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 int elf_sort_sections (const void *, const void *);
44 static bfd_boolean
assign_file_positions_except_relocs (bfd
*);
45 static bfd_boolean
prep_headers (bfd
*);
46 static bfd_boolean
swap_out_syms (bfd
*, struct bfd_strtab_hash
**, int) ;
47 static bfd_boolean
elfcore_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
49 /* Swap version information in and out. The version information is
50 currently size independent. If that ever changes, this code will
51 need to move into elfcode.h. */
53 /* Swap in a Verdef structure. */
56 _bfd_elf_swap_verdef_in (bfd
*abfd
,
57 const Elf_External_Verdef
*src
,
58 Elf_Internal_Verdef
*dst
)
60 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
61 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
62 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
63 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
64 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
65 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
66 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
69 /* Swap out a Verdef structure. */
72 _bfd_elf_swap_verdef_out (bfd
*abfd
,
73 const Elf_Internal_Verdef
*src
,
74 Elf_External_Verdef
*dst
)
76 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
77 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
78 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
79 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
80 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
81 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
82 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
85 /* Swap in a Verdaux structure. */
88 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
89 const Elf_External_Verdaux
*src
,
90 Elf_Internal_Verdaux
*dst
)
92 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
93 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
96 /* Swap out a Verdaux structure. */
99 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
100 const Elf_Internal_Verdaux
*src
,
101 Elf_External_Verdaux
*dst
)
103 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
104 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
107 /* Swap in a Verneed structure. */
110 _bfd_elf_swap_verneed_in (bfd
*abfd
,
111 const Elf_External_Verneed
*src
,
112 Elf_Internal_Verneed
*dst
)
114 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
115 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
116 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
117 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
118 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
121 /* Swap out a Verneed structure. */
124 _bfd_elf_swap_verneed_out (bfd
*abfd
,
125 const Elf_Internal_Verneed
*src
,
126 Elf_External_Verneed
*dst
)
128 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
129 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
130 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
131 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
132 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
135 /* Swap in a Vernaux structure. */
138 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
139 const Elf_External_Vernaux
*src
,
140 Elf_Internal_Vernaux
*dst
)
142 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
143 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
144 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
145 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
146 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
149 /* Swap out a Vernaux structure. */
152 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
153 const Elf_Internal_Vernaux
*src
,
154 Elf_External_Vernaux
*dst
)
156 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
157 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
158 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
159 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
160 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
163 /* Swap in a Versym structure. */
166 _bfd_elf_swap_versym_in (bfd
*abfd
,
167 const Elf_External_Versym
*src
,
168 Elf_Internal_Versym
*dst
)
170 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
173 /* Swap out a Versym structure. */
176 _bfd_elf_swap_versym_out (bfd
*abfd
,
177 const Elf_Internal_Versym
*src
,
178 Elf_External_Versym
*dst
)
180 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
183 /* Standard ELF hash function. Do not change this function; you will
184 cause invalid hash tables to be generated. */
187 bfd_elf_hash (const char *namearg
)
189 const unsigned char *name
= (const unsigned char *) namearg
;
194 while ((ch
= *name
++) != '\0')
197 if ((g
= (h
& 0xf0000000)) != 0)
200 /* The ELF ABI says `h &= ~g', but this is equivalent in
201 this case and on some machines one insn instead of two. */
205 return h
& 0xffffffff;
208 /* Read a specified number of bytes at a specified offset in an ELF
209 file, into a newly allocated buffer, and return a pointer to the
213 elf_read (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
217 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
219 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
221 if (bfd_bread (buf
, size
, abfd
) != size
)
223 if (bfd_get_error () != bfd_error_system_call
)
224 bfd_set_error (bfd_error_file_truncated
);
231 bfd_elf_mkobject (bfd
*abfd
)
233 /* This just does initialization. */
234 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
235 elf_tdata (abfd
) = bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
236 if (elf_tdata (abfd
) == 0)
238 /* Since everything is done at close time, do we need any
245 bfd_elf_mkcorefile (bfd
*abfd
)
247 /* I think this can be done just like an object file. */
248 return bfd_elf_mkobject (abfd
);
252 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
254 Elf_Internal_Shdr
**i_shdrp
;
255 char *shstrtab
= NULL
;
257 bfd_size_type shstrtabsize
;
259 i_shdrp
= elf_elfsections (abfd
);
260 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
263 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
264 if (shstrtab
== NULL
)
266 /* No cached one, attempt to read, and cache what we read. */
267 offset
= i_shdrp
[shindex
]->sh_offset
;
268 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
269 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
270 i_shdrp
[shindex
]->contents
= shstrtab
;
276 bfd_elf_string_from_elf_section (bfd
*abfd
,
277 unsigned int shindex
,
278 unsigned int strindex
)
280 Elf_Internal_Shdr
*hdr
;
285 hdr
= elf_elfsections (abfd
)[shindex
];
287 if (hdr
->contents
== NULL
288 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
291 if (strindex
>= hdr
->sh_size
)
293 (*_bfd_error_handler
)
294 (_("%s: invalid string offset %u >= %lu for section `%s'"),
295 bfd_archive_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
296 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
297 && strindex
== hdr
->sh_name
)
299 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
303 return ((char *) hdr
->contents
) + strindex
;
306 /* Read and convert symbols to internal format.
307 SYMCOUNT specifies the number of symbols to read, starting from
308 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
309 are non-NULL, they are used to store the internal symbols, external
310 symbols, and symbol section index extensions, respectively. */
313 bfd_elf_get_elf_syms (bfd
*ibfd
,
314 Elf_Internal_Shdr
*symtab_hdr
,
317 Elf_Internal_Sym
*intsym_buf
,
319 Elf_External_Sym_Shndx
*extshndx_buf
)
321 Elf_Internal_Shdr
*shndx_hdr
;
323 const bfd_byte
*esym
;
324 Elf_External_Sym_Shndx
*alloc_extshndx
;
325 Elf_External_Sym_Shndx
*shndx
;
326 Elf_Internal_Sym
*isym
;
327 Elf_Internal_Sym
*isymend
;
328 const struct elf_backend_data
*bed
;
336 /* Normal syms might have section extension entries. */
338 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
339 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
341 /* Read the symbols. */
343 alloc_extshndx
= NULL
;
344 bed
= get_elf_backend_data (ibfd
);
345 extsym_size
= bed
->s
->sizeof_sym
;
346 amt
= symcount
* extsym_size
;
347 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
348 if (extsym_buf
== NULL
)
350 alloc_ext
= bfd_malloc (amt
);
351 extsym_buf
= alloc_ext
;
353 if (extsym_buf
== NULL
354 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
355 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
361 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
365 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
366 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
367 if (extshndx_buf
== NULL
)
369 alloc_extshndx
= bfd_malloc (amt
);
370 extshndx_buf
= alloc_extshndx
;
372 if (extshndx_buf
== NULL
373 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
374 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
381 if (intsym_buf
== NULL
)
383 bfd_size_type amt
= symcount
* sizeof (Elf_Internal_Sym
);
384 intsym_buf
= bfd_malloc (amt
);
385 if (intsym_buf
== NULL
)
389 /* Convert the symbols to internal form. */
390 isymend
= intsym_buf
+ symcount
;
391 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
393 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
394 (*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
);
397 if (alloc_ext
!= NULL
)
399 if (alloc_extshndx
!= NULL
)
400 free (alloc_extshndx
);
405 /* Look up a symbol name. */
407 bfd_elf_local_sym_name (bfd
*abfd
, Elf_Internal_Sym
*isym
)
409 unsigned int iname
= isym
->st_name
;
410 unsigned int shindex
= elf_tdata (abfd
)->symtab_hdr
.sh_link
;
411 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
413 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
414 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
417 return bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
420 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
421 sections. The first element is the flags, the rest are section
424 typedef union elf_internal_group
{
425 Elf_Internal_Shdr
*shdr
;
427 } Elf_Internal_Group
;
429 /* Return the name of the group signature symbol. Why isn't the
430 signature just a string? */
433 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
435 Elf_Internal_Shdr
*hdr
;
436 unsigned char esym
[sizeof (Elf64_External_Sym
)];
437 Elf_External_Sym_Shndx eshndx
;
438 Elf_Internal_Sym isym
;
440 /* First we need to ensure the symbol table is available. */
441 if (! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
444 /* Go read the symbol. */
445 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
446 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
447 &isym
, esym
, &eshndx
) == NULL
)
450 return bfd_elf_local_sym_name (abfd
, &isym
);
453 /* Set next_in_group list pointer, and group name for NEWSECT. */
456 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
458 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
460 /* If num_group is zero, read in all SHT_GROUP sections. The count
461 is set to -1 if there are no SHT_GROUP sections. */
464 unsigned int i
, shnum
;
466 /* First count the number of groups. If we have a SHT_GROUP
467 section with just a flag word (ie. sh_size is 4), ignore it. */
468 shnum
= elf_numsections (abfd
);
470 for (i
= 0; i
< shnum
; i
++)
472 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
473 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
478 num_group
= (unsigned) -1;
479 elf_tdata (abfd
)->num_group
= num_group
;
483 /* We keep a list of elf section headers for group sections,
484 so we can find them quickly. */
485 bfd_size_type amt
= num_group
* sizeof (Elf_Internal_Shdr
*);
486 elf_tdata (abfd
)->group_sect_ptr
= bfd_alloc (abfd
, amt
);
487 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
491 for (i
= 0; i
< shnum
; i
++)
493 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
494 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
497 Elf_Internal_Group
*dest
;
499 /* Add to list of sections. */
500 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
503 /* Read the raw contents. */
504 BFD_ASSERT (sizeof (*dest
) >= 4);
505 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
506 shdr
->contents
= bfd_alloc (abfd
, amt
);
507 if (shdr
->contents
== NULL
508 || bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
509 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
513 /* Translate raw contents, a flag word followed by an
514 array of elf section indices all in target byte order,
515 to the flag word followed by an array of elf section
517 src
= shdr
->contents
+ shdr
->sh_size
;
518 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
525 idx
= H_GET_32 (abfd
, src
);
526 if (src
== shdr
->contents
)
529 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
530 shdr
->bfd_section
->flags
531 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
536 ((*_bfd_error_handler
)
537 (_("%s: invalid SHT_GROUP entry"),
538 bfd_archive_filename (abfd
)));
541 dest
->shdr
= elf_elfsections (abfd
)[idx
];
548 if (num_group
!= (unsigned) -1)
552 for (i
= 0; i
< num_group
; i
++)
554 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
555 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
556 unsigned int n_elt
= shdr
->sh_size
/ 4;
558 /* Look through this group's sections to see if current
559 section is a member. */
561 if ((++idx
)->shdr
== hdr
)
565 /* We are a member of this group. Go looking through
566 other members to see if any others are linked via
568 idx
= (Elf_Internal_Group
*) shdr
->contents
;
569 n_elt
= shdr
->sh_size
/ 4;
571 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
572 && elf_next_in_group (s
) != NULL
)
576 /* Snarf the group name from other member, and
577 insert current section in circular list. */
578 elf_group_name (newsect
) = elf_group_name (s
);
579 elf_next_in_group (newsect
) = elf_next_in_group (s
);
580 elf_next_in_group (s
) = newsect
;
586 gname
= group_signature (abfd
, shdr
);
589 elf_group_name (newsect
) = gname
;
591 /* Start a circular list with one element. */
592 elf_next_in_group (newsect
) = newsect
;
595 /* If the group section has been created, point to the
597 if (shdr
->bfd_section
!= NULL
)
598 elf_next_in_group (shdr
->bfd_section
) = newsect
;
606 if (elf_group_name (newsect
) == NULL
)
608 (*_bfd_error_handler
) (_("%s: no group info for section %s"),
609 bfd_archive_filename (abfd
), newsect
->name
);
615 bfd_elf_discard_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*group
)
617 asection
*first
= elf_next_in_group (group
);
622 s
->output_section
= bfd_abs_section_ptr
;
623 s
= elf_next_in_group (s
);
624 /* These lists are circular. */
631 /* Make a BFD section from an ELF section. We store a pointer to the
632 BFD section in the bfd_section field of the header. */
635 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
636 Elf_Internal_Shdr
*hdr
,
641 const struct elf_backend_data
*bed
;
643 if (hdr
->bfd_section
!= NULL
)
645 BFD_ASSERT (strcmp (name
,
646 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
650 newsect
= bfd_make_section_anyway (abfd
, name
);
654 /* Always use the real type/flags. */
655 elf_section_type (newsect
) = hdr
->sh_type
;
656 elf_section_flags (newsect
) = hdr
->sh_flags
;
658 newsect
->filepos
= hdr
->sh_offset
;
660 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
661 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
662 || ! bfd_set_section_alignment (abfd
, newsect
,
663 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
666 flags
= SEC_NO_FLAGS
;
667 if (hdr
->sh_type
!= SHT_NOBITS
)
668 flags
|= SEC_HAS_CONTENTS
;
669 if (hdr
->sh_type
== SHT_GROUP
)
670 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
671 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
674 if (hdr
->sh_type
!= SHT_NOBITS
)
677 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
678 flags
|= SEC_READONLY
;
679 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
681 else if ((flags
& SEC_LOAD
) != 0)
683 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
686 newsect
->entsize
= hdr
->sh_entsize
;
687 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
688 flags
|= SEC_STRINGS
;
690 if (hdr
->sh_flags
& SHF_GROUP
)
691 if (!setup_group (abfd
, hdr
, newsect
))
693 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
694 flags
|= SEC_THREAD_LOCAL
;
696 /* The debugging sections appear to be recognized only by name, not
699 static const char *debug_sec_names
[] =
708 for (i
= ARRAY_SIZE (debug_sec_names
); i
--;)
709 if (strncmp (name
, debug_sec_names
[i
], strlen (debug_sec_names
[i
])) == 0)
713 flags
|= SEC_DEBUGGING
;
716 /* As a GNU extension, if the name begins with .gnu.linkonce, we
717 only link a single copy of the section. This is used to support
718 g++. g++ will emit each template expansion in its own section.
719 The symbols will be defined as weak, so that multiple definitions
720 are permitted. The GNU linker extension is to actually discard
721 all but one of the sections. */
722 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
723 && elf_next_in_group (newsect
) == NULL
)
724 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
726 bed
= get_elf_backend_data (abfd
);
727 if (bed
->elf_backend_section_flags
)
728 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
731 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
734 if ((flags
& SEC_ALLOC
) != 0)
736 Elf_Internal_Phdr
*phdr
;
739 /* Look through the phdrs to see if we need to adjust the lma.
740 If all the p_paddr fields are zero, we ignore them, since
741 some ELF linkers produce such output. */
742 phdr
= elf_tdata (abfd
)->phdr
;
743 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
745 if (phdr
->p_paddr
!= 0)
748 if (i
< elf_elfheader (abfd
)->e_phnum
)
750 phdr
= elf_tdata (abfd
)->phdr
;
751 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
753 /* This section is part of this segment if its file
754 offset plus size lies within the segment's memory
755 span and, if the section is loaded, the extent of the
756 loaded data lies within the extent of the segment.
758 Note - we used to check the p_paddr field as well, and
759 refuse to set the LMA if it was 0. This is wrong
760 though, as a perfectly valid initialised segment can
761 have a p_paddr of zero. Some architectures, eg ARM,
762 place special significance on the address 0 and
763 executables need to be able to have a segment which
764 covers this address. */
765 if (phdr
->p_type
== PT_LOAD
766 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
767 && (hdr
->sh_offset
+ hdr
->sh_size
768 <= phdr
->p_offset
+ phdr
->p_memsz
)
769 && ((flags
& SEC_LOAD
) == 0
770 || (hdr
->sh_offset
+ hdr
->sh_size
771 <= phdr
->p_offset
+ phdr
->p_filesz
)))
773 if ((flags
& SEC_LOAD
) == 0)
774 newsect
->lma
= (phdr
->p_paddr
775 + hdr
->sh_addr
- phdr
->p_vaddr
);
777 /* We used to use the same adjustment for SEC_LOAD
778 sections, but that doesn't work if the segment
779 is packed with code from multiple VMAs.
780 Instead we calculate the section LMA based on
781 the segment LMA. It is assumed that the
782 segment will contain sections with contiguous
783 LMAs, even if the VMAs are not. */
784 newsect
->lma
= (phdr
->p_paddr
785 + hdr
->sh_offset
- phdr
->p_offset
);
787 /* With contiguous segments, we can't tell from file
788 offsets whether a section with zero size should
789 be placed at the end of one segment or the
790 beginning of the next. Decide based on vaddr. */
791 if (hdr
->sh_addr
>= phdr
->p_vaddr
792 && (hdr
->sh_addr
+ hdr
->sh_size
793 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
800 hdr
->bfd_section
= newsect
;
801 elf_section_data (newsect
)->this_hdr
= *hdr
;
811 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
814 Helper functions for GDB to locate the string tables.
815 Since BFD hides string tables from callers, GDB needs to use an
816 internal hook to find them. Sun's .stabstr, in particular,
817 isn't even pointed to by the .stab section, so ordinary
818 mechanisms wouldn't work to find it, even if we had some.
821 struct elf_internal_shdr
*
822 bfd_elf_find_section (bfd
*abfd
, char *name
)
824 Elf_Internal_Shdr
**i_shdrp
;
829 i_shdrp
= elf_elfsections (abfd
);
832 shstrtab
= bfd_elf_get_str_section (abfd
,
833 elf_elfheader (abfd
)->e_shstrndx
);
834 if (shstrtab
!= NULL
)
836 max
= elf_numsections (abfd
);
837 for (i
= 1; i
< max
; i
++)
838 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
845 const char *const bfd_elf_section_type_names
[] = {
846 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
847 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
848 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
851 /* ELF relocs are against symbols. If we are producing relocatable
852 output, and the reloc is against an external symbol, and nothing
853 has given us any additional addend, the resulting reloc will also
854 be against the same symbol. In such a case, we don't want to
855 change anything about the way the reloc is handled, since it will
856 all be done at final link time. Rather than put special case code
857 into bfd_perform_relocation, all the reloc types use this howto
858 function. It just short circuits the reloc if producing
859 relocatable output against an external symbol. */
861 bfd_reloc_status_type
862 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
863 arelent
*reloc_entry
,
865 void *data ATTRIBUTE_UNUSED
,
866 asection
*input_section
,
868 char **error_message ATTRIBUTE_UNUSED
)
870 if (output_bfd
!= NULL
871 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
872 && (! reloc_entry
->howto
->partial_inplace
873 || reloc_entry
->addend
== 0))
875 reloc_entry
->address
+= input_section
->output_offset
;
879 return bfd_reloc_continue
;
882 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
885 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
888 BFD_ASSERT (sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
889 sec
->sec_info_type
= ELF_INFO_TYPE_NONE
;
892 /* Finish SHF_MERGE section merging. */
895 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
897 if (!is_elf_hash_table (info
))
899 if (elf_hash_table (info
)->merge_info
)
900 _bfd_merge_sections (abfd
, elf_hash_table (info
)->merge_info
,
901 merge_sections_remove_hook
);
906 _bfd_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
908 sec
->output_section
= bfd_abs_section_ptr
;
909 sec
->output_offset
= sec
->vma
;
910 if (!is_elf_hash_table (info
))
913 sec
->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
916 /* Copy the program header and other data from one object module to
920 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
922 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
923 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
926 BFD_ASSERT (!elf_flags_init (obfd
)
927 || (elf_elfheader (obfd
)->e_flags
928 == elf_elfheader (ibfd
)->e_flags
));
930 elf_gp (obfd
) = elf_gp (ibfd
);
931 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
932 elf_flags_init (obfd
) = TRUE
;
936 /* Print out the program headers. */
939 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
942 Elf_Internal_Phdr
*p
;
944 bfd_byte
*dynbuf
= NULL
;
946 p
= elf_tdata (abfd
)->phdr
;
951 fprintf (f
, _("\nProgram Header:\n"));
952 c
= elf_elfheader (abfd
)->e_phnum
;
953 for (i
= 0; i
< c
; i
++, p
++)
960 case PT_NULL
: pt
= "NULL"; break;
961 case PT_LOAD
: pt
= "LOAD"; break;
962 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
963 case PT_INTERP
: pt
= "INTERP"; break;
964 case PT_NOTE
: pt
= "NOTE"; break;
965 case PT_SHLIB
: pt
= "SHLIB"; break;
966 case PT_PHDR
: pt
= "PHDR"; break;
967 case PT_TLS
: pt
= "TLS"; break;
968 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
969 case PT_GNU_STACK
: pt
= "STACK"; break;
970 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
972 fprintf (f
, "%8s off 0x", pt
);
973 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
974 fprintf (f
, " vaddr 0x");
975 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
976 fprintf (f
, " paddr 0x");
977 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
978 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
979 fprintf (f
, " filesz 0x");
980 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
981 fprintf (f
, " memsz 0x");
982 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
983 fprintf (f
, " flags %c%c%c",
984 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
985 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
986 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
987 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
988 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
993 s
= bfd_get_section_by_name (abfd
, ".dynamic");
997 unsigned long shlink
;
998 bfd_byte
*extdyn
, *extdynend
;
1000 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1002 fprintf (f
, _("\nDynamic Section:\n"));
1004 dynbuf
= bfd_malloc (s
->_raw_size
);
1007 if (! bfd_get_section_contents (abfd
, s
, dynbuf
, 0, s
->_raw_size
))
1010 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1013 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1015 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1016 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1019 extdynend
= extdyn
+ s
->_raw_size
;
1020 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1022 Elf_Internal_Dyn dyn
;
1025 bfd_boolean stringp
;
1027 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1029 if (dyn
.d_tag
== DT_NULL
)
1036 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1040 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1041 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1042 case DT_PLTGOT
: name
= "PLTGOT"; break;
1043 case DT_HASH
: name
= "HASH"; break;
1044 case DT_STRTAB
: name
= "STRTAB"; break;
1045 case DT_SYMTAB
: name
= "SYMTAB"; break;
1046 case DT_RELA
: name
= "RELA"; break;
1047 case DT_RELASZ
: name
= "RELASZ"; break;
1048 case DT_RELAENT
: name
= "RELAENT"; break;
1049 case DT_STRSZ
: name
= "STRSZ"; break;
1050 case DT_SYMENT
: name
= "SYMENT"; break;
1051 case DT_INIT
: name
= "INIT"; break;
1052 case DT_FINI
: name
= "FINI"; break;
1053 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1054 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1055 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1056 case DT_REL
: name
= "REL"; break;
1057 case DT_RELSZ
: name
= "RELSZ"; break;
1058 case DT_RELENT
: name
= "RELENT"; break;
1059 case DT_PLTREL
: name
= "PLTREL"; break;
1060 case DT_DEBUG
: name
= "DEBUG"; break;
1061 case DT_TEXTREL
: name
= "TEXTREL"; break;
1062 case DT_JMPREL
: name
= "JMPREL"; break;
1063 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1064 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1065 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1066 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1067 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1068 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1069 case DT_FLAGS
: name
= "FLAGS"; break;
1070 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1071 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1072 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1073 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1074 case DT_MOVEENT
: name
= "MOVEENT"; break;
1075 case DT_MOVESZ
: name
= "MOVESZ"; break;
1076 case DT_FEATURE
: name
= "FEATURE"; break;
1077 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1078 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1079 case DT_SYMINENT
: name
= "SYMINENT"; break;
1080 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1081 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1082 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1083 case DT_PLTPAD
: name
= "PLTPAD"; break;
1084 case DT_MOVETAB
: name
= "MOVETAB"; break;
1085 case DT_SYMINFO
: name
= "SYMINFO"; break;
1086 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1087 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1088 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1089 case DT_VERSYM
: name
= "VERSYM"; break;
1090 case DT_VERDEF
: name
= "VERDEF"; break;
1091 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1092 case DT_VERNEED
: name
= "VERNEED"; break;
1093 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1094 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1095 case DT_USED
: name
= "USED"; break;
1096 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1099 fprintf (f
, " %-11s ", name
);
1101 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1105 unsigned int tagv
= dyn
.d_un
.d_val
;
1107 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1110 fprintf (f
, "%s", string
);
1119 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1120 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1122 if (! _bfd_elf_slurp_version_tables (abfd
))
1126 if (elf_dynverdef (abfd
) != 0)
1128 Elf_Internal_Verdef
*t
;
1130 fprintf (f
, _("\nVersion definitions:\n"));
1131 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1133 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1134 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1135 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1137 Elf_Internal_Verdaux
*a
;
1140 for (a
= t
->vd_auxptr
->vda_nextptr
;
1143 fprintf (f
, "%s ", a
->vda_nodename
);
1149 if (elf_dynverref (abfd
) != 0)
1151 Elf_Internal_Verneed
*t
;
1153 fprintf (f
, _("\nVersion References:\n"));
1154 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1156 Elf_Internal_Vernaux
*a
;
1158 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1159 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1160 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1161 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1173 /* Display ELF-specific fields of a symbol. */
1176 bfd_elf_print_symbol (bfd
*abfd
,
1179 bfd_print_symbol_type how
)
1184 case bfd_print_symbol_name
:
1185 fprintf (file
, "%s", symbol
->name
);
1187 case bfd_print_symbol_more
:
1188 fprintf (file
, "elf ");
1189 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1190 fprintf (file
, " %lx", (long) symbol
->flags
);
1192 case bfd_print_symbol_all
:
1194 const char *section_name
;
1195 const char *name
= NULL
;
1196 const struct elf_backend_data
*bed
;
1197 unsigned char st_other
;
1200 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1202 bed
= get_elf_backend_data (abfd
);
1203 if (bed
->elf_backend_print_symbol_all
)
1204 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1208 name
= symbol
->name
;
1209 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1212 fprintf (file
, " %s\t", section_name
);
1213 /* Print the "other" value for a symbol. For common symbols,
1214 we've already printed the size; now print the alignment.
1215 For other symbols, we have no specified alignment, and
1216 we've printed the address; now print the size. */
1217 if (bfd_is_com_section (symbol
->section
))
1218 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1220 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1221 bfd_fprintf_vma (abfd
, file
, val
);
1223 /* If we have version information, print it. */
1224 if (elf_tdata (abfd
)->dynversym_section
!= 0
1225 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1226 || elf_tdata (abfd
)->dynverref_section
!= 0))
1228 unsigned int vernum
;
1229 const char *version_string
;
1231 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1234 version_string
= "";
1235 else if (vernum
== 1)
1236 version_string
= "Base";
1237 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1239 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1242 Elf_Internal_Verneed
*t
;
1244 version_string
= "";
1245 for (t
= elf_tdata (abfd
)->verref
;
1249 Elf_Internal_Vernaux
*a
;
1251 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1253 if (a
->vna_other
== vernum
)
1255 version_string
= a
->vna_nodename
;
1262 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1263 fprintf (file
, " %-11s", version_string
);
1268 fprintf (file
, " (%s)", version_string
);
1269 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1274 /* If the st_other field is not zero, print it. */
1275 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1280 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1281 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1282 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1284 /* Some other non-defined flags are also present, so print
1286 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1289 fprintf (file
, " %s", name
);
1295 /* Create an entry in an ELF linker hash table. */
1297 struct bfd_hash_entry
*
1298 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1299 struct bfd_hash_table
*table
,
1302 /* Allocate the structure if it has not already been allocated by a
1306 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1311 /* Call the allocation method of the superclass. */
1312 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1315 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1316 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1318 /* Set local fields. */
1321 ret
->dynstr_index
= 0;
1322 ret
->elf_hash_value
= 0;
1323 ret
->weakdef
= NULL
;
1324 ret
->verinfo
.verdef
= NULL
;
1325 ret
->vtable_entries_size
= 0;
1326 ret
->vtable_entries_used
= NULL
;
1327 ret
->vtable_parent
= NULL
;
1328 ret
->got
= htab
->init_refcount
;
1329 ret
->plt
= htab
->init_refcount
;
1331 ret
->type
= STT_NOTYPE
;
1333 /* Assume that we have been called by a non-ELF symbol reader.
1334 This flag is then reset by the code which reads an ELF input
1335 file. This ensures that a symbol created by a non-ELF symbol
1336 reader will have the flag set correctly. */
1337 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
1343 /* Copy data from an indirect symbol to its direct symbol, hiding the
1344 old indirect symbol. Also used for copying flags to a weakdef. */
1347 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data
*bed
,
1348 struct elf_link_hash_entry
*dir
,
1349 struct elf_link_hash_entry
*ind
)
1352 bfd_signed_vma lowest_valid
= bed
->can_refcount
;
1354 /* Copy down any references that we may have already seen to the
1355 symbol which just became indirect. */
1357 dir
->elf_link_hash_flags
|=
1358 (ind
->elf_link_hash_flags
1359 & (ELF_LINK_HASH_REF_DYNAMIC
1360 | ELF_LINK_HASH_REF_REGULAR
1361 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1362 | ELF_LINK_NON_GOT_REF
));
1364 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1367 /* Copy over the global and procedure linkage table refcount entries.
1368 These may have been already set up by a check_relocs routine. */
1369 tmp
= dir
->got
.refcount
;
1370 if (tmp
< lowest_valid
)
1372 dir
->got
.refcount
= ind
->got
.refcount
;
1373 ind
->got
.refcount
= tmp
;
1376 BFD_ASSERT (ind
->got
.refcount
< lowest_valid
);
1378 tmp
= dir
->plt
.refcount
;
1379 if (tmp
< lowest_valid
)
1381 dir
->plt
.refcount
= ind
->plt
.refcount
;
1382 ind
->plt
.refcount
= tmp
;
1385 BFD_ASSERT (ind
->plt
.refcount
< lowest_valid
);
1387 if (dir
->dynindx
== -1)
1389 dir
->dynindx
= ind
->dynindx
;
1390 dir
->dynstr_index
= ind
->dynstr_index
;
1392 ind
->dynstr_index
= 0;
1395 BFD_ASSERT (ind
->dynindx
== -1);
1399 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
1400 struct elf_link_hash_entry
*h
,
1401 bfd_boolean force_local
)
1403 h
->plt
= elf_hash_table (info
)->init_offset
;
1404 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1407 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
1408 if (h
->dynindx
!= -1)
1411 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1417 /* Initialize an ELF linker hash table. */
1420 _bfd_elf_link_hash_table_init
1421 (struct elf_link_hash_table
*table
,
1423 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
1424 struct bfd_hash_table
*,
1429 table
->dynamic_sections_created
= FALSE
;
1430 table
->dynobj
= NULL
;
1431 /* Make sure can_refcount is extended to the width and signedness of
1432 init_refcount before we subtract one from it. */
1433 table
->init_refcount
.refcount
= get_elf_backend_data (abfd
)->can_refcount
;
1434 table
->init_refcount
.refcount
-= 1;
1435 table
->init_offset
.offset
= -(bfd_vma
) 1;
1436 /* The first dynamic symbol is a dummy. */
1437 table
->dynsymcount
= 1;
1438 table
->dynstr
= NULL
;
1439 table
->bucketcount
= 0;
1440 table
->needed
= NULL
;
1442 table
->stab_info
= NULL
;
1443 table
->merge_info
= NULL
;
1444 memset (&table
->eh_info
, 0, sizeof (table
->eh_info
));
1445 table
->dynlocal
= NULL
;
1446 table
->runpath
= NULL
;
1447 table
->tls_segment
= NULL
;
1448 table
->loaded
= NULL
;
1450 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
1451 table
->root
.type
= bfd_link_elf_hash_table
;
1456 /* Create an ELF linker hash table. */
1458 struct bfd_link_hash_table
*
1459 _bfd_elf_link_hash_table_create (bfd
*abfd
)
1461 struct elf_link_hash_table
*ret
;
1462 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1464 ret
= bfd_malloc (amt
);
1468 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1477 /* This is a hook for the ELF emulation code in the generic linker to
1478 tell the backend linker what file name to use for the DT_NEEDED
1479 entry for a dynamic object. The generic linker passes name as an
1480 empty string to indicate that no DT_NEEDED entry should be made. */
1483 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
1485 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1486 && bfd_get_format (abfd
) == bfd_object
)
1487 elf_dt_name (abfd
) = name
;
1491 bfd_elf_set_dt_needed_soname (bfd
*abfd
, const char *name
)
1493 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1494 && bfd_get_format (abfd
) == bfd_object
)
1495 elf_dt_soname (abfd
) = name
;
1498 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1499 the linker ELF emulation code. */
1501 struct bfd_link_needed_list
*
1502 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1503 struct bfd_link_info
*info
)
1505 if (! is_elf_hash_table (info
))
1507 return elf_hash_table (info
)->needed
;
1510 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1511 hook for the linker ELF emulation code. */
1513 struct bfd_link_needed_list
*
1514 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1515 struct bfd_link_info
*info
)
1517 if (! is_elf_hash_table (info
))
1519 return elf_hash_table (info
)->runpath
;
1522 /* Get the name actually used for a dynamic object for a link. This
1523 is the SONAME entry if there is one. Otherwise, it is the string
1524 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1527 bfd_elf_get_dt_soname (bfd
*abfd
)
1529 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1530 && bfd_get_format (abfd
) == bfd_object
)
1531 return elf_dt_name (abfd
);
1535 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1536 the ELF linker emulation code. */
1539 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
1540 struct bfd_link_needed_list
**pneeded
)
1543 bfd_byte
*dynbuf
= NULL
;
1545 unsigned long shlink
;
1546 bfd_byte
*extdyn
, *extdynend
;
1548 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1552 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1553 || bfd_get_format (abfd
) != bfd_object
)
1556 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1557 if (s
== NULL
|| s
->_raw_size
== 0)
1560 dynbuf
= bfd_malloc (s
->_raw_size
);
1564 if (! bfd_get_section_contents (abfd
, s
, dynbuf
, 0, s
->_raw_size
))
1567 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1571 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1573 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1574 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1577 extdynend
= extdyn
+ s
->_raw_size
;
1578 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1580 Elf_Internal_Dyn dyn
;
1582 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1584 if (dyn
.d_tag
== DT_NULL
)
1587 if (dyn
.d_tag
== DT_NEEDED
)
1590 struct bfd_link_needed_list
*l
;
1591 unsigned int tagv
= dyn
.d_un
.d_val
;
1594 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1599 l
= bfd_alloc (abfd
, amt
);
1620 /* Allocate an ELF string table--force the first byte to be zero. */
1622 struct bfd_strtab_hash
*
1623 _bfd_elf_stringtab_init (void)
1625 struct bfd_strtab_hash
*ret
;
1627 ret
= _bfd_stringtab_init ();
1632 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1633 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1634 if (loc
== (bfd_size_type
) -1)
1636 _bfd_stringtab_free (ret
);
1643 /* ELF .o/exec file reading */
1645 /* Create a new bfd section from an ELF section header. */
1648 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1650 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1651 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1652 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1655 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1657 switch (hdr
->sh_type
)
1660 /* Inactive section. Throw it away. */
1663 case SHT_PROGBITS
: /* Normal section with contents. */
1664 case SHT_NOBITS
: /* .bss section. */
1665 case SHT_HASH
: /* .hash section. */
1666 case SHT_NOTE
: /* .note section. */
1667 case SHT_INIT_ARRAY
: /* .init_array section. */
1668 case SHT_FINI_ARRAY
: /* .fini_array section. */
1669 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1670 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1672 case SHT_DYNAMIC
: /* Dynamic linking information. */
1673 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1675 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1677 Elf_Internal_Shdr
*dynsymhdr
;
1679 /* The shared libraries distributed with hpux11 have a bogus
1680 sh_link field for the ".dynamic" section. Find the
1681 string table for the ".dynsym" section instead. */
1682 if (elf_dynsymtab (abfd
) != 0)
1684 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1685 hdr
->sh_link
= dynsymhdr
->sh_link
;
1689 unsigned int i
, num_sec
;
1691 num_sec
= elf_numsections (abfd
);
1692 for (i
= 1; i
< num_sec
; i
++)
1694 dynsymhdr
= elf_elfsections (abfd
)[i
];
1695 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1697 hdr
->sh_link
= dynsymhdr
->sh_link
;
1705 case SHT_SYMTAB
: /* A symbol table */
1706 if (elf_onesymtab (abfd
) == shindex
)
1709 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1710 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1711 elf_onesymtab (abfd
) = shindex
;
1712 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1713 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1714 abfd
->flags
|= HAS_SYMS
;
1716 /* Sometimes a shared object will map in the symbol table. If
1717 SHF_ALLOC is set, and this is a shared object, then we also
1718 treat this section as a BFD section. We can not base the
1719 decision purely on SHF_ALLOC, because that flag is sometimes
1720 set in a relocatable object file, which would confuse the
1722 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1723 && (abfd
->flags
& DYNAMIC
) != 0
1724 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1729 case SHT_DYNSYM
: /* A dynamic symbol table */
1730 if (elf_dynsymtab (abfd
) == shindex
)
1733 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1734 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1735 elf_dynsymtab (abfd
) = shindex
;
1736 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1737 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1738 abfd
->flags
|= HAS_SYMS
;
1740 /* Besides being a symbol table, we also treat this as a regular
1741 section, so that objcopy can handle it. */
1742 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1744 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1745 if (elf_symtab_shndx (abfd
) == shindex
)
1748 /* Get the associated symbol table. */
1749 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
)
1750 || hdr
->sh_link
!= elf_onesymtab (abfd
))
1753 elf_symtab_shndx (abfd
) = shindex
;
1754 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1755 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1758 case SHT_STRTAB
: /* A string table */
1759 if (hdr
->bfd_section
!= NULL
)
1761 if (ehdr
->e_shstrndx
== shindex
)
1763 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1764 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1768 unsigned int i
, num_sec
;
1770 num_sec
= elf_numsections (abfd
);
1771 for (i
= 1; i
< num_sec
; i
++)
1773 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1774 if (hdr2
->sh_link
== shindex
)
1776 if (! bfd_section_from_shdr (abfd
, i
))
1778 if (elf_onesymtab (abfd
) == i
)
1780 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1781 elf_elfsections (abfd
)[shindex
] =
1782 &elf_tdata (abfd
)->strtab_hdr
;
1785 if (elf_dynsymtab (abfd
) == i
)
1787 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1788 elf_elfsections (abfd
)[shindex
] = hdr
=
1789 &elf_tdata (abfd
)->dynstrtab_hdr
;
1790 /* We also treat this as a regular section, so
1791 that objcopy can handle it. */
1794 #if 0 /* Not handling other string tables specially right now. */
1795 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1796 /* We have a strtab for some random other section. */
1797 newsect
= (asection
*) hdr2
->bfd_section
;
1800 hdr
->bfd_section
= newsect
;
1801 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1803 elf_elfsections (abfd
)[shindex
] = hdr2
;
1809 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1813 /* *These* do a lot of work -- but build no sections! */
1815 asection
*target_sect
;
1816 Elf_Internal_Shdr
*hdr2
;
1817 unsigned int num_sec
= elf_numsections (abfd
);
1819 /* Check for a bogus link to avoid crashing. */
1820 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1821 || hdr
->sh_link
>= num_sec
)
1823 ((*_bfd_error_handler
)
1824 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1825 bfd_archive_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1826 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1829 /* For some incomprehensible reason Oracle distributes
1830 libraries for Solaris in which some of the objects have
1831 bogus sh_link fields. It would be nice if we could just
1832 reject them, but, unfortunately, some people need to use
1833 them. We scan through the section headers; if we find only
1834 one suitable symbol table, we clobber the sh_link to point
1835 to it. I hope this doesn't break anything. */
1836 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1837 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1843 for (scan
= 1; scan
< num_sec
; scan
++)
1845 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1846 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1857 hdr
->sh_link
= found
;
1860 /* Get the symbol table. */
1861 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1862 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1865 /* If this reloc section does not use the main symbol table we
1866 don't treat it as a reloc section. BFD can't adequately
1867 represent such a section, so at least for now, we don't
1868 try. We just present it as a normal section. We also
1869 can't use it as a reloc section if it points to the null
1871 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1872 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1874 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1876 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1877 if (target_sect
== NULL
)
1880 if ((target_sect
->flags
& SEC_RELOC
) == 0
1881 || target_sect
->reloc_count
== 0)
1882 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1886 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1887 amt
= sizeof (*hdr2
);
1888 hdr2
= bfd_alloc (abfd
, amt
);
1889 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1892 elf_elfsections (abfd
)[shindex
] = hdr2
;
1893 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1894 target_sect
->flags
|= SEC_RELOC
;
1895 target_sect
->relocation
= NULL
;
1896 target_sect
->rel_filepos
= hdr
->sh_offset
;
1897 /* In the section to which the relocations apply, mark whether
1898 its relocations are of the REL or RELA variety. */
1899 if (hdr
->sh_size
!= 0)
1900 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1901 abfd
->flags
|= HAS_RELOC
;
1906 case SHT_GNU_verdef
:
1907 elf_dynverdef (abfd
) = shindex
;
1908 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1909 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1912 case SHT_GNU_versym
:
1913 elf_dynversym (abfd
) = shindex
;
1914 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1915 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1918 case SHT_GNU_verneed
:
1919 elf_dynverref (abfd
) = shindex
;
1920 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1921 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1928 /* We need a BFD section for objcopy and relocatable linking,
1929 and it's handy to have the signature available as the section
1931 name
= group_signature (abfd
, hdr
);
1934 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1936 if (hdr
->contents
!= NULL
)
1938 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1939 unsigned int n_elt
= hdr
->sh_size
/ 4;
1942 if (idx
->flags
& GRP_COMDAT
)
1943 hdr
->bfd_section
->flags
1944 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1946 while (--n_elt
!= 0)
1947 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
1948 && elf_next_in_group (s
) != NULL
)
1950 elf_next_in_group (hdr
->bfd_section
) = s
;
1957 /* Check for any processor-specific section types. */
1959 if (bed
->elf_backend_section_from_shdr
)
1960 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1968 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1969 Return SEC for sections that have no elf section, and NULL on error. */
1972 bfd_section_from_r_symndx (bfd
*abfd
,
1973 struct sym_sec_cache
*cache
,
1975 unsigned long r_symndx
)
1977 Elf_Internal_Shdr
*symtab_hdr
;
1978 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1979 Elf_External_Sym_Shndx eshndx
;
1980 Elf_Internal_Sym isym
;
1981 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1983 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
1984 return cache
->sec
[ent
];
1986 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1987 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1988 &isym
, esym
, &eshndx
) == NULL
)
1991 if (cache
->abfd
!= abfd
)
1993 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1996 cache
->indx
[ent
] = r_symndx
;
1997 cache
->sec
[ent
] = sec
;
1998 if ((isym
.st_shndx
!= SHN_UNDEF
&& isym
.st_shndx
< SHN_LORESERVE
)
1999 || isym
.st_shndx
> SHN_HIRESERVE
)
2002 s
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
2004 cache
->sec
[ent
] = s
;
2006 return cache
->sec
[ent
];
2009 /* Given an ELF section number, retrieve the corresponding BFD
2013 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
2015 if (index
>= elf_numsections (abfd
))
2017 return elf_elfsections (abfd
)[index
]->bfd_section
;
2020 static struct bfd_elf_special_section
const special_sections
[] =
2022 { ".bss", 0, NULL
, 0,
2023 SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2024 { ".comment", 0, NULL
, 0,
2026 { ".data", 0, NULL
, 0,
2027 SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2028 { ".data1", 0, NULL
, 0,
2029 SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2030 { ".debug", 0, NULL
, 0,
2032 { ".fini", 0, NULL
, 0,
2033 SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2034 { ".init", 0, NULL
, 0,
2035 SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2036 { ".line", 0, NULL
, 0,
2038 { ".rodata", 0, NULL
, 0,
2039 SHT_PROGBITS
, SHF_ALLOC
},
2040 { ".rodata1", 0, NULL
, 0,
2041 SHT_PROGBITS
, SHF_ALLOC
},
2042 { ".tbss", 0, NULL
, 0,
2043 SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2044 { ".tdata", 0, NULL
, 0,
2045 SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2046 { ".text", 0, NULL
, 0,
2047 SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2048 { ".init_array", 0, NULL
, 0,
2049 SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2050 { ".fini_array", 0, NULL
, 0,
2051 SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2052 { ".preinit_array", 0, NULL
, 0,
2053 SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2054 { ".debug_line", 0, NULL
, 0,
2056 { ".debug_info", 0, NULL
, 0,
2058 { ".debug_abbrev", 0, NULL
, 0,
2060 { ".debug_aranges", 0, NULL
, 0,
2062 { ".dynamic", 0, NULL
, 0,
2063 SHT_DYNAMIC
, SHF_ALLOC
},
2064 { ".dynstr", 0, NULL
, 0,
2065 SHT_STRTAB
, SHF_ALLOC
},
2066 { ".dynsym", 0, NULL
, 0,
2067 SHT_DYNSYM
, SHF_ALLOC
},
2068 { ".got", 0, NULL
, 0,
2069 SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2070 { ".hash", 0, NULL
, 0,
2071 SHT_HASH
, SHF_ALLOC
},
2072 { ".interp", 0, NULL
, 0,
2074 { ".plt", 0, NULL
, 0,
2075 SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2076 { ".shstrtab", 0, NULL
, 0,
2078 { ".strtab", 0, NULL
, 0,
2080 { ".symtab", 0, NULL
, 0,
2082 { ".gnu.version", 0, NULL
, 0,
2083 SHT_GNU_versym
, 0 },
2084 { ".gnu.version_d", 0, NULL
, 0,
2085 SHT_GNU_verdef
, 0 },
2086 { ".gnu.version_r", 0, NULL
, 0,
2087 SHT_GNU_verneed
, 0 },
2088 { ".note", 5, NULL
, 0,
2090 { ".rela", 5, NULL
, 0,
2092 { ".rel", 4, NULL
, 0,
2094 { ".stab", 5, "str", 3,
2100 static const struct bfd_elf_special_section
*
2101 get_special_section (const char *name
,
2102 const struct bfd_elf_special_section
*special_sections
,
2107 for (i
= 0; special_sections
[i
].prefix
!= NULL
; i
++)
2108 if (((special_sections
[i
].prefix_length
2109 && strncmp (name
, special_sections
[i
].prefix
,
2110 special_sections
[i
].prefix_length
) == 0
2111 && (! special_sections
[i
].suffix_length
2112 || strcmp ((name
+ strlen (name
)
2113 - special_sections
[i
].suffix_length
),
2114 special_sections
[i
].suffix
) == 0))
2115 || strcmp (name
, special_sections
[i
].prefix
) == 0)
2116 && (rela
|| special_sections
[i
].type
!= SHT_RELA
))
2117 return &special_sections
[i
];
2123 _bfd_elf_get_sec_type_attr (bfd
*abfd
, const char *name
, int *type
, int *attr
)
2125 bfd_boolean found
= FALSE
;
2126 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2128 /* See if this is one of the special sections. */
2131 const struct bfd_elf_special_section
*ssect
= NULL
;
2132 unsigned int rela
= bed
->default_use_rela_p
;
2134 if (bed
->special_sections
)
2135 ssect
= get_special_section (name
, bed
->special_sections
, rela
);
2138 ssect
= get_special_section (name
, special_sections
, rela
);
2142 *type
= ssect
->type
;
2143 *attr
= ssect
->attributes
;
2152 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2154 struct bfd_elf_section_data
*sdata
;
2157 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2160 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2163 sec
->used_by_bfd
= sdata
;
2166 elf_section_type (sec
) = SHT_NULL
;
2167 if (sec
->name
&& _bfd_elf_get_sec_type_attr (abfd
, sec
->name
,
2170 elf_section_type (sec
) = type
;
2171 elf_section_flags (sec
) = attr
;
2174 /* Indicate whether or not this section should use RELA relocations. */
2175 sec
->use_rela_p
= get_elf_backend_data (abfd
)->default_use_rela_p
;
2180 /* Create a new bfd section from an ELF program header.
2182 Since program segments have no names, we generate a synthetic name
2183 of the form segment<NUM>, where NUM is generally the index in the
2184 program header table. For segments that are split (see below) we
2185 generate the names segment<NUM>a and segment<NUM>b.
2187 Note that some program segments may have a file size that is different than
2188 (less than) the memory size. All this means is that at execution the
2189 system must allocate the amount of memory specified by the memory size,
2190 but only initialize it with the first "file size" bytes read from the
2191 file. This would occur for example, with program segments consisting
2192 of combined data+bss.
2194 To handle the above situation, this routine generates TWO bfd sections
2195 for the single program segment. The first has the length specified by
2196 the file size of the segment, and the second has the length specified
2197 by the difference between the two sizes. In effect, the segment is split
2198 into it's initialized and uninitialized parts.
2203 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2204 Elf_Internal_Phdr
*hdr
,
2206 const char *typename
)
2214 split
= ((hdr
->p_memsz
> 0)
2215 && (hdr
->p_filesz
> 0)
2216 && (hdr
->p_memsz
> hdr
->p_filesz
));
2217 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2218 len
= strlen (namebuf
) + 1;
2219 name
= bfd_alloc (abfd
, len
);
2222 memcpy (name
, namebuf
, len
);
2223 newsect
= bfd_make_section (abfd
, name
);
2224 if (newsect
== NULL
)
2226 newsect
->vma
= hdr
->p_vaddr
;
2227 newsect
->lma
= hdr
->p_paddr
;
2228 newsect
->_raw_size
= hdr
->p_filesz
;
2229 newsect
->filepos
= hdr
->p_offset
;
2230 newsect
->flags
|= SEC_HAS_CONTENTS
;
2231 if (hdr
->p_type
== PT_LOAD
)
2233 newsect
->flags
|= SEC_ALLOC
;
2234 newsect
->flags
|= SEC_LOAD
;
2235 if (hdr
->p_flags
& PF_X
)
2237 /* FIXME: all we known is that it has execute PERMISSION,
2239 newsect
->flags
|= SEC_CODE
;
2242 if (!(hdr
->p_flags
& PF_W
))
2244 newsect
->flags
|= SEC_READONLY
;
2249 sprintf (namebuf
, "%s%db", typename
, index
);
2250 len
= strlen (namebuf
) + 1;
2251 name
= bfd_alloc (abfd
, len
);
2254 memcpy (name
, namebuf
, len
);
2255 newsect
= bfd_make_section (abfd
, name
);
2256 if (newsect
== NULL
)
2258 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2259 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2260 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
2261 if (hdr
->p_type
== PT_LOAD
)
2263 newsect
->flags
|= SEC_ALLOC
;
2264 if (hdr
->p_flags
& PF_X
)
2265 newsect
->flags
|= SEC_CODE
;
2267 if (!(hdr
->p_flags
& PF_W
))
2268 newsect
->flags
|= SEC_READONLY
;
2275 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2277 const struct elf_backend_data
*bed
;
2279 switch (hdr
->p_type
)
2282 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2285 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2288 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2291 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2294 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2296 if (! elfcore_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2301 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2304 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2306 case PT_GNU_EH_FRAME
:
2307 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2311 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2314 /* Check for any processor-specific program segment types.
2315 If no handler for them, default to making "segment" sections. */
2316 bed
= get_elf_backend_data (abfd
);
2317 if (bed
->elf_backend_section_from_phdr
)
2318 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
2320 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
2324 /* Initialize REL_HDR, the section-header for new section, containing
2325 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2326 relocations; otherwise, we use REL relocations. */
2329 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2330 Elf_Internal_Shdr
*rel_hdr
,
2332 bfd_boolean use_rela_p
)
2335 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2336 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2338 name
= bfd_alloc (abfd
, amt
);
2341 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2343 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2345 if (rel_hdr
->sh_name
== (unsigned int) -1)
2347 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2348 rel_hdr
->sh_entsize
= (use_rela_p
2349 ? bed
->s
->sizeof_rela
2350 : bed
->s
->sizeof_rel
);
2351 rel_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
2352 rel_hdr
->sh_flags
= 0;
2353 rel_hdr
->sh_addr
= 0;
2354 rel_hdr
->sh_size
= 0;
2355 rel_hdr
->sh_offset
= 0;
2360 /* Set up an ELF internal section header for a section. */
2363 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2365 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2366 bfd_boolean
*failedptr
= failedptrarg
;
2367 Elf_Internal_Shdr
*this_hdr
;
2371 /* We already failed; just get out of the bfd_map_over_sections
2376 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2378 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2379 asect
->name
, FALSE
);
2380 if (this_hdr
->sh_name
== (unsigned int) -1)
2386 this_hdr
->sh_flags
= 0;
2388 if ((asect
->flags
& SEC_ALLOC
) != 0
2389 || asect
->user_set_vma
)
2390 this_hdr
->sh_addr
= asect
->vma
;
2392 this_hdr
->sh_addr
= 0;
2394 this_hdr
->sh_offset
= 0;
2395 this_hdr
->sh_size
= asect
->_raw_size
;
2396 this_hdr
->sh_link
= 0;
2397 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2398 /* The sh_entsize and sh_info fields may have been set already by
2399 copy_private_section_data. */
2401 this_hdr
->bfd_section
= asect
;
2402 this_hdr
->contents
= NULL
;
2404 /* If the section type is unspecified, we set it based on
2406 if (this_hdr
->sh_type
== SHT_NULL
)
2408 if ((asect
->flags
& SEC_ALLOC
) != 0
2409 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2410 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2411 this_hdr
->sh_type
= SHT_NOBITS
;
2413 this_hdr
->sh_type
= SHT_PROGBITS
;
2416 switch (this_hdr
->sh_type
)
2422 case SHT_INIT_ARRAY
:
2423 case SHT_FINI_ARRAY
:
2424 case SHT_PREINIT_ARRAY
:
2431 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2435 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2439 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2443 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2444 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2448 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2449 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2452 case SHT_GNU_versym
:
2453 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2456 case SHT_GNU_verdef
:
2457 this_hdr
->sh_entsize
= 0;
2458 /* objcopy or strip will copy over sh_info, but may not set
2459 cverdefs. The linker will set cverdefs, but sh_info will be
2461 if (this_hdr
->sh_info
== 0)
2462 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2464 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2465 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2468 case SHT_GNU_verneed
:
2469 this_hdr
->sh_entsize
= 0;
2470 /* objcopy or strip will copy over sh_info, but may not set
2471 cverrefs. The linker will set cverrefs, but sh_info will be
2473 if (this_hdr
->sh_info
== 0)
2474 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2476 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2477 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2481 this_hdr
->sh_entsize
= 4;
2485 if ((asect
->flags
& SEC_ALLOC
) != 0)
2486 this_hdr
->sh_flags
|= SHF_ALLOC
;
2487 if ((asect
->flags
& SEC_READONLY
) == 0)
2488 this_hdr
->sh_flags
|= SHF_WRITE
;
2489 if ((asect
->flags
& SEC_CODE
) != 0)
2490 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2491 if ((asect
->flags
& SEC_MERGE
) != 0)
2493 this_hdr
->sh_flags
|= SHF_MERGE
;
2494 this_hdr
->sh_entsize
= asect
->entsize
;
2495 if ((asect
->flags
& SEC_STRINGS
) != 0)
2496 this_hdr
->sh_flags
|= SHF_STRINGS
;
2498 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2499 this_hdr
->sh_flags
|= SHF_GROUP
;
2500 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2502 this_hdr
->sh_flags
|= SHF_TLS
;
2503 if (asect
->_raw_size
== 0 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2505 struct bfd_link_order
*o
;
2507 this_hdr
->sh_size
= 0;
2508 for (o
= asect
->link_order_head
; o
!= NULL
; o
= o
->next
)
2509 if (this_hdr
->sh_size
< o
->offset
+ o
->size
)
2510 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2511 if (this_hdr
->sh_size
)
2512 this_hdr
->sh_type
= SHT_NOBITS
;
2516 /* Check for processor-specific section types. */
2517 if (bed
->elf_backend_fake_sections
2518 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2521 /* If the section has relocs, set up a section header for the
2522 SHT_REL[A] section. If two relocation sections are required for
2523 this section, it is up to the processor-specific back-end to
2524 create the other. */
2525 if ((asect
->flags
& SEC_RELOC
) != 0
2526 && !_bfd_elf_init_reloc_shdr (abfd
,
2527 &elf_section_data (asect
)->rel_hdr
,
2533 /* Fill in the contents of a SHT_GROUP section. */
2536 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2538 bfd_boolean
*failedptr
= failedptrarg
;
2539 unsigned long symindx
;
2540 asection
*elt
, *first
;
2542 struct bfd_link_order
*l
;
2545 if (elf_section_data (sec
)->this_hdr
.sh_type
!= SHT_GROUP
2550 if (elf_group_id (sec
) != NULL
)
2551 symindx
= elf_group_id (sec
)->udata
.i
;
2555 /* If called from the assembler, swap_out_syms will have set up
2556 elf_section_syms; If called for "ld -r", use target_index. */
2557 if (elf_section_syms (abfd
) != NULL
)
2558 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2560 symindx
= sec
->target_index
;
2562 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2564 /* The contents won't be allocated for "ld -r" or objcopy. */
2566 if (sec
->contents
== NULL
)
2569 sec
->contents
= bfd_alloc (abfd
, sec
->_raw_size
);
2571 /* Arrange for the section to be written out. */
2572 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2573 if (sec
->contents
== NULL
)
2580 loc
= sec
->contents
+ sec
->_raw_size
;
2582 /* Get the pointer to the first section in the group that gas
2583 squirreled away here. objcopy arranges for this to be set to the
2584 start of the input section group. */
2585 first
= elt
= elf_next_in_group (sec
);
2587 /* First element is a flag word. Rest of section is elf section
2588 indices for all the sections of the group. Write them backwards
2589 just to keep the group in the same order as given in .section
2590 directives, not that it matters. */
2599 s
= s
->output_section
;
2602 idx
= elf_section_data (s
)->this_idx
;
2603 H_PUT_32 (abfd
, idx
, loc
);
2604 elt
= elf_next_in_group (elt
);
2609 /* If this is a relocatable link, then the above did nothing because
2610 SEC is the output section. Look through the input sections
2612 for (l
= sec
->link_order_head
; l
!= NULL
; l
= l
->next
)
2613 if (l
->type
== bfd_indirect_link_order
2614 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2619 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2620 elt
= elf_next_in_group (elt
);
2621 /* During a relocatable link, the lists are circular. */
2623 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2625 /* With ld -r, merging SHT_GROUP sections results in wasted space
2626 due to allowing for the flag word on each input. We may well
2627 duplicate entries too. */
2628 while ((loc
-= 4) > sec
->contents
)
2629 H_PUT_32 (abfd
, 0, loc
);
2631 if (loc
!= sec
->contents
)
2634 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2637 /* Assign all ELF section numbers. The dummy first section is handled here
2638 too. The link/info pointers for the standard section types are filled
2639 in here too, while we're at it. */
2642 assign_section_numbers (bfd
*abfd
)
2644 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2646 unsigned int section_number
, secn
;
2647 Elf_Internal_Shdr
**i_shdrp
;
2652 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2654 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2656 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2658 if (section_number
== SHN_LORESERVE
)
2659 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2660 d
->this_idx
= section_number
++;
2661 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2662 if ((sec
->flags
& SEC_RELOC
) == 0)
2666 if (section_number
== SHN_LORESERVE
)
2667 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2668 d
->rel_idx
= section_number
++;
2669 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2674 if (section_number
== SHN_LORESERVE
)
2675 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2676 d
->rel_idx2
= section_number
++;
2677 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2683 if (section_number
== SHN_LORESERVE
)
2684 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2685 t
->shstrtab_section
= section_number
++;
2686 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2687 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2689 if (bfd_get_symcount (abfd
) > 0)
2691 if (section_number
== SHN_LORESERVE
)
2692 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2693 t
->symtab_section
= section_number
++;
2694 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2695 if (section_number
> SHN_LORESERVE
- 2)
2697 if (section_number
== SHN_LORESERVE
)
2698 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2699 t
->symtab_shndx_section
= section_number
++;
2700 t
->symtab_shndx_hdr
.sh_name
2701 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2702 ".symtab_shndx", FALSE
);
2703 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2706 if (section_number
== SHN_LORESERVE
)
2707 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2708 t
->strtab_section
= section_number
++;
2709 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2712 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2713 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2715 elf_numsections (abfd
) = section_number
;
2716 elf_elfheader (abfd
)->e_shnum
= section_number
;
2717 if (section_number
> SHN_LORESERVE
)
2718 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2720 /* Set up the list of section header pointers, in agreement with the
2722 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2723 i_shdrp
= bfd_zalloc (abfd
, amt
);
2724 if (i_shdrp
== NULL
)
2727 amt
= sizeof (Elf_Internal_Shdr
);
2728 i_shdrp
[0] = bfd_zalloc (abfd
, amt
);
2729 if (i_shdrp
[0] == NULL
)
2731 bfd_release (abfd
, i_shdrp
);
2735 elf_elfsections (abfd
) = i_shdrp
;
2737 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2738 if (bfd_get_symcount (abfd
) > 0)
2740 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2741 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2743 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2744 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2746 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2747 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2749 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2751 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2755 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2756 if (d
->rel_idx
!= 0)
2757 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2758 if (d
->rel_idx2
!= 0)
2759 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2761 /* Fill in the sh_link and sh_info fields while we're at it. */
2763 /* sh_link of a reloc section is the section index of the symbol
2764 table. sh_info is the section index of the section to which
2765 the relocation entries apply. */
2766 if (d
->rel_idx
!= 0)
2768 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2769 d
->rel_hdr
.sh_info
= d
->this_idx
;
2771 if (d
->rel_idx2
!= 0)
2773 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2774 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2777 switch (d
->this_hdr
.sh_type
)
2781 /* A reloc section which we are treating as a normal BFD
2782 section. sh_link is the section index of the symbol
2783 table. sh_info is the section index of the section to
2784 which the relocation entries apply. We assume that an
2785 allocated reloc section uses the dynamic symbol table.
2786 FIXME: How can we be sure? */
2787 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2789 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2791 /* We look up the section the relocs apply to by name. */
2793 if (d
->this_hdr
.sh_type
== SHT_REL
)
2797 s
= bfd_get_section_by_name (abfd
, name
);
2799 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2803 /* We assume that a section named .stab*str is a stabs
2804 string section. We look for a section with the same name
2805 but without the trailing ``str'', and set its sh_link
2806 field to point to this section. */
2807 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
2808 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2813 len
= strlen (sec
->name
);
2814 alc
= bfd_malloc (len
- 2);
2817 memcpy (alc
, sec
->name
, len
- 3);
2818 alc
[len
- 3] = '\0';
2819 s
= bfd_get_section_by_name (abfd
, alc
);
2823 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2825 /* This is a .stab section. */
2826 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
2827 elf_section_data (s
)->this_hdr
.sh_entsize
2828 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2835 case SHT_GNU_verneed
:
2836 case SHT_GNU_verdef
:
2837 /* sh_link is the section header index of the string table
2838 used for the dynamic entries, or the symbol table, or the
2840 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2842 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2846 case SHT_GNU_versym
:
2847 /* sh_link is the section header index of the symbol table
2848 this hash table or version table is for. */
2849 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2851 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2855 d
->this_hdr
.sh_link
= t
->symtab_section
;
2859 for (secn
= 1; secn
< section_number
; ++secn
)
2860 if (i_shdrp
[secn
] == NULL
)
2861 i_shdrp
[secn
] = i_shdrp
[0];
2863 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
2864 i_shdrp
[secn
]->sh_name
);
2868 /* Map symbol from it's internal number to the external number, moving
2869 all local symbols to be at the head of the list. */
2872 sym_is_global (bfd
*abfd
, asymbol
*sym
)
2874 /* If the backend has a special mapping, use it. */
2875 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2876 if (bed
->elf_backend_sym_is_global
)
2877 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
2879 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2880 || bfd_is_und_section (bfd_get_section (sym
))
2881 || bfd_is_com_section (bfd_get_section (sym
)));
2885 elf_map_symbols (bfd
*abfd
)
2887 unsigned int symcount
= bfd_get_symcount (abfd
);
2888 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2889 asymbol
**sect_syms
;
2890 unsigned int num_locals
= 0;
2891 unsigned int num_globals
= 0;
2892 unsigned int num_locals2
= 0;
2893 unsigned int num_globals2
= 0;
2901 fprintf (stderr
, "elf_map_symbols\n");
2905 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2907 if (max_index
< asect
->index
)
2908 max_index
= asect
->index
;
2912 amt
= max_index
* sizeof (asymbol
*);
2913 sect_syms
= bfd_zalloc (abfd
, amt
);
2914 if (sect_syms
== NULL
)
2916 elf_section_syms (abfd
) = sect_syms
;
2917 elf_num_section_syms (abfd
) = max_index
;
2919 /* Init sect_syms entries for any section symbols we have already
2920 decided to output. */
2921 for (idx
= 0; idx
< symcount
; idx
++)
2923 asymbol
*sym
= syms
[idx
];
2925 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2932 if (sec
->owner
!= NULL
)
2934 if (sec
->owner
!= abfd
)
2936 if (sec
->output_offset
!= 0)
2939 sec
= sec
->output_section
;
2941 /* Empty sections in the input files may have had a
2942 section symbol created for them. (See the comment
2943 near the end of _bfd_generic_link_output_symbols in
2944 linker.c). If the linker script discards such
2945 sections then we will reach this point. Since we know
2946 that we cannot avoid this case, we detect it and skip
2947 the abort and the assignment to the sect_syms array.
2948 To reproduce this particular case try running the
2949 linker testsuite test ld-scripts/weak.exp for an ELF
2950 port that uses the generic linker. */
2951 if (sec
->owner
== NULL
)
2954 BFD_ASSERT (sec
->owner
== abfd
);
2956 sect_syms
[sec
->index
] = syms
[idx
];
2961 /* Classify all of the symbols. */
2962 for (idx
= 0; idx
< symcount
; idx
++)
2964 if (!sym_is_global (abfd
, syms
[idx
]))
2970 /* We will be adding a section symbol for each BFD section. Most normal
2971 sections will already have a section symbol in outsymbols, but
2972 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2973 at least in that case. */
2974 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2976 if (sect_syms
[asect
->index
] == NULL
)
2978 if (!sym_is_global (abfd
, asect
->symbol
))
2985 /* Now sort the symbols so the local symbols are first. */
2986 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
2987 new_syms
= bfd_alloc (abfd
, amt
);
2989 if (new_syms
== NULL
)
2992 for (idx
= 0; idx
< symcount
; idx
++)
2994 asymbol
*sym
= syms
[idx
];
2997 if (!sym_is_global (abfd
, sym
))
3000 i
= num_locals
+ num_globals2
++;
3002 sym
->udata
.i
= i
+ 1;
3004 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3006 if (sect_syms
[asect
->index
] == NULL
)
3008 asymbol
*sym
= asect
->symbol
;
3011 sect_syms
[asect
->index
] = sym
;
3012 if (!sym_is_global (abfd
, sym
))
3015 i
= num_locals
+ num_globals2
++;
3017 sym
->udata
.i
= i
+ 1;
3021 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3023 elf_num_locals (abfd
) = num_locals
;
3024 elf_num_globals (abfd
) = num_globals
;
3028 /* Align to the maximum file alignment that could be required for any
3029 ELF data structure. */
3031 static inline file_ptr
3032 align_file_position (file_ptr off
, int align
)
3034 return (off
+ align
- 1) & ~(align
- 1);
3037 /* Assign a file position to a section, optionally aligning to the
3038 required section alignment. */
3041 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3049 al
= i_shdrp
->sh_addralign
;
3051 offset
= BFD_ALIGN (offset
, al
);
3053 i_shdrp
->sh_offset
= offset
;
3054 if (i_shdrp
->bfd_section
!= NULL
)
3055 i_shdrp
->bfd_section
->filepos
= offset
;
3056 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3057 offset
+= i_shdrp
->sh_size
;
3061 /* Compute the file positions we are going to put the sections at, and
3062 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3063 is not NULL, this is being called by the ELF backend linker. */
3066 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3067 struct bfd_link_info
*link_info
)
3069 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3071 struct bfd_strtab_hash
*strtab
;
3072 Elf_Internal_Shdr
*shstrtab_hdr
;
3074 if (abfd
->output_has_begun
)
3077 /* Do any elf backend specific processing first. */
3078 if (bed
->elf_backend_begin_write_processing
)
3079 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3081 if (! prep_headers (abfd
))
3084 /* Post process the headers if necessary. */
3085 if (bed
->elf_backend_post_process_headers
)
3086 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3089 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3093 if (!assign_section_numbers (abfd
))
3096 /* The backend linker builds symbol table information itself. */
3097 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3099 /* Non-zero if doing a relocatable link. */
3100 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3102 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3106 if (link_info
== NULL
)
3108 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3113 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3114 /* sh_name was set in prep_headers. */
3115 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3116 shstrtab_hdr
->sh_flags
= 0;
3117 shstrtab_hdr
->sh_addr
= 0;
3118 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3119 shstrtab_hdr
->sh_entsize
= 0;
3120 shstrtab_hdr
->sh_link
= 0;
3121 shstrtab_hdr
->sh_info
= 0;
3122 /* sh_offset is set in assign_file_positions_except_relocs. */
3123 shstrtab_hdr
->sh_addralign
= 1;
3125 if (!assign_file_positions_except_relocs (abfd
))
3128 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3131 Elf_Internal_Shdr
*hdr
;
3133 off
= elf_tdata (abfd
)->next_file_pos
;
3135 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3136 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3138 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3139 if (hdr
->sh_size
!= 0)
3140 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3142 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3143 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3145 elf_tdata (abfd
)->next_file_pos
= off
;
3147 /* Now that we know where the .strtab section goes, write it
3149 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3150 || ! _bfd_stringtab_emit (abfd
, strtab
))
3152 _bfd_stringtab_free (strtab
);
3155 abfd
->output_has_begun
= TRUE
;
3160 /* Create a mapping from a set of sections to a program segment. */
3162 static struct elf_segment_map
*
3163 make_mapping (bfd
*abfd
,
3164 asection
**sections
,
3169 struct elf_segment_map
*m
;
3174 amt
= sizeof (struct elf_segment_map
);
3175 amt
+= (to
- from
- 1) * sizeof (asection
*);
3176 m
= bfd_zalloc (abfd
, amt
);
3180 m
->p_type
= PT_LOAD
;
3181 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3182 m
->sections
[i
- from
] = *hdrpp
;
3183 m
->count
= to
- from
;
3185 if (from
== 0 && phdr
)
3187 /* Include the headers in the first PT_LOAD segment. */
3188 m
->includes_filehdr
= 1;
3189 m
->includes_phdrs
= 1;
3195 /* Set up a mapping from BFD sections to program segments. */
3198 map_sections_to_segments (bfd
*abfd
)
3200 asection
**sections
= NULL
;
3204 struct elf_segment_map
*mfirst
;
3205 struct elf_segment_map
**pm
;
3206 struct elf_segment_map
*m
;
3208 unsigned int phdr_index
;
3209 bfd_vma maxpagesize
;
3211 bfd_boolean phdr_in_segment
= TRUE
;
3212 bfd_boolean writable
;
3214 asection
*first_tls
= NULL
;
3215 asection
*dynsec
, *eh_frame_hdr
;
3218 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3221 if (bfd_count_sections (abfd
) == 0)
3224 /* Select the allocated sections, and sort them. */
3226 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
3227 sections
= bfd_malloc (amt
);
3228 if (sections
== NULL
)
3232 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3234 if ((s
->flags
& SEC_ALLOC
) != 0)
3240 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3243 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3245 /* Build the mapping. */
3250 /* If we have a .interp section, then create a PT_PHDR segment for
3251 the program headers and a PT_INTERP segment for the .interp
3253 s
= bfd_get_section_by_name (abfd
, ".interp");
3254 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3256 amt
= sizeof (struct elf_segment_map
);
3257 m
= bfd_zalloc (abfd
, amt
);
3261 m
->p_type
= PT_PHDR
;
3262 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3263 m
->p_flags
= PF_R
| PF_X
;
3264 m
->p_flags_valid
= 1;
3265 m
->includes_phdrs
= 1;
3270 amt
= sizeof (struct elf_segment_map
);
3271 m
= bfd_zalloc (abfd
, amt
);
3275 m
->p_type
= PT_INTERP
;
3283 /* Look through the sections. We put sections in the same program
3284 segment when the start of the second section can be placed within
3285 a few bytes of the end of the first section. */
3288 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3290 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3292 && (dynsec
->flags
& SEC_LOAD
) == 0)
3295 /* Deal with -Ttext or something similar such that the first section
3296 is not adjacent to the program headers. This is an
3297 approximation, since at this point we don't know exactly how many
3298 program headers we will need. */
3301 bfd_size_type phdr_size
;
3303 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3305 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3306 if ((abfd
->flags
& D_PAGED
) == 0
3307 || sections
[0]->lma
< phdr_size
3308 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3309 phdr_in_segment
= FALSE
;
3312 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3315 bfd_boolean new_segment
;
3319 /* See if this section and the last one will fit in the same
3322 if (last_hdr
== NULL
)
3324 /* If we don't have a segment yet, then we don't need a new
3325 one (we build the last one after this loop). */
3326 new_segment
= FALSE
;
3328 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3330 /* If this section has a different relation between the
3331 virtual address and the load address, then we need a new
3335 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
3336 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3338 /* If putting this section in this segment would force us to
3339 skip a page in the segment, then we need a new segment. */
3342 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
3343 && (hdr
->flags
& SEC_LOAD
) != 0)
3345 /* We don't want to put a loadable section after a
3346 nonloadable section in the same segment. */
3349 else if ((abfd
->flags
& D_PAGED
) == 0)
3351 /* If the file is not demand paged, which means that we
3352 don't require the sections to be correctly aligned in the
3353 file, then there is no other reason for a new segment. */
3354 new_segment
= FALSE
;
3357 && (hdr
->flags
& SEC_READONLY
) == 0
3358 && (((last_hdr
->lma
+ last_hdr
->_raw_size
- 1)
3359 & ~(maxpagesize
- 1))
3360 != (hdr
->lma
& ~(maxpagesize
- 1))))
3362 /* We don't want to put a writable section in a read only
3363 segment, unless they are on the same page in memory
3364 anyhow. We already know that the last section does not
3365 bring us past the current section on the page, so the
3366 only case in which the new section is not on the same
3367 page as the previous section is when the previous section
3368 ends precisely on a page boundary. */
3373 /* Otherwise, we can use the same segment. */
3374 new_segment
= FALSE
;
3379 if ((hdr
->flags
& SEC_READONLY
) == 0)
3385 /* We need a new program segment. We must create a new program
3386 header holding all the sections from phdr_index until hdr. */
3388 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3395 if ((hdr
->flags
& SEC_READONLY
) == 0)
3402 phdr_in_segment
= FALSE
;
3405 /* Create a final PT_LOAD program segment. */
3406 if (last_hdr
!= NULL
)
3408 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3416 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3419 amt
= sizeof (struct elf_segment_map
);
3420 m
= bfd_zalloc (abfd
, amt
);
3424 m
->p_type
= PT_DYNAMIC
;
3426 m
->sections
[0] = dynsec
;
3432 /* For each loadable .note section, add a PT_NOTE segment. We don't
3433 use bfd_get_section_by_name, because if we link together
3434 nonloadable .note sections and loadable .note sections, we will
3435 generate two .note sections in the output file. FIXME: Using
3436 names for section types is bogus anyhow. */
3437 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3439 if ((s
->flags
& SEC_LOAD
) != 0
3440 && strncmp (s
->name
, ".note", 5) == 0)
3442 amt
= sizeof (struct elf_segment_map
);
3443 m
= bfd_zalloc (abfd
, amt
);
3447 m
->p_type
= PT_NOTE
;
3454 if (s
->flags
& SEC_THREAD_LOCAL
)
3462 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3467 amt
= sizeof (struct elf_segment_map
);
3468 amt
+= (tls_count
- 1) * sizeof (asection
*);
3469 m
= bfd_zalloc (abfd
, amt
);
3474 m
->count
= tls_count
;
3475 /* Mandated PF_R. */
3477 m
->p_flags_valid
= 1;
3478 for (i
= 0; i
< tls_count
; ++i
)
3480 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3481 m
->sections
[i
] = first_tls
;
3482 first_tls
= first_tls
->next
;
3489 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3491 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3492 if (eh_frame_hdr
!= NULL
3493 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3495 amt
= sizeof (struct elf_segment_map
);
3496 m
= bfd_zalloc (abfd
, amt
);
3500 m
->p_type
= PT_GNU_EH_FRAME
;
3502 m
->sections
[0] = eh_frame_hdr
->output_section
;
3508 if (elf_tdata (abfd
)->stack_flags
)
3510 amt
= sizeof (struct elf_segment_map
);
3511 m
= bfd_zalloc (abfd
, amt
);
3515 m
->p_type
= PT_GNU_STACK
;
3516 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3517 m
->p_flags_valid
= 1;
3526 elf_tdata (abfd
)->segment_map
= mfirst
;
3530 if (sections
!= NULL
)
3535 /* Sort sections by address. */
3538 elf_sort_sections (const void *arg1
, const void *arg2
)
3540 const asection
*sec1
= *(const asection
**) arg1
;
3541 const asection
*sec2
= *(const asection
**) arg2
;
3542 bfd_size_type size1
, size2
;
3544 /* Sort by LMA first, since this is the address used to
3545 place the section into a segment. */
3546 if (sec1
->lma
< sec2
->lma
)
3548 else if (sec1
->lma
> sec2
->lma
)
3551 /* Then sort by VMA. Normally the LMA and the VMA will be
3552 the same, and this will do nothing. */
3553 if (sec1
->vma
< sec2
->vma
)
3555 else if (sec1
->vma
> sec2
->vma
)
3558 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3560 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3566 /* If the indicies are the same, do not return 0
3567 here, but continue to try the next comparison. */
3568 if (sec1
->target_index
- sec2
->target_index
!= 0)
3569 return sec1
->target_index
- sec2
->target_index
;
3574 else if (TOEND (sec2
))
3579 /* Sort by size, to put zero sized sections
3580 before others at the same address. */
3582 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->_raw_size
: 0;
3583 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->_raw_size
: 0;
3590 return sec1
->target_index
- sec2
->target_index
;
3593 /* Assign file positions to the sections based on the mapping from
3594 sections to segments. This function also sets up some fields in
3595 the file header, and writes out the program headers. */
3598 assign_file_positions_for_segments (bfd
*abfd
)
3600 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3602 struct elf_segment_map
*m
;
3604 Elf_Internal_Phdr
*phdrs
;
3606 bfd_vma filehdr_vaddr
, filehdr_paddr
;
3607 bfd_vma phdrs_vaddr
, phdrs_paddr
;
3608 Elf_Internal_Phdr
*p
;
3611 if (elf_tdata (abfd
)->segment_map
== NULL
)
3613 if (! map_sections_to_segments (abfd
))
3618 /* The placement algorithm assumes that non allocated sections are
3619 not in PT_LOAD segments. We ensure this here by removing such
3620 sections from the segment map. */
3621 for (m
= elf_tdata (abfd
)->segment_map
;
3625 unsigned int new_count
;
3628 if (m
->p_type
!= PT_LOAD
)
3632 for (i
= 0; i
< m
->count
; i
++)
3634 if ((m
->sections
[i
]->flags
& SEC_ALLOC
) != 0)
3637 m
->sections
[new_count
] = m
->sections
[i
];
3643 if (new_count
!= m
->count
)
3644 m
->count
= new_count
;
3648 if (bed
->elf_backend_modify_segment_map
)
3650 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
3655 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3658 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
3659 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
3660 elf_elfheader (abfd
)->e_phnum
= count
;
3665 /* If we already counted the number of program segments, make sure
3666 that we allocated enough space. This happens when SIZEOF_HEADERS
3667 is used in a linker script. */
3668 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
3669 if (alloc
!= 0 && count
> alloc
)
3671 ((*_bfd_error_handler
)
3672 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3673 bfd_get_filename (abfd
), alloc
, count
));
3674 bfd_set_error (bfd_error_bad_value
);
3681 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
3682 phdrs
= bfd_alloc (abfd
, amt
);
3686 off
= bed
->s
->sizeof_ehdr
;
3687 off
+= alloc
* bed
->s
->sizeof_phdr
;
3694 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3701 /* If elf_segment_map is not from map_sections_to_segments, the
3702 sections may not be correctly ordered. NOTE: sorting should
3703 not be done to the PT_NOTE section of a corefile, which may
3704 contain several pseudo-sections artificially created by bfd.
3705 Sorting these pseudo-sections breaks things badly. */
3707 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
3708 && m
->p_type
== PT_NOTE
))
3709 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
3712 p
->p_type
= m
->p_type
;
3713 p
->p_flags
= m
->p_flags
;
3715 if (p
->p_type
== PT_LOAD
3717 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
3719 if ((abfd
->flags
& D_PAGED
) != 0)
3720 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
3723 bfd_size_type align
;
3726 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3728 bfd_size_type secalign
;
3730 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
3731 if (secalign
> align
)
3735 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
3742 p
->p_vaddr
= m
->sections
[0]->vma
;
3744 if (m
->p_paddr_valid
)
3745 p
->p_paddr
= m
->p_paddr
;
3746 else if (m
->count
== 0)
3749 p
->p_paddr
= m
->sections
[0]->lma
;
3751 if (p
->p_type
== PT_LOAD
3752 && (abfd
->flags
& D_PAGED
) != 0)
3753 p
->p_align
= bed
->maxpagesize
;
3754 else if (m
->count
== 0)
3755 p
->p_align
= 1 << bed
->s
->log_file_align
;
3763 if (m
->includes_filehdr
)
3765 if (! m
->p_flags_valid
)
3768 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3769 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3772 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3774 if (p
->p_vaddr
< (bfd_vma
) off
)
3776 (*_bfd_error_handler
)
3777 (_("%s: Not enough room for program headers, try linking with -N"),
3778 bfd_get_filename (abfd
));
3779 bfd_set_error (bfd_error_bad_value
);
3784 if (! m
->p_paddr_valid
)
3787 if (p
->p_type
== PT_LOAD
)
3789 filehdr_vaddr
= p
->p_vaddr
;
3790 filehdr_paddr
= p
->p_paddr
;
3794 if (m
->includes_phdrs
)
3796 if (! m
->p_flags_valid
)
3799 if (m
->includes_filehdr
)
3801 if (p
->p_type
== PT_LOAD
)
3803 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3804 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3809 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3813 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3814 p
->p_vaddr
-= off
- p
->p_offset
;
3815 if (! m
->p_paddr_valid
)
3816 p
->p_paddr
-= off
- p
->p_offset
;
3819 if (p
->p_type
== PT_LOAD
)
3821 phdrs_vaddr
= p
->p_vaddr
;
3822 phdrs_paddr
= p
->p_paddr
;
3825 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3828 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3829 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3832 if (p
->p_type
== PT_LOAD
3833 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3835 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3841 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3842 p
->p_filesz
+= adjust
;
3843 p
->p_memsz
+= adjust
;
3849 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3853 bfd_size_type align
;
3857 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3859 /* The section may have artificial alignment forced by a
3860 link script. Notice this case by the gap between the
3861 cumulative phdr lma and the section's lma. */
3862 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3864 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3866 p
->p_memsz
+= adjust
;
3867 if (p
->p_type
== PT_LOAD
3868 || (p
->p_type
== PT_NOTE
3869 && bfd_get_format (abfd
) == bfd_core
))
3874 if ((flags
& SEC_LOAD
) != 0
3875 || (flags
& SEC_THREAD_LOCAL
) != 0)
3876 p
->p_filesz
+= adjust
;
3879 if (p
->p_type
== PT_LOAD
)
3881 bfd_signed_vma adjust
;
3883 if ((flags
& SEC_LOAD
) != 0)
3885 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3889 else if ((flags
& SEC_ALLOC
) != 0)
3891 /* The section VMA must equal the file position
3892 modulo the page size. FIXME: I'm not sure if
3893 this adjustment is really necessary. We used to
3894 not have the SEC_LOAD case just above, and then
3895 this was necessary, but now I'm not sure. */
3896 if ((abfd
->flags
& D_PAGED
) != 0)
3897 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
3899 adjust
= (sec
->vma
- voff
) % align
;
3908 (* _bfd_error_handler
) (_("\
3909 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3910 bfd_section_name (abfd
, sec
),
3915 p
->p_memsz
+= adjust
;
3918 if ((flags
& SEC_LOAD
) != 0)
3919 p
->p_filesz
+= adjust
;
3924 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3925 used in a linker script we may have a section with
3926 SEC_LOAD clear but which is supposed to have
3928 if ((flags
& SEC_LOAD
) != 0
3929 || (flags
& SEC_HAS_CONTENTS
) != 0)
3930 off
+= sec
->_raw_size
;
3932 if ((flags
& SEC_ALLOC
) != 0
3933 && ((flags
& SEC_LOAD
) != 0
3934 || (flags
& SEC_THREAD_LOCAL
) == 0))
3935 voff
+= sec
->_raw_size
;
3938 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
3940 /* The actual "note" segment has i == 0.
3941 This is the one that actually contains everything. */
3945 p
->p_filesz
= sec
->_raw_size
;
3946 off
+= sec
->_raw_size
;
3951 /* Fake sections -- don't need to be written. */
3954 flags
= sec
->flags
= 0;
3961 if ((sec
->flags
& SEC_LOAD
) != 0
3962 || (sec
->flags
& SEC_THREAD_LOCAL
) == 0
3963 || p
->p_type
== PT_TLS
)
3964 p
->p_memsz
+= sec
->_raw_size
;
3966 if ((flags
& SEC_LOAD
) != 0)
3967 p
->p_filesz
+= sec
->_raw_size
;
3969 if (p
->p_type
== PT_TLS
3970 && sec
->_raw_size
== 0
3971 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
3973 struct bfd_link_order
*o
;
3974 bfd_vma tbss_size
= 0;
3976 for (o
= sec
->link_order_head
; o
!= NULL
; o
= o
->next
)
3977 if (tbss_size
< o
->offset
+ o
->size
)
3978 tbss_size
= o
->offset
+ o
->size
;
3980 p
->p_memsz
+= tbss_size
;
3983 if (align
> p
->p_align
3984 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
3988 if (! m
->p_flags_valid
)
3991 if ((flags
& SEC_CODE
) != 0)
3993 if ((flags
& SEC_READONLY
) == 0)
3999 /* Now that we have set the section file positions, we can set up
4000 the file positions for the non PT_LOAD segments. */
4001 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4005 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
4007 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
4008 p
->p_offset
= m
->sections
[0]->filepos
;
4012 if (m
->includes_filehdr
)
4014 p
->p_vaddr
= filehdr_vaddr
;
4015 if (! m
->p_paddr_valid
)
4016 p
->p_paddr
= filehdr_paddr
;
4018 else if (m
->includes_phdrs
)
4020 p
->p_vaddr
= phdrs_vaddr
;
4021 if (! m
->p_paddr_valid
)
4022 p
->p_paddr
= phdrs_paddr
;
4027 /* Clear out any program headers we allocated but did not use. */
4028 for (; count
< alloc
; count
++, p
++)
4030 memset (p
, 0, sizeof *p
);
4031 p
->p_type
= PT_NULL
;
4034 elf_tdata (abfd
)->phdr
= phdrs
;
4036 elf_tdata (abfd
)->next_file_pos
= off
;
4038 /* Write out the program headers. */
4039 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4040 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
4046 /* Get the size of the program header.
4048 If this is called by the linker before any of the section VMA's are set, it
4049 can't calculate the correct value for a strange memory layout. This only
4050 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4051 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4052 data segment (exclusive of .interp and .dynamic).
4054 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4055 will be two segments. */
4057 static bfd_size_type
4058 get_program_header_size (bfd
*abfd
)
4062 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4064 /* We can't return a different result each time we're called. */
4065 if (elf_tdata (abfd
)->program_header_size
!= 0)
4066 return elf_tdata (abfd
)->program_header_size
;
4068 if (elf_tdata (abfd
)->segment_map
!= NULL
)
4070 struct elf_segment_map
*m
;
4073 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4075 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4076 return elf_tdata (abfd
)->program_header_size
;
4079 /* Assume we will need exactly two PT_LOAD segments: one for text
4080 and one for data. */
4083 s
= bfd_get_section_by_name (abfd
, ".interp");
4084 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4086 /* If we have a loadable interpreter section, we need a
4087 PT_INTERP segment. In this case, assume we also need a
4088 PT_PHDR segment, although that may not be true for all
4093 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4095 /* We need a PT_DYNAMIC segment. */
4099 if (elf_tdata (abfd
)->eh_frame_hdr
)
4101 /* We need a PT_GNU_EH_FRAME segment. */
4105 if (elf_tdata (abfd
)->stack_flags
)
4107 /* We need a PT_GNU_STACK segment. */
4111 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4113 if ((s
->flags
& SEC_LOAD
) != 0
4114 && strncmp (s
->name
, ".note", 5) == 0)
4116 /* We need a PT_NOTE segment. */
4121 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4123 if (s
->flags
& SEC_THREAD_LOCAL
)
4125 /* We need a PT_TLS segment. */
4131 /* Let the backend count up any program headers it might need. */
4132 if (bed
->elf_backend_additional_program_headers
)
4136 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
4142 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4143 return elf_tdata (abfd
)->program_header_size
;
4146 /* Work out the file positions of all the sections. This is called by
4147 _bfd_elf_compute_section_file_positions. All the section sizes and
4148 VMAs must be known before this is called.
4150 We do not consider reloc sections at this point, unless they form
4151 part of the loadable image. Reloc sections are assigned file
4152 positions in assign_file_positions_for_relocs, which is called by
4153 write_object_contents and final_link.
4155 We also don't set the positions of the .symtab and .strtab here. */
4158 assign_file_positions_except_relocs (bfd
*abfd
)
4160 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
4161 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
4162 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4163 unsigned int num_sec
= elf_numsections (abfd
);
4165 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4167 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4168 && bfd_get_format (abfd
) != bfd_core
)
4170 Elf_Internal_Shdr
**hdrpp
;
4173 /* Start after the ELF header. */
4174 off
= i_ehdrp
->e_ehsize
;
4176 /* We are not creating an executable, which means that we are
4177 not creating a program header, and that the actual order of
4178 the sections in the file is unimportant. */
4179 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4181 Elf_Internal_Shdr
*hdr
;
4184 if (hdr
->sh_type
== SHT_REL
4185 || hdr
->sh_type
== SHT_RELA
4186 || i
== tdata
->symtab_section
4187 || i
== tdata
->symtab_shndx_section
4188 || i
== tdata
->strtab_section
)
4190 hdr
->sh_offset
= -1;
4193 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4195 if (i
== SHN_LORESERVE
- 1)
4197 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4198 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4205 Elf_Internal_Shdr
**hdrpp
;
4207 /* Assign file positions for the loaded sections based on the
4208 assignment of sections to segments. */
4209 if (! assign_file_positions_for_segments (abfd
))
4212 /* Assign file positions for the other sections. */
4214 off
= elf_tdata (abfd
)->next_file_pos
;
4215 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4217 Elf_Internal_Shdr
*hdr
;
4220 if (hdr
->bfd_section
!= NULL
4221 && hdr
->bfd_section
->filepos
!= 0)
4222 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
4223 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4225 ((*_bfd_error_handler
)
4226 (_("%s: warning: allocated section `%s' not in segment"),
4227 bfd_get_filename (abfd
),
4228 (hdr
->bfd_section
== NULL
4230 : hdr
->bfd_section
->name
)));
4231 if ((abfd
->flags
& D_PAGED
) != 0)
4232 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
4234 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
4235 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4238 else if (hdr
->sh_type
== SHT_REL
4239 || hdr
->sh_type
== SHT_RELA
4240 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4241 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4242 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4243 hdr
->sh_offset
= -1;
4245 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4247 if (i
== SHN_LORESERVE
- 1)
4249 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4250 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4255 /* Place the section headers. */
4256 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4257 i_ehdrp
->e_shoff
= off
;
4258 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4260 elf_tdata (abfd
)->next_file_pos
= off
;
4266 prep_headers (bfd
*abfd
)
4268 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4269 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4270 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4271 struct elf_strtab_hash
*shstrtab
;
4272 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4274 i_ehdrp
= elf_elfheader (abfd
);
4275 i_shdrp
= elf_elfsections (abfd
);
4277 shstrtab
= _bfd_elf_strtab_init ();
4278 if (shstrtab
== NULL
)
4281 elf_shstrtab (abfd
) = shstrtab
;
4283 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4284 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4285 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4286 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4288 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4289 i_ehdrp
->e_ident
[EI_DATA
] =
4290 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4291 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4293 if ((abfd
->flags
& DYNAMIC
) != 0)
4294 i_ehdrp
->e_type
= ET_DYN
;
4295 else if ((abfd
->flags
& EXEC_P
) != 0)
4296 i_ehdrp
->e_type
= ET_EXEC
;
4297 else if (bfd_get_format (abfd
) == bfd_core
)
4298 i_ehdrp
->e_type
= ET_CORE
;
4300 i_ehdrp
->e_type
= ET_REL
;
4302 switch (bfd_get_arch (abfd
))
4304 case bfd_arch_unknown
:
4305 i_ehdrp
->e_machine
= EM_NONE
;
4308 /* There used to be a long list of cases here, each one setting
4309 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4310 in the corresponding bfd definition. To avoid duplication,
4311 the switch was removed. Machines that need special handling
4312 can generally do it in elf_backend_final_write_processing(),
4313 unless they need the information earlier than the final write.
4314 Such need can generally be supplied by replacing the tests for
4315 e_machine with the conditions used to determine it. */
4317 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4320 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4321 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4323 /* No program header, for now. */
4324 i_ehdrp
->e_phoff
= 0;
4325 i_ehdrp
->e_phentsize
= 0;
4326 i_ehdrp
->e_phnum
= 0;
4328 /* Each bfd section is section header entry. */
4329 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4330 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4332 /* If we're building an executable, we'll need a program header table. */
4333 if (abfd
->flags
& EXEC_P
)
4335 /* It all happens later. */
4337 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
4339 /* elf_build_phdrs() returns a (NULL-terminated) array of
4340 Elf_Internal_Phdrs. */
4341 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
4342 i_ehdrp
->e_phoff
= outbase
;
4343 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
4348 i_ehdrp
->e_phentsize
= 0;
4350 i_ehdrp
->e_phoff
= 0;
4353 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4354 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4355 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4356 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4357 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4358 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4359 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4360 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4361 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4367 /* Assign file positions for all the reloc sections which are not part
4368 of the loadable file image. */
4371 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4374 unsigned int i
, num_sec
;
4375 Elf_Internal_Shdr
**shdrpp
;
4377 off
= elf_tdata (abfd
)->next_file_pos
;
4379 num_sec
= elf_numsections (abfd
);
4380 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4382 Elf_Internal_Shdr
*shdrp
;
4385 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4386 && shdrp
->sh_offset
== -1)
4387 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4390 elf_tdata (abfd
)->next_file_pos
= off
;
4394 _bfd_elf_write_object_contents (bfd
*abfd
)
4396 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4397 Elf_Internal_Ehdr
*i_ehdrp
;
4398 Elf_Internal_Shdr
**i_shdrp
;
4400 unsigned int count
, num_sec
;
4402 if (! abfd
->output_has_begun
4403 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4406 i_shdrp
= elf_elfsections (abfd
);
4407 i_ehdrp
= elf_elfheader (abfd
);
4410 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4414 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4416 /* After writing the headers, we need to write the sections too... */
4417 num_sec
= elf_numsections (abfd
);
4418 for (count
= 1; count
< num_sec
; count
++)
4420 if (bed
->elf_backend_section_processing
)
4421 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4422 if (i_shdrp
[count
]->contents
)
4424 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4426 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4427 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4430 if (count
== SHN_LORESERVE
- 1)
4431 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4434 /* Write out the section header names. */
4435 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4436 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4439 if (bed
->elf_backend_final_write_processing
)
4440 (*bed
->elf_backend_final_write_processing
) (abfd
,
4441 elf_tdata (abfd
)->linker
);
4443 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4447 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4449 /* Hopefully this can be done just like an object file. */
4450 return _bfd_elf_write_object_contents (abfd
);
4453 /* Given a section, search the header to find them. */
4456 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct sec
*asect
)
4458 const struct elf_backend_data
*bed
;
4461 if (elf_section_data (asect
) != NULL
4462 && elf_section_data (asect
)->this_idx
!= 0)
4463 return elf_section_data (asect
)->this_idx
;
4465 if (bfd_is_abs_section (asect
))
4467 else if (bfd_is_com_section (asect
))
4469 else if (bfd_is_und_section (asect
))
4473 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4474 int maxindex
= elf_numsections (abfd
);
4476 for (index
= 1; index
< maxindex
; index
++)
4478 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4480 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4486 bed
= get_elf_backend_data (abfd
);
4487 if (bed
->elf_backend_section_from_bfd_section
)
4491 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4496 bfd_set_error (bfd_error_nonrepresentable_section
);
4501 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4505 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
4507 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4509 flagword flags
= asym_ptr
->flags
;
4511 /* When gas creates relocations against local labels, it creates its
4512 own symbol for the section, but does put the symbol into the
4513 symbol chain, so udata is 0. When the linker is generating
4514 relocatable output, this section symbol may be for one of the
4515 input sections rather than the output section. */
4516 if (asym_ptr
->udata
.i
== 0
4517 && (flags
& BSF_SECTION_SYM
)
4518 && asym_ptr
->section
)
4522 if (asym_ptr
->section
->output_section
!= NULL
)
4523 indx
= asym_ptr
->section
->output_section
->index
;
4525 indx
= asym_ptr
->section
->index
;
4526 if (indx
< elf_num_section_syms (abfd
)
4527 && elf_section_syms (abfd
)[indx
] != NULL
)
4528 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4531 idx
= asym_ptr
->udata
.i
;
4535 /* This case can occur when using --strip-symbol on a symbol
4536 which is used in a relocation entry. */
4537 (*_bfd_error_handler
)
4538 (_("%s: symbol `%s' required but not present"),
4539 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4540 bfd_set_error (bfd_error_no_symbols
);
4547 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4548 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4549 elf_symbol_flags (flags
));
4557 /* Copy private BFD data. This copies any program header information. */
4560 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4562 Elf_Internal_Ehdr
*iehdr
;
4563 struct elf_segment_map
*map
;
4564 struct elf_segment_map
*map_first
;
4565 struct elf_segment_map
**pointer_to_map
;
4566 Elf_Internal_Phdr
*segment
;
4569 unsigned int num_segments
;
4570 bfd_boolean phdr_included
= FALSE
;
4571 bfd_vma maxpagesize
;
4572 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
4573 unsigned int phdr_adjust_num
= 0;
4574 const struct elf_backend_data
*bed
;
4576 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4577 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4580 if (elf_tdata (ibfd
)->phdr
== NULL
)
4583 bed
= get_elf_backend_data (ibfd
);
4584 iehdr
= elf_elfheader (ibfd
);
4587 pointer_to_map
= &map_first
;
4589 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4590 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4592 /* Returns the end address of the segment + 1. */
4593 #define SEGMENT_END(segment, start) \
4594 (start + (segment->p_memsz > segment->p_filesz \
4595 ? segment->p_memsz : segment->p_filesz))
4597 #define SECTION_SIZE(section, segment) \
4598 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4599 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
4600 ? section->_raw_size : 0)
4602 /* Returns TRUE if the given section is contained within
4603 the given segment. VMA addresses are compared. */
4604 #define IS_CONTAINED_BY_VMA(section, segment) \
4605 (section->vma >= segment->p_vaddr \
4606 && (section->vma + SECTION_SIZE (section, segment) \
4607 <= (SEGMENT_END (segment, segment->p_vaddr))))
4609 /* Returns TRUE if the given section is contained within
4610 the given segment. LMA addresses are compared. */
4611 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4612 (section->lma >= base \
4613 && (section->lma + SECTION_SIZE (section, segment) \
4614 <= SEGMENT_END (segment, base)))
4616 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4617 #define IS_COREFILE_NOTE(p, s) \
4618 (p->p_type == PT_NOTE \
4619 && bfd_get_format (ibfd) == bfd_core \
4620 && s->vma == 0 && s->lma == 0 \
4621 && (bfd_vma) s->filepos >= p->p_offset \
4622 && ((bfd_vma) s->filepos + s->_raw_size \
4623 <= p->p_offset + p->p_filesz))
4625 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4626 linker, which generates a PT_INTERP section with p_vaddr and
4627 p_memsz set to 0. */
4628 #define IS_SOLARIS_PT_INTERP(p, s) \
4630 && p->p_paddr == 0 \
4631 && p->p_memsz == 0 \
4632 && p->p_filesz > 0 \
4633 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4634 && s->_raw_size > 0 \
4635 && (bfd_vma) s->filepos >= p->p_offset \
4636 && ((bfd_vma) s->filepos + s->_raw_size \
4637 <= p->p_offset + p->p_filesz))
4639 /* Decide if the given section should be included in the given segment.
4640 A section will be included if:
4641 1. It is within the address space of the segment -- we use the LMA
4642 if that is set for the segment and the VMA otherwise,
4643 2. It is an allocated segment,
4644 3. There is an output section associated with it,
4645 4. The section has not already been allocated to a previous segment.
4646 5. PT_TLS segment includes only SHF_TLS sections.
4647 6. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
4648 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4649 ((((segment->p_paddr \
4650 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4651 : IS_CONTAINED_BY_VMA (section, segment)) \
4652 && (section->flags & SEC_ALLOC) != 0) \
4653 || IS_COREFILE_NOTE (segment, section)) \
4654 && section->output_section != NULL \
4655 && (segment->p_type != PT_TLS \
4656 || (section->flags & SEC_THREAD_LOCAL)) \
4657 && (segment->p_type == PT_LOAD \
4658 || segment->p_type == PT_TLS \
4659 || (section->flags & SEC_THREAD_LOCAL) == 0) \
4660 && ! section->segment_mark)
4662 /* Returns TRUE iff seg1 starts after the end of seg2. */
4663 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
4664 (seg1->field >= SEGMENT_END (seg2, seg2->field))
4666 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4667 their VMA address ranges and their LMA address ranges overlap.
4668 It is possible to have overlapping VMA ranges without overlapping LMA
4669 ranges. RedBoot images for example can have both .data and .bss mapped
4670 to the same VMA range, but with the .data section mapped to a different
4672 #define SEGMENT_OVERLAPS(seg1, seg2) \
4673 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
4674 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
4675 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
4676 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4678 /* Initialise the segment mark field. */
4679 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4680 section
->segment_mark
= FALSE
;
4682 /* Scan through the segments specified in the program header
4683 of the input BFD. For this first scan we look for overlaps
4684 in the loadable segments. These can be created by weird
4685 parameters to objcopy. Also, fix some solaris weirdness. */
4686 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4691 Elf_Internal_Phdr
*segment2
;
4693 if (segment
->p_type
== PT_INTERP
)
4694 for (section
= ibfd
->sections
; section
; section
= section
->next
)
4695 if (IS_SOLARIS_PT_INTERP (segment
, section
))
4697 /* Mininal change so that the normal section to segment
4698 assigment code will work. */
4699 segment
->p_vaddr
= section
->vma
;
4703 if (segment
->p_type
!= PT_LOAD
)
4706 /* Determine if this segment overlaps any previous segments. */
4707 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4709 bfd_signed_vma extra_length
;
4711 if (segment2
->p_type
!= PT_LOAD
4712 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4715 /* Merge the two segments together. */
4716 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4718 /* Extend SEGMENT2 to include SEGMENT and then delete
4721 SEGMENT_END (segment
, segment
->p_vaddr
)
4722 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4724 if (extra_length
> 0)
4726 segment2
->p_memsz
+= extra_length
;
4727 segment2
->p_filesz
+= extra_length
;
4730 segment
->p_type
= PT_NULL
;
4732 /* Since we have deleted P we must restart the outer loop. */
4734 segment
= elf_tdata (ibfd
)->phdr
;
4739 /* Extend SEGMENT to include SEGMENT2 and then delete
4742 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4743 - SEGMENT_END (segment
, segment
->p_vaddr
);
4745 if (extra_length
> 0)
4747 segment
->p_memsz
+= extra_length
;
4748 segment
->p_filesz
+= extra_length
;
4751 segment2
->p_type
= PT_NULL
;
4756 /* The second scan attempts to assign sections to segments. */
4757 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4761 unsigned int section_count
;
4762 asection
** sections
;
4763 asection
* output_section
;
4765 bfd_vma matching_lma
;
4766 bfd_vma suggested_lma
;
4770 if (segment
->p_type
== PT_NULL
)
4773 /* Compute how many sections might be placed into this segment. */
4774 for (section
= ibfd
->sections
, section_count
= 0;
4776 section
= section
->next
)
4777 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
4780 /* Allocate a segment map big enough to contain
4781 all of the sections we have selected. */
4782 amt
= sizeof (struct elf_segment_map
);
4783 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4784 map
= bfd_alloc (obfd
, amt
);
4788 /* Initialise the fields of the segment map. Default to
4789 using the physical address of the segment in the input BFD. */
4791 map
->p_type
= segment
->p_type
;
4792 map
->p_flags
= segment
->p_flags
;
4793 map
->p_flags_valid
= 1;
4794 map
->p_paddr
= segment
->p_paddr
;
4795 map
->p_paddr_valid
= 1;
4797 /* Determine if this segment contains the ELF file header
4798 and if it contains the program headers themselves. */
4799 map
->includes_filehdr
= (segment
->p_offset
== 0
4800 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4802 map
->includes_phdrs
= 0;
4804 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4806 map
->includes_phdrs
=
4807 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4808 && (segment
->p_offset
+ segment
->p_filesz
4809 >= ((bfd_vma
) iehdr
->e_phoff
4810 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4812 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4813 phdr_included
= TRUE
;
4816 if (section_count
== 0)
4818 /* Special segments, such as the PT_PHDR segment, may contain
4819 no sections, but ordinary, loadable segments should contain
4820 something. They are allowed by the ELF spec however, so only
4821 a warning is produced. */
4822 if (segment
->p_type
== PT_LOAD
)
4823 (*_bfd_error_handler
)
4824 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4825 bfd_archive_filename (ibfd
));
4828 *pointer_to_map
= map
;
4829 pointer_to_map
= &map
->next
;
4834 /* Now scan the sections in the input BFD again and attempt
4835 to add their corresponding output sections to the segment map.
4836 The problem here is how to handle an output section which has
4837 been moved (ie had its LMA changed). There are four possibilities:
4839 1. None of the sections have been moved.
4840 In this case we can continue to use the segment LMA from the
4843 2. All of the sections have been moved by the same amount.
4844 In this case we can change the segment's LMA to match the LMA
4845 of the first section.
4847 3. Some of the sections have been moved, others have not.
4848 In this case those sections which have not been moved can be
4849 placed in the current segment which will have to have its size,
4850 and possibly its LMA changed, and a new segment or segments will
4851 have to be created to contain the other sections.
4853 4. The sections have been moved, but not by the same amount.
4854 In this case we can change the segment's LMA to match the LMA
4855 of the first section and we will have to create a new segment
4856 or segments to contain the other sections.
4858 In order to save time, we allocate an array to hold the section
4859 pointers that we are interested in. As these sections get assigned
4860 to a segment, they are removed from this array. */
4862 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4863 to work around this long long bug. */
4864 amt
= section_count
* sizeof (asection
*);
4865 sections
= bfd_malloc (amt
);
4866 if (sections
== NULL
)
4869 /* Step One: Scan for segment vs section LMA conflicts.
4870 Also add the sections to the section array allocated above.
4871 Also add the sections to the current segment. In the common
4872 case, where the sections have not been moved, this means that
4873 we have completely filled the segment, and there is nothing
4879 for (j
= 0, section
= ibfd
->sections
;
4881 section
= section
->next
)
4883 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
4885 output_section
= section
->output_section
;
4887 sections
[j
++] = section
;
4889 /* The Solaris native linker always sets p_paddr to 0.
4890 We try to catch that case here, and set it to the
4891 correct value. Note - some backends require that
4892 p_paddr be left as zero. */
4893 if (segment
->p_paddr
== 0
4894 && segment
->p_vaddr
!= 0
4895 && (! bed
->want_p_paddr_set_to_zero
)
4897 && output_section
->lma
!= 0
4898 && (output_section
->vma
== (segment
->p_vaddr
4899 + (map
->includes_filehdr
4902 + (map
->includes_phdrs
4904 * iehdr
->e_phentsize
)
4906 map
->p_paddr
= segment
->p_vaddr
;
4908 /* Match up the physical address of the segment with the
4909 LMA address of the output section. */
4910 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
4911 || IS_COREFILE_NOTE (segment
, section
)
4912 || (bed
->want_p_paddr_set_to_zero
&&
4913 IS_CONTAINED_BY_VMA (output_section
, segment
))
4916 if (matching_lma
== 0)
4917 matching_lma
= output_section
->lma
;
4919 /* We assume that if the section fits within the segment
4920 then it does not overlap any other section within that
4922 map
->sections
[isec
++] = output_section
;
4924 else if (suggested_lma
== 0)
4925 suggested_lma
= output_section
->lma
;
4929 BFD_ASSERT (j
== section_count
);
4931 /* Step Two: Adjust the physical address of the current segment,
4933 if (isec
== section_count
)
4935 /* All of the sections fitted within the segment as currently
4936 specified. This is the default case. Add the segment to
4937 the list of built segments and carry on to process the next
4938 program header in the input BFD. */
4939 map
->count
= section_count
;
4940 *pointer_to_map
= map
;
4941 pointer_to_map
= &map
->next
;
4948 if (matching_lma
!= 0)
4950 /* At least one section fits inside the current segment.
4951 Keep it, but modify its physical address to match the
4952 LMA of the first section that fitted. */
4953 map
->p_paddr
= matching_lma
;
4957 /* None of the sections fitted inside the current segment.
4958 Change the current segment's physical address to match
4959 the LMA of the first section. */
4960 map
->p_paddr
= suggested_lma
;
4963 /* Offset the segment physical address from the lma
4964 to allow for space taken up by elf headers. */
4965 if (map
->includes_filehdr
)
4966 map
->p_paddr
-= iehdr
->e_ehsize
;
4968 if (map
->includes_phdrs
)
4970 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
4972 /* iehdr->e_phnum is just an estimate of the number
4973 of program headers that we will need. Make a note
4974 here of the number we used and the segment we chose
4975 to hold these headers, so that we can adjust the
4976 offset when we know the correct value. */
4977 phdr_adjust_num
= iehdr
->e_phnum
;
4978 phdr_adjust_seg
= map
;
4982 /* Step Three: Loop over the sections again, this time assigning
4983 those that fit to the current segment and removing them from the
4984 sections array; but making sure not to leave large gaps. Once all
4985 possible sections have been assigned to the current segment it is
4986 added to the list of built segments and if sections still remain
4987 to be assigned, a new segment is constructed before repeating
4995 /* Fill the current segment with sections that fit. */
4996 for (j
= 0; j
< section_count
; j
++)
4998 section
= sections
[j
];
5000 if (section
== NULL
)
5003 output_section
= section
->output_section
;
5005 BFD_ASSERT (output_section
!= NULL
);
5007 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5008 || IS_COREFILE_NOTE (segment
, section
))
5010 if (map
->count
== 0)
5012 /* If the first section in a segment does not start at
5013 the beginning of the segment, then something is
5015 if (output_section
->lma
!=
5017 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5018 + (map
->includes_phdrs
5019 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5025 asection
* prev_sec
;
5027 prev_sec
= map
->sections
[map
->count
- 1];
5029 /* If the gap between the end of the previous section
5030 and the start of this section is more than
5031 maxpagesize then we need to start a new segment. */
5032 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
,
5034 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5035 || ((prev_sec
->lma
+ prev_sec
->_raw_size
)
5036 > output_section
->lma
))
5038 if (suggested_lma
== 0)
5039 suggested_lma
= output_section
->lma
;
5045 map
->sections
[map
->count
++] = output_section
;
5048 section
->segment_mark
= TRUE
;
5050 else if (suggested_lma
== 0)
5051 suggested_lma
= output_section
->lma
;
5054 BFD_ASSERT (map
->count
> 0);
5056 /* Add the current segment to the list of built segments. */
5057 *pointer_to_map
= map
;
5058 pointer_to_map
= &map
->next
;
5060 if (isec
< section_count
)
5062 /* We still have not allocated all of the sections to
5063 segments. Create a new segment here, initialise it
5064 and carry on looping. */
5065 amt
= sizeof (struct elf_segment_map
);
5066 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5067 map
= bfd_alloc (obfd
, amt
);
5074 /* Initialise the fields of the segment map. Set the physical
5075 physical address to the LMA of the first section that has
5076 not yet been assigned. */
5078 map
->p_type
= segment
->p_type
;
5079 map
->p_flags
= segment
->p_flags
;
5080 map
->p_flags_valid
= 1;
5081 map
->p_paddr
= suggested_lma
;
5082 map
->p_paddr_valid
= 1;
5083 map
->includes_filehdr
= 0;
5084 map
->includes_phdrs
= 0;
5087 while (isec
< section_count
);
5092 /* The Solaris linker creates program headers in which all the
5093 p_paddr fields are zero. When we try to objcopy or strip such a
5094 file, we get confused. Check for this case, and if we find it
5095 reset the p_paddr_valid fields. */
5096 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5097 if (map
->p_paddr
!= 0)
5100 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5101 map
->p_paddr_valid
= 0;
5103 elf_tdata (obfd
)->segment_map
= map_first
;
5105 /* If we had to estimate the number of program headers that were
5106 going to be needed, then check our estimate now and adjust
5107 the offset if necessary. */
5108 if (phdr_adjust_seg
!= NULL
)
5112 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5115 if (count
> phdr_adjust_num
)
5116 phdr_adjust_seg
->p_paddr
5117 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5121 /* Final Step: Sort the segments into ascending order of physical
5123 if (map_first
!= NULL
)
5125 struct elf_segment_map
*prev
;
5128 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
5130 /* Yes I know - its a bubble sort.... */
5131 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
5133 /* Swap map and map->next. */
5134 prev
->next
= map
->next
;
5135 map
->next
= map
->next
->next
;
5136 prev
->next
->next
= map
;
5147 #undef IS_CONTAINED_BY_VMA
5148 #undef IS_CONTAINED_BY_LMA
5149 #undef IS_COREFILE_NOTE
5150 #undef IS_SOLARIS_PT_INTERP
5151 #undef INCLUDE_SECTION_IN_SEGMENT
5152 #undef SEGMENT_AFTER_SEGMENT
5153 #undef SEGMENT_OVERLAPS
5157 /* Copy private section information. This copies over the entsize
5158 field, and sometimes the info field. */
5161 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
5166 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5168 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5169 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5172 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
5176 /* Only set up the segments if there are no more SEC_ALLOC
5177 sections. FIXME: This won't do the right thing if objcopy is
5178 used to remove the last SEC_ALLOC section, since objcopy
5179 won't call this routine in that case. */
5180 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
5181 if ((s
->flags
& SEC_ALLOC
) != 0)
5185 if (! copy_private_bfd_data (ibfd
, obfd
))
5190 ihdr
= &elf_section_data (isec
)->this_hdr
;
5191 ohdr
= &elf_section_data (osec
)->this_hdr
;
5193 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
5195 if (ihdr
->sh_type
== SHT_SYMTAB
5196 || ihdr
->sh_type
== SHT_DYNSYM
5197 || ihdr
->sh_type
== SHT_GNU_verneed
5198 || ihdr
->sh_type
== SHT_GNU_verdef
)
5199 ohdr
->sh_info
= ihdr
->sh_info
;
5201 /* Set things up for objcopy. The output SHT_GROUP section will
5202 have its elf_next_in_group pointing back to the input group
5204 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5205 elf_group_name (osec
) = elf_group_name (isec
);
5207 osec
->use_rela_p
= isec
->use_rela_p
;
5212 /* Copy private symbol information. If this symbol is in a section
5213 which we did not map into a BFD section, try to map the section
5214 index correctly. We use special macro definitions for the mapped
5215 section indices; these definitions are interpreted by the
5216 swap_out_syms function. */
5218 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5219 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5220 #define MAP_STRTAB (SHN_HIOS + 3)
5221 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5222 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5225 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
5230 elf_symbol_type
*isym
, *osym
;
5232 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5233 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5236 isym
= elf_symbol_from (ibfd
, isymarg
);
5237 osym
= elf_symbol_from (obfd
, osymarg
);
5241 && bfd_is_abs_section (isym
->symbol
.section
))
5245 shndx
= isym
->internal_elf_sym
.st_shndx
;
5246 if (shndx
== elf_onesymtab (ibfd
))
5247 shndx
= MAP_ONESYMTAB
;
5248 else if (shndx
== elf_dynsymtab (ibfd
))
5249 shndx
= MAP_DYNSYMTAB
;
5250 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
5252 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
5253 shndx
= MAP_SHSTRTAB
;
5254 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
5255 shndx
= MAP_SYM_SHNDX
;
5256 osym
->internal_elf_sym
.st_shndx
= shndx
;
5262 /* Swap out the symbols. */
5265 swap_out_syms (bfd
*abfd
,
5266 struct bfd_strtab_hash
**sttp
,
5269 const struct elf_backend_data
*bed
;
5272 struct bfd_strtab_hash
*stt
;
5273 Elf_Internal_Shdr
*symtab_hdr
;
5274 Elf_Internal_Shdr
*symtab_shndx_hdr
;
5275 Elf_Internal_Shdr
*symstrtab_hdr
;
5276 char *outbound_syms
;
5277 char *outbound_shndx
;
5281 if (!elf_map_symbols (abfd
))
5284 /* Dump out the symtabs. */
5285 stt
= _bfd_elf_stringtab_init ();
5289 bed
= get_elf_backend_data (abfd
);
5290 symcount
= bfd_get_symcount (abfd
);
5291 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5292 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5293 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
5294 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
5295 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
5296 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
5298 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5299 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5301 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
5302 outbound_syms
= bfd_alloc (abfd
, amt
);
5303 if (outbound_syms
== NULL
)
5305 _bfd_stringtab_free (stt
);
5308 symtab_hdr
->contents
= outbound_syms
;
5310 outbound_shndx
= NULL
;
5311 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
5312 if (symtab_shndx_hdr
->sh_name
!= 0)
5314 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
5315 outbound_shndx
= bfd_zalloc (abfd
, amt
);
5316 if (outbound_shndx
== NULL
)
5318 _bfd_stringtab_free (stt
);
5322 symtab_shndx_hdr
->contents
= outbound_shndx
;
5323 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
5324 symtab_shndx_hdr
->sh_size
= amt
;
5325 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
5326 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
5329 /* Now generate the data (for "contents"). */
5331 /* Fill in zeroth symbol and swap it out. */
5332 Elf_Internal_Sym sym
;
5338 sym
.st_shndx
= SHN_UNDEF
;
5339 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5340 outbound_syms
+= bed
->s
->sizeof_sym
;
5341 if (outbound_shndx
!= NULL
)
5342 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5345 syms
= bfd_get_outsymbols (abfd
);
5346 for (idx
= 0; idx
< symcount
; idx
++)
5348 Elf_Internal_Sym sym
;
5349 bfd_vma value
= syms
[idx
]->value
;
5350 elf_symbol_type
*type_ptr
;
5351 flagword flags
= syms
[idx
]->flags
;
5354 if ((flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
5356 /* Local section symbols have no name. */
5361 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
5364 if (sym
.st_name
== (unsigned long) -1)
5366 _bfd_stringtab_free (stt
);
5371 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
5373 if ((flags
& BSF_SECTION_SYM
) == 0
5374 && bfd_is_com_section (syms
[idx
]->section
))
5376 /* ELF common symbols put the alignment into the `value' field,
5377 and the size into the `size' field. This is backwards from
5378 how BFD handles it, so reverse it here. */
5379 sym
.st_size
= value
;
5380 if (type_ptr
== NULL
5381 || type_ptr
->internal_elf_sym
.st_value
== 0)
5382 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
5384 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
5385 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
5386 (abfd
, syms
[idx
]->section
);
5390 asection
*sec
= syms
[idx
]->section
;
5393 if (sec
->output_section
)
5395 value
+= sec
->output_offset
;
5396 sec
= sec
->output_section
;
5399 /* Don't add in the section vma for relocatable output. */
5400 if (! relocatable_p
)
5402 sym
.st_value
= value
;
5403 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
5405 if (bfd_is_abs_section (sec
)
5407 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
5409 /* This symbol is in a real ELF section which we did
5410 not create as a BFD section. Undo the mapping done
5411 by copy_private_symbol_data. */
5412 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
5416 shndx
= elf_onesymtab (abfd
);
5419 shndx
= elf_dynsymtab (abfd
);
5422 shndx
= elf_tdata (abfd
)->strtab_section
;
5425 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5428 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5436 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5442 /* Writing this would be a hell of a lot easier if
5443 we had some decent documentation on bfd, and
5444 knew what to expect of the library, and what to
5445 demand of applications. For example, it
5446 appears that `objcopy' might not set the
5447 section of a symbol to be a section that is
5448 actually in the output file. */
5449 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5452 _bfd_error_handler (_("\
5453 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5454 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
5456 bfd_set_error (bfd_error_invalid_operation
);
5457 _bfd_stringtab_free (stt
);
5461 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5462 BFD_ASSERT (shndx
!= -1);
5466 sym
.st_shndx
= shndx
;
5469 if ((flags
& BSF_THREAD_LOCAL
) != 0)
5471 else if ((flags
& BSF_FUNCTION
) != 0)
5473 else if ((flags
& BSF_OBJECT
) != 0)
5478 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
5481 /* Processor-specific types. */
5482 if (type_ptr
!= NULL
5483 && bed
->elf_backend_get_symbol_type
)
5484 type
= ((*bed
->elf_backend_get_symbol_type
)
5485 (&type_ptr
->internal_elf_sym
, type
));
5487 if (flags
& BSF_SECTION_SYM
)
5489 if (flags
& BSF_GLOBAL
)
5490 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5492 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5494 else if (bfd_is_com_section (syms
[idx
]->section
))
5495 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5496 else if (bfd_is_und_section (syms
[idx
]->section
))
5497 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5501 else if (flags
& BSF_FILE
)
5502 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5505 int bind
= STB_LOCAL
;
5507 if (flags
& BSF_LOCAL
)
5509 else if (flags
& BSF_WEAK
)
5511 else if (flags
& BSF_GLOBAL
)
5514 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5517 if (type_ptr
!= NULL
)
5518 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5522 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5523 outbound_syms
+= bed
->s
->sizeof_sym
;
5524 if (outbound_shndx
!= NULL
)
5525 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5529 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5530 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5532 symstrtab_hdr
->sh_flags
= 0;
5533 symstrtab_hdr
->sh_addr
= 0;
5534 symstrtab_hdr
->sh_entsize
= 0;
5535 symstrtab_hdr
->sh_link
= 0;
5536 symstrtab_hdr
->sh_info
= 0;
5537 symstrtab_hdr
->sh_addralign
= 1;
5542 /* Return the number of bytes required to hold the symtab vector.
5544 Note that we base it on the count plus 1, since we will null terminate
5545 the vector allocated based on this size. However, the ELF symbol table
5546 always has a dummy entry as symbol #0, so it ends up even. */
5549 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
5553 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5555 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5556 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5558 symtab_size
-= sizeof (asymbol
*);
5564 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
5568 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5570 if (elf_dynsymtab (abfd
) == 0)
5572 bfd_set_error (bfd_error_invalid_operation
);
5576 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5577 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5579 symtab_size
-= sizeof (asymbol
*);
5585 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
5588 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5591 /* Canonicalize the relocs. */
5594 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
5601 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5603 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
5606 tblptr
= section
->relocation
;
5607 for (i
= 0; i
< section
->reloc_count
; i
++)
5608 *relptr
++ = tblptr
++;
5612 return section
->reloc_count
;
5616 _bfd_elf_get_symtab (bfd
*abfd
, asymbol
**allocation
)
5618 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5619 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
5622 bfd_get_symcount (abfd
) = symcount
;
5627 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
5628 asymbol
**allocation
)
5630 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5631 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
5634 bfd_get_dynamic_symcount (abfd
) = symcount
;
5638 /* Return the size required for the dynamic reloc entries. Any
5639 section that was actually installed in the BFD, and has type
5640 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5641 considered to be a dynamic reloc section. */
5644 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
5649 if (elf_dynsymtab (abfd
) == 0)
5651 bfd_set_error (bfd_error_invalid_operation
);
5655 ret
= sizeof (arelent
*);
5656 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5657 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5658 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5659 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5660 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5661 * sizeof (arelent
*));
5666 /* Canonicalize the dynamic relocation entries. Note that we return
5667 the dynamic relocations as a single block, although they are
5668 actually associated with particular sections; the interface, which
5669 was designed for SunOS style shared libraries, expects that there
5670 is only one set of dynamic relocs. Any section that was actually
5671 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5672 the dynamic symbol table, is considered to be a dynamic reloc
5676 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
5680 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5684 if (elf_dynsymtab (abfd
) == 0)
5686 bfd_set_error (bfd_error_invalid_operation
);
5690 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5692 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5694 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5695 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5696 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5701 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
5703 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5705 for (i
= 0; i
< count
; i
++)
5716 /* Read in the version information. */
5719 _bfd_elf_slurp_version_tables (bfd
*abfd
)
5721 bfd_byte
*contents
= NULL
;
5724 if (elf_dynverdef (abfd
) != 0)
5726 Elf_Internal_Shdr
*hdr
;
5727 Elf_External_Verdef
*everdef
;
5728 Elf_Internal_Verdef
*iverdef
;
5729 Elf_Internal_Verdef
*iverdefarr
;
5730 Elf_Internal_Verdef iverdefmem
;
5732 unsigned int maxidx
;
5734 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5736 contents
= bfd_malloc (hdr
->sh_size
);
5737 if (contents
== NULL
)
5739 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5740 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5743 /* We know the number of entries in the section but not the maximum
5744 index. Therefore we have to run through all entries and find
5746 everdef
= (Elf_External_Verdef
*) contents
;
5748 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5750 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5752 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5753 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5755 everdef
= ((Elf_External_Verdef
*)
5756 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5759 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5760 elf_tdata (abfd
)->verdef
= bfd_zalloc (abfd
, amt
);
5761 if (elf_tdata (abfd
)->verdef
== NULL
)
5764 elf_tdata (abfd
)->cverdefs
= maxidx
;
5766 everdef
= (Elf_External_Verdef
*) contents
;
5767 iverdefarr
= elf_tdata (abfd
)->verdef
;
5768 for (i
= 0; i
< hdr
->sh_info
; i
++)
5770 Elf_External_Verdaux
*everdaux
;
5771 Elf_Internal_Verdaux
*iverdaux
;
5774 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5776 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5777 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5779 iverdef
->vd_bfd
= abfd
;
5781 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5782 iverdef
->vd_auxptr
= bfd_alloc (abfd
, amt
);
5783 if (iverdef
->vd_auxptr
== NULL
)
5786 everdaux
= ((Elf_External_Verdaux
*)
5787 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5788 iverdaux
= iverdef
->vd_auxptr
;
5789 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5791 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5793 iverdaux
->vda_nodename
=
5794 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5795 iverdaux
->vda_name
);
5796 if (iverdaux
->vda_nodename
== NULL
)
5799 if (j
+ 1 < iverdef
->vd_cnt
)
5800 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5802 iverdaux
->vda_nextptr
= NULL
;
5804 everdaux
= ((Elf_External_Verdaux
*)
5805 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5808 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5810 if (i
+ 1 < hdr
->sh_info
)
5811 iverdef
->vd_nextdef
= iverdef
+ 1;
5813 iverdef
->vd_nextdef
= NULL
;
5815 everdef
= ((Elf_External_Verdef
*)
5816 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5823 if (elf_dynverref (abfd
) != 0)
5825 Elf_Internal_Shdr
*hdr
;
5826 Elf_External_Verneed
*everneed
;
5827 Elf_Internal_Verneed
*iverneed
;
5830 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5832 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5833 elf_tdata (abfd
)->verref
= bfd_zalloc (abfd
, amt
);
5834 if (elf_tdata (abfd
)->verref
== NULL
)
5837 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5839 contents
= bfd_malloc (hdr
->sh_size
);
5840 if (contents
== NULL
)
5842 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5843 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5846 everneed
= (Elf_External_Verneed
*) contents
;
5847 iverneed
= elf_tdata (abfd
)->verref
;
5848 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
5850 Elf_External_Vernaux
*evernaux
;
5851 Elf_Internal_Vernaux
*ivernaux
;
5854 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
5856 iverneed
->vn_bfd
= abfd
;
5858 iverneed
->vn_filename
=
5859 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5861 if (iverneed
->vn_filename
== NULL
)
5864 amt
= iverneed
->vn_cnt
;
5865 amt
*= sizeof (Elf_Internal_Vernaux
);
5866 iverneed
->vn_auxptr
= bfd_alloc (abfd
, amt
);
5868 evernaux
= ((Elf_External_Vernaux
*)
5869 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
5870 ivernaux
= iverneed
->vn_auxptr
;
5871 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
5873 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
5875 ivernaux
->vna_nodename
=
5876 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5877 ivernaux
->vna_name
);
5878 if (ivernaux
->vna_nodename
== NULL
)
5881 if (j
+ 1 < iverneed
->vn_cnt
)
5882 ivernaux
->vna_nextptr
= ivernaux
+ 1;
5884 ivernaux
->vna_nextptr
= NULL
;
5886 evernaux
= ((Elf_External_Vernaux
*)
5887 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
5890 if (i
+ 1 < hdr
->sh_info
)
5891 iverneed
->vn_nextref
= iverneed
+ 1;
5893 iverneed
->vn_nextref
= NULL
;
5895 everneed
= ((Elf_External_Verneed
*)
5896 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
5906 if (contents
!= NULL
)
5912 _bfd_elf_make_empty_symbol (bfd
*abfd
)
5914 elf_symbol_type
*newsym
;
5915 bfd_size_type amt
= sizeof (elf_symbol_type
);
5917 newsym
= bfd_zalloc (abfd
, amt
);
5922 newsym
->symbol
.the_bfd
= abfd
;
5923 return &newsym
->symbol
;
5928 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
5932 bfd_symbol_info (symbol
, ret
);
5935 /* Return whether a symbol name implies a local symbol. Most targets
5936 use this function for the is_local_label_name entry point, but some
5940 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
5943 /* Normal local symbols start with ``.L''. */
5944 if (name
[0] == '.' && name
[1] == 'L')
5947 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5948 DWARF debugging symbols starting with ``..''. */
5949 if (name
[0] == '.' && name
[1] == '.')
5952 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5953 emitting DWARF debugging output. I suspect this is actually a
5954 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5955 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5956 underscore to be emitted on some ELF targets). For ease of use,
5957 we treat such symbols as local. */
5958 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
5965 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
5966 asymbol
*symbol ATTRIBUTE_UNUSED
)
5973 _bfd_elf_set_arch_mach (bfd
*abfd
,
5974 enum bfd_architecture arch
,
5975 unsigned long machine
)
5977 /* If this isn't the right architecture for this backend, and this
5978 isn't the generic backend, fail. */
5979 if (arch
!= get_elf_backend_data (abfd
)->arch
5980 && arch
!= bfd_arch_unknown
5981 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
5984 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
5987 /* Find the function to a particular section and offset,
5988 for error reporting. */
5991 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
5995 const char **filename_ptr
,
5996 const char **functionname_ptr
)
5998 const char *filename
;
6007 for (p
= symbols
; *p
!= NULL
; p
++)
6011 q
= (elf_symbol_type
*) *p
;
6013 if (bfd_get_section (&q
->symbol
) != section
)
6016 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
6021 filename
= bfd_asymbol_name (&q
->symbol
);
6025 if (q
->symbol
.section
== section
6026 && q
->symbol
.value
>= low_func
6027 && q
->symbol
.value
<= offset
)
6029 func
= (asymbol
*) q
;
6030 low_func
= q
->symbol
.value
;
6040 *filename_ptr
= filename
;
6041 if (functionname_ptr
)
6042 *functionname_ptr
= bfd_asymbol_name (func
);
6047 /* Find the nearest line to a particular section and offset,
6048 for error reporting. */
6051 _bfd_elf_find_nearest_line (bfd
*abfd
,
6055 const char **filename_ptr
,
6056 const char **functionname_ptr
,
6057 unsigned int *line_ptr
)
6061 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
6062 filename_ptr
, functionname_ptr
,
6065 if (!*functionname_ptr
)
6066 elf_find_function (abfd
, section
, symbols
, offset
,
6067 *filename_ptr
? NULL
: filename_ptr
,
6073 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
6074 filename_ptr
, functionname_ptr
,
6076 &elf_tdata (abfd
)->dwarf2_find_line_info
))
6078 if (!*functionname_ptr
)
6079 elf_find_function (abfd
, section
, symbols
, offset
,
6080 *filename_ptr
? NULL
: filename_ptr
,
6086 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
6087 &found
, filename_ptr
,
6088 functionname_ptr
, line_ptr
,
6089 &elf_tdata (abfd
)->line_info
))
6091 if (found
&& (*functionname_ptr
|| *line_ptr
))
6094 if (symbols
== NULL
)
6097 if (! elf_find_function (abfd
, section
, symbols
, offset
,
6098 filename_ptr
, functionname_ptr
))
6106 _bfd_elf_sizeof_headers (bfd
*abfd
, bfd_boolean reloc
)
6110 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
6112 ret
+= get_program_header_size (abfd
);
6117 _bfd_elf_set_section_contents (bfd
*abfd
,
6121 bfd_size_type count
)
6123 Elf_Internal_Shdr
*hdr
;
6126 if (! abfd
->output_has_begun
6127 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6130 hdr
= &elf_section_data (section
)->this_hdr
;
6131 pos
= hdr
->sh_offset
+ offset
;
6132 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6133 || bfd_bwrite (location
, count
, abfd
) != count
)
6140 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
6141 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
6142 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
6147 /* Try to convert a non-ELF reloc into an ELF one. */
6150 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
6152 /* Check whether we really have an ELF howto. */
6154 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
6156 bfd_reloc_code_real_type code
;
6157 reloc_howto_type
*howto
;
6159 /* Alien reloc: Try to determine its type to replace it with an
6160 equivalent ELF reloc. */
6162 if (areloc
->howto
->pc_relative
)
6164 switch (areloc
->howto
->bitsize
)
6167 code
= BFD_RELOC_8_PCREL
;
6170 code
= BFD_RELOC_12_PCREL
;
6173 code
= BFD_RELOC_16_PCREL
;
6176 code
= BFD_RELOC_24_PCREL
;
6179 code
= BFD_RELOC_32_PCREL
;
6182 code
= BFD_RELOC_64_PCREL
;
6188 howto
= bfd_reloc_type_lookup (abfd
, code
);
6190 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
6192 if (howto
->pcrel_offset
)
6193 areloc
->addend
+= areloc
->address
;
6195 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
6200 switch (areloc
->howto
->bitsize
)
6206 code
= BFD_RELOC_14
;
6209 code
= BFD_RELOC_16
;
6212 code
= BFD_RELOC_26
;
6215 code
= BFD_RELOC_32
;
6218 code
= BFD_RELOC_64
;
6224 howto
= bfd_reloc_type_lookup (abfd
, code
);
6228 areloc
->howto
= howto
;
6236 (*_bfd_error_handler
)
6237 (_("%s: unsupported relocation type %s"),
6238 bfd_archive_filename (abfd
), areloc
->howto
->name
);
6239 bfd_set_error (bfd_error_bad_value
);
6244 _bfd_elf_close_and_cleanup (bfd
*abfd
)
6246 if (bfd_get_format (abfd
) == bfd_object
)
6248 if (elf_shstrtab (abfd
) != NULL
)
6249 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
6252 return _bfd_generic_close_and_cleanup (abfd
);
6255 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6256 in the relocation's offset. Thus we cannot allow any sort of sanity
6257 range-checking to interfere. There is nothing else to do in processing
6260 bfd_reloc_status_type
6261 _bfd_elf_rel_vtable_reloc_fn
6262 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
6263 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
,
6264 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
6265 bfd
*obfd ATTRIBUTE_UNUSED
, 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 (bfd
*abfd
)
6284 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
6285 + (elf_tdata (abfd
)->core_pid
));
6288 /* If there isn't a section called NAME, make one, using
6289 data from SECT. Note, this function will generate a
6290 reference to NAME, so you shouldn't deallocate or
6294 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
6298 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
6301 sect2
= bfd_make_section (abfd
, name
);
6305 sect2
->_raw_size
= sect
->_raw_size
;
6306 sect2
->filepos
= sect
->filepos
;
6307 sect2
->flags
= sect
->flags
;
6308 sect2
->alignment_power
= sect
->alignment_power
;
6312 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6313 actually creates up to two pseudosections:
6314 - For the single-threaded case, a section named NAME, unless
6315 such a section already exists.
6316 - For the multi-threaded case, a section named "NAME/PID", where
6317 PID is elfcore_make_pid (abfd).
6318 Both pseudosections have identical contents. */
6320 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
6326 char *threaded_name
;
6330 /* Build the section name. */
6332 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
6333 len
= strlen (buf
) + 1;
6334 threaded_name
= bfd_alloc (abfd
, len
);
6335 if (threaded_name
== NULL
)
6337 memcpy (threaded_name
, buf
, len
);
6339 sect
= bfd_make_section (abfd
, threaded_name
);
6342 sect
->_raw_size
= size
;
6343 sect
->filepos
= filepos
;
6344 sect
->flags
= SEC_HAS_CONTENTS
;
6345 sect
->alignment_power
= 2;
6347 return elfcore_maybe_make_sect (abfd
, name
, sect
);
6350 /* prstatus_t exists on:
6352 linux 2.[01] + glibc
6356 #if defined (HAVE_PRSTATUS_T)
6359 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6364 if (note
->descsz
== sizeof (prstatus_t
))
6368 raw_size
= sizeof (prstat
.pr_reg
);
6369 offset
= offsetof (prstatus_t
, pr_reg
);
6370 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6372 /* Do not overwrite the core signal if it
6373 has already been set by another thread. */
6374 if (elf_tdata (abfd
)->core_signal
== 0)
6375 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6376 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6378 /* pr_who exists on:
6381 pr_who doesn't exist on:
6384 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6385 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6388 #if defined (HAVE_PRSTATUS32_T)
6389 else if (note
->descsz
== sizeof (prstatus32_t
))
6391 /* 64-bit host, 32-bit corefile */
6392 prstatus32_t prstat
;
6394 raw_size
= sizeof (prstat
.pr_reg
);
6395 offset
= offsetof (prstatus32_t
, pr_reg
);
6396 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6398 /* Do not overwrite the core signal if it
6399 has already been set by another thread. */
6400 if (elf_tdata (abfd
)->core_signal
== 0)
6401 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6402 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6404 /* pr_who exists on:
6407 pr_who doesn't exist on:
6410 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6411 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6414 #endif /* HAVE_PRSTATUS32_T */
6417 /* Fail - we don't know how to handle any other
6418 note size (ie. data object type). */
6422 /* Make a ".reg/999" section and a ".reg" section. */
6423 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6424 raw_size
, note
->descpos
+ offset
);
6426 #endif /* defined (HAVE_PRSTATUS_T) */
6428 /* Create a pseudosection containing the exact contents of NOTE. */
6430 elfcore_make_note_pseudosection (bfd
*abfd
,
6432 Elf_Internal_Note
*note
)
6434 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6435 note
->descsz
, note
->descpos
);
6438 /* There isn't a consistent prfpregset_t across platforms,
6439 but it doesn't matter, because we don't have to pick this
6440 data structure apart. */
6443 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
6445 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6448 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6449 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6453 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
6455 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6458 #if defined (HAVE_PRPSINFO_T)
6459 typedef prpsinfo_t elfcore_psinfo_t
;
6460 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6461 typedef prpsinfo32_t elfcore_psinfo32_t
;
6465 #if defined (HAVE_PSINFO_T)
6466 typedef psinfo_t elfcore_psinfo_t
;
6467 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6468 typedef psinfo32_t elfcore_psinfo32_t
;
6472 /* return a malloc'ed copy of a string at START which is at
6473 most MAX bytes long, possibly without a terminating '\0'.
6474 the copy will always have a terminating '\0'. */
6477 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
6480 char *end
= memchr (start
, '\0', max
);
6488 dups
= bfd_alloc (abfd
, len
+ 1);
6492 memcpy (dups
, start
, len
);
6498 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6500 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6502 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6504 elfcore_psinfo_t psinfo
;
6506 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6508 elf_tdata (abfd
)->core_program
6509 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6510 sizeof (psinfo
.pr_fname
));
6512 elf_tdata (abfd
)->core_command
6513 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6514 sizeof (psinfo
.pr_psargs
));
6516 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6517 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6519 /* 64-bit host, 32-bit corefile */
6520 elfcore_psinfo32_t psinfo
;
6522 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6524 elf_tdata (abfd
)->core_program
6525 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6526 sizeof (psinfo
.pr_fname
));
6528 elf_tdata (abfd
)->core_command
6529 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6530 sizeof (psinfo
.pr_psargs
));
6536 /* Fail - we don't know how to handle any other
6537 note size (ie. data object type). */
6541 /* Note that for some reason, a spurious space is tacked
6542 onto the end of the args in some (at least one anyway)
6543 implementations, so strip it off if it exists. */
6546 char *command
= elf_tdata (abfd
)->core_command
;
6547 int n
= strlen (command
);
6549 if (0 < n
&& command
[n
- 1] == ' ')
6550 command
[n
- 1] = '\0';
6555 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6557 #if defined (HAVE_PSTATUS_T)
6559 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6561 if (note
->descsz
== sizeof (pstatus_t
)
6562 #if defined (HAVE_PXSTATUS_T)
6563 || note
->descsz
== sizeof (pxstatus_t
)
6569 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6571 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6573 #if defined (HAVE_PSTATUS32_T)
6574 else if (note
->descsz
== sizeof (pstatus32_t
))
6576 /* 64-bit host, 32-bit corefile */
6579 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6581 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6584 /* Could grab some more details from the "representative"
6585 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6586 NT_LWPSTATUS note, presumably. */
6590 #endif /* defined (HAVE_PSTATUS_T) */
6592 #if defined (HAVE_LWPSTATUS_T)
6594 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6596 lwpstatus_t lwpstat
;
6602 if (note
->descsz
!= sizeof (lwpstat
)
6603 #if defined (HAVE_LWPXSTATUS_T)
6604 && note
->descsz
!= sizeof (lwpxstatus_t
)
6609 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6611 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6612 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6614 /* Make a ".reg/999" section. */
6616 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6617 len
= strlen (buf
) + 1;
6618 name
= bfd_alloc (abfd
, len
);
6621 memcpy (name
, buf
, len
);
6623 sect
= bfd_make_section (abfd
, name
);
6627 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6628 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6629 sect
->filepos
= note
->descpos
6630 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6633 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6634 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
6635 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6638 sect
->flags
= SEC_HAS_CONTENTS
;
6639 sect
->alignment_power
= 2;
6641 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6644 /* Make a ".reg2/999" section */
6646 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6647 len
= strlen (buf
) + 1;
6648 name
= bfd_alloc (abfd
, len
);
6651 memcpy (name
, buf
, len
);
6653 sect
= bfd_make_section (abfd
, name
);
6657 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6658 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6659 sect
->filepos
= note
->descpos
6660 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6663 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6664 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
6665 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6668 sect
->flags
= SEC_HAS_CONTENTS
;
6669 sect
->alignment_power
= 2;
6671 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6673 #endif /* defined (HAVE_LWPSTATUS_T) */
6675 #if defined (HAVE_WIN32_PSTATUS_T)
6677 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6683 win32_pstatus_t pstatus
;
6685 if (note
->descsz
< sizeof (pstatus
))
6688 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6690 switch (pstatus
.data_type
)
6692 case NOTE_INFO_PROCESS
:
6693 /* FIXME: need to add ->core_command. */
6694 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6695 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6698 case NOTE_INFO_THREAD
:
6699 /* Make a ".reg/999" section. */
6700 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6702 len
= strlen (buf
) + 1;
6703 name
= bfd_alloc (abfd
, len
);
6707 memcpy (name
, buf
, len
);
6709 sect
= bfd_make_section (abfd
, name
);
6713 sect
->_raw_size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6714 sect
->filepos
= (note
->descpos
6715 + offsetof (struct win32_pstatus
,
6716 data
.thread_info
.thread_context
));
6717 sect
->flags
= SEC_HAS_CONTENTS
;
6718 sect
->alignment_power
= 2;
6720 if (pstatus
.data
.thread_info
.is_active_thread
)
6721 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6725 case NOTE_INFO_MODULE
:
6726 /* Make a ".module/xxxxxxxx" section. */
6727 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6729 len
= strlen (buf
) + 1;
6730 name
= bfd_alloc (abfd
, len
);
6734 memcpy (name
, buf
, len
);
6736 sect
= bfd_make_section (abfd
, name
);
6741 sect
->_raw_size
= note
->descsz
;
6742 sect
->filepos
= note
->descpos
;
6743 sect
->flags
= SEC_HAS_CONTENTS
;
6744 sect
->alignment_power
= 2;
6753 #endif /* HAVE_WIN32_PSTATUS_T */
6756 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
6758 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6766 if (bed
->elf_backend_grok_prstatus
)
6767 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6769 #if defined (HAVE_PRSTATUS_T)
6770 return elfcore_grok_prstatus (abfd
, note
);
6775 #if defined (HAVE_PSTATUS_T)
6777 return elfcore_grok_pstatus (abfd
, note
);
6780 #if defined (HAVE_LWPSTATUS_T)
6782 return elfcore_grok_lwpstatus (abfd
, note
);
6785 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6786 return elfcore_grok_prfpreg (abfd
, note
);
6788 #if defined (HAVE_WIN32_PSTATUS_T)
6789 case NT_WIN32PSTATUS
:
6790 return elfcore_grok_win32pstatus (abfd
, note
);
6793 case NT_PRXFPREG
: /* Linux SSE extension */
6794 if (note
->namesz
== 6
6795 && strcmp (note
->namedata
, "LINUX") == 0)
6796 return elfcore_grok_prxfpreg (abfd
, note
);
6802 if (bed
->elf_backend_grok_psinfo
)
6803 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6805 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6806 return elfcore_grok_psinfo (abfd
, note
);
6813 asection
*sect
= bfd_make_section (abfd
, ".auxv");
6817 sect
->_raw_size
= note
->descsz
;
6818 sect
->filepos
= note
->descpos
;
6819 sect
->flags
= SEC_HAS_CONTENTS
;
6820 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
6828 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
6832 cp
= strchr (note
->namedata
, '@');
6835 *lwpidp
= atoi(cp
+ 1);
6842 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6845 /* Signal number at offset 0x08. */
6846 elf_tdata (abfd
)->core_signal
6847 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
6849 /* Process ID at offset 0x50. */
6850 elf_tdata (abfd
)->core_pid
6851 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
6853 /* Command name at 0x7c (max 32 bytes, including nul). */
6854 elf_tdata (abfd
)->core_command
6855 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
6861 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
6865 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
6866 elf_tdata (abfd
)->core_lwpid
= lwp
;
6868 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
6870 /* NetBSD-specific core "procinfo". Note that we expect to
6871 find this note before any of the others, which is fine,
6872 since the kernel writes this note out first when it
6873 creates a core file. */
6875 return elfcore_grok_netbsd_procinfo (abfd
, note
);
6878 /* As of Jan 2002 there are no other machine-independent notes
6879 defined for NetBSD core files. If the note type is less
6880 than the start of the machine-dependent note types, we don't
6883 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
6887 switch (bfd_get_arch (abfd
))
6889 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6890 PT_GETFPREGS == mach+2. */
6892 case bfd_arch_alpha
:
6893 case bfd_arch_sparc
:
6896 case NT_NETBSDCORE_FIRSTMACH
+0:
6897 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6899 case NT_NETBSDCORE_FIRSTMACH
+2:
6900 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6906 /* On all other arch's, PT_GETREGS == mach+1 and
6907 PT_GETFPREGS == mach+3. */
6912 case NT_NETBSDCORE_FIRSTMACH
+1:
6913 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
6915 case NT_NETBSDCORE_FIRSTMACH
+3:
6916 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6926 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t
*tid
)
6928 void *ddata
= note
->descdata
;
6935 /* nto_procfs_status 'pid' field is at offset 0. */
6936 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
6938 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
6939 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
6941 /* nto_procfs_status 'flags' field is at offset 8. */
6942 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
6944 /* nto_procfs_status 'what' field is at offset 14. */
6945 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
6947 elf_tdata (abfd
)->core_signal
= sig
;
6948 elf_tdata (abfd
)->core_lwpid
= *tid
;
6951 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
6952 do not come from signals so we make sure we set the current
6953 thread just in case. */
6954 if (flags
& 0x00000080)
6955 elf_tdata (abfd
)->core_lwpid
= *tid
;
6957 /* Make a ".qnx_core_status/%d" section. */
6958 sprintf (buf
, ".qnx_core_status/%d", *tid
);
6960 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
6965 sect
= bfd_make_section (abfd
, name
);
6969 sect
->_raw_size
= note
->descsz
;
6970 sect
->filepos
= note
->descpos
;
6971 sect
->flags
= SEC_HAS_CONTENTS
;
6972 sect
->alignment_power
= 2;
6974 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
6978 elfcore_grok_nto_gregs (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t tid
)
6984 /* Make a ".reg/%d" section. */
6985 sprintf (buf
, ".reg/%d", tid
);
6987 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
6992 sect
= bfd_make_section (abfd
, name
);
6996 sect
->_raw_size
= note
->descsz
;
6997 sect
->filepos
= note
->descpos
;
6998 sect
->flags
= SEC_HAS_CONTENTS
;
6999 sect
->alignment_power
= 2;
7001 /* This is the current thread. */
7002 if (elf_tdata (abfd
)->core_lwpid
== tid
)
7003 return elfcore_maybe_make_sect (abfd
, ".reg", sect
);
7008 #define BFD_QNT_CORE_INFO 7
7009 #define BFD_QNT_CORE_STATUS 8
7010 #define BFD_QNT_CORE_GREG 9
7011 #define BFD_QNT_CORE_FPREG 10
7014 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7016 /* Every GREG section has a STATUS section before it. Store the
7017 tid from the previous call to pass down to the next gregs
7019 static pid_t tid
= 1;
7023 case BFD_QNT_CORE_INFO
: return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
7024 case BFD_QNT_CORE_STATUS
: return elfcore_grok_nto_status (abfd
, note
, &tid
);
7025 case BFD_QNT_CORE_GREG
: return elfcore_grok_nto_gregs (abfd
, note
, tid
);
7026 case BFD_QNT_CORE_FPREG
: return elfcore_grok_prfpreg (abfd
, note
);
7027 default: return TRUE
;
7031 /* Function: elfcore_write_note
7038 size of data for note
7041 End of buffer containing note. */
7044 elfcore_write_note (bfd
*abfd
,
7052 Elf_External_Note
*xnp
;
7062 const struct elf_backend_data
*bed
;
7064 namesz
= strlen (name
) + 1;
7065 bed
= get_elf_backend_data (abfd
);
7066 pad
= -namesz
& ((1 << bed
->s
->log_file_align
) - 1);
7069 newspace
= sizeof (Elf_External_Note
) - 1 + namesz
+ pad
+ size
;
7071 p
= realloc (buf
, *bufsiz
+ newspace
);
7073 *bufsiz
+= newspace
;
7074 xnp
= (Elf_External_Note
*) dest
;
7075 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
7076 H_PUT_32 (abfd
, size
, xnp
->descsz
);
7077 H_PUT_32 (abfd
, type
, xnp
->type
);
7081 memcpy (dest
, name
, namesz
);
7089 memcpy (dest
, input
, size
);
7093 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7095 elfcore_write_prpsinfo (bfd
*abfd
,
7102 char *note_name
= "CORE";
7104 #if defined (HAVE_PSINFO_T)
7106 note_type
= NT_PSINFO
;
7109 note_type
= NT_PRPSINFO
;
7112 memset (&data
, 0, sizeof (data
));
7113 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
7114 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
7115 return elfcore_write_note (abfd
, buf
, bufsiz
,
7116 note_name
, note_type
, &data
, sizeof (data
));
7118 #endif /* PSINFO_T or PRPSINFO_T */
7120 #if defined (HAVE_PRSTATUS_T)
7122 elfcore_write_prstatus (bfd
*abfd
,
7130 char *note_name
= "CORE";
7132 memset (&prstat
, 0, sizeof (prstat
));
7133 prstat
.pr_pid
= pid
;
7134 prstat
.pr_cursig
= cursig
;
7135 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
7136 return elfcore_write_note (abfd
, buf
, bufsiz
,
7137 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
7139 #endif /* HAVE_PRSTATUS_T */
7141 #if defined (HAVE_LWPSTATUS_T)
7143 elfcore_write_lwpstatus (bfd
*abfd
,
7150 lwpstatus_t lwpstat
;
7151 char *note_name
= "CORE";
7153 memset (&lwpstat
, 0, sizeof (lwpstat
));
7154 lwpstat
.pr_lwpid
= pid
>> 16;
7155 lwpstat
.pr_cursig
= cursig
;
7156 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7157 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
7158 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7160 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
7161 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
7163 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
7164 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
7167 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7168 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
7170 #endif /* HAVE_LWPSTATUS_T */
7172 #if defined (HAVE_PSTATUS_T)
7174 elfcore_write_pstatus (bfd
*abfd
,
7182 char *note_name
= "CORE";
7184 memset (&pstat
, 0, sizeof (pstat
));
7185 pstat
.pr_pid
= pid
& 0xffff;
7186 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7187 NT_PSTATUS
, &pstat
, sizeof (pstat
));
7190 #endif /* HAVE_PSTATUS_T */
7193 elfcore_write_prfpreg (bfd
*abfd
,
7199 char *note_name
= "CORE";
7200 return elfcore_write_note (abfd
, buf
, bufsiz
,
7201 note_name
, NT_FPREGSET
, fpregs
, size
);
7205 elfcore_write_prxfpreg (bfd
*abfd
,
7208 const void *xfpregs
,
7211 char *note_name
= "LINUX";
7212 return elfcore_write_note (abfd
, buf
, bufsiz
,
7213 note_name
, NT_PRXFPREG
, xfpregs
, size
);
7217 elfcore_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
7225 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
7228 buf
= bfd_malloc (size
);
7232 if (bfd_bread (buf
, size
, abfd
) != size
)
7240 while (p
< buf
+ size
)
7242 /* FIXME: bad alignment assumption. */
7243 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
7244 Elf_Internal_Note in
;
7246 in
.type
= H_GET_32 (abfd
, xnp
->type
);
7248 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
7249 in
.namedata
= xnp
->name
;
7251 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
7252 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
7253 in
.descpos
= offset
+ (in
.descdata
- buf
);
7255 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
7257 if (! elfcore_grok_netbsd_note (abfd
, &in
))
7260 else if (strncmp (in
.namedata
, "QNX", 3) == 0)
7262 if (! elfcore_grok_nto_note (abfd
, &in
))
7267 if (! elfcore_grok_note (abfd
, &in
))
7271 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
7278 /* Providing external access to the ELF program header table. */
7280 /* Return an upper bound on the number of bytes required to store a
7281 copy of ABFD's program header table entries. Return -1 if an error
7282 occurs; bfd_get_error will return an appropriate code. */
7285 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
7287 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7289 bfd_set_error (bfd_error_wrong_format
);
7293 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
7296 /* Copy ABFD's program header table entries to *PHDRS. The entries
7297 will be stored as an array of Elf_Internal_Phdr structures, as
7298 defined in include/elf/internal.h. To find out how large the
7299 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7301 Return the number of program header table entries read, or -1 if an
7302 error occurs; bfd_get_error will return an appropriate code. */
7305 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
7309 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7311 bfd_set_error (bfd_error_wrong_format
);
7315 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
7316 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
7317 num_phdrs
* sizeof (Elf_Internal_Phdr
));
7323 _bfd_elf_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
7326 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7328 i_ehdrp
= elf_elfheader (abfd
);
7329 if (i_ehdrp
== NULL
)
7330 sprintf_vma (buf
, value
);
7333 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7335 #if BFD_HOST_64BIT_LONG
7336 sprintf (buf
, "%016lx", value
);
7338 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
7339 _bfd_int64_low (value
));
7343 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
7346 sprintf_vma (buf
, value
);
7351 _bfd_elf_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
7354 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7356 i_ehdrp
= elf_elfheader (abfd
);
7357 if (i_ehdrp
== NULL
)
7358 fprintf_vma ((FILE *) stream
, value
);
7361 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7363 #if BFD_HOST_64BIT_LONG
7364 fprintf ((FILE *) stream
, "%016lx", value
);
7366 fprintf ((FILE *) stream
, "%08lx%08lx",
7367 _bfd_int64_high (value
), _bfd_int64_low (value
));
7371 fprintf ((FILE *) stream
, "%08lx",
7372 (unsigned long) (value
& 0xffffffff));
7375 fprintf_vma ((FILE *) stream
, value
);
7379 enum elf_reloc_type_class
7380 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
7382 return reloc_class_normal
;
7385 /* For RELA architectures, return the relocation value for a
7386 relocation against a local symbol. */
7389 _bfd_elf_rela_local_sym (bfd
*abfd
,
7390 Elf_Internal_Sym
*sym
,
7392 Elf_Internal_Rela
*rel
)
7396 relocation
= (sec
->output_section
->vma
7397 + sec
->output_offset
7399 if ((sec
->flags
& SEC_MERGE
)
7400 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
7401 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
7407 _bfd_merged_section_offset (abfd
, &msec
,
7408 elf_section_data (sec
)->sec_info
,
7409 sym
->st_value
+ rel
->r_addend
,
7412 rel
->r_addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
7418 _bfd_elf_rel_local_sym (bfd
*abfd
,
7419 Elf_Internal_Sym
*sym
,
7423 asection
*sec
= *psec
;
7425 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
7426 return sym
->st_value
+ addend
;
7428 return _bfd_merged_section_offset (abfd
, psec
,
7429 elf_section_data (sec
)->sec_info
,
7430 sym
->st_value
+ addend
, 0);
7434 _bfd_elf_section_offset (bfd
*abfd
,
7435 struct bfd_link_info
*info
,
7439 struct bfd_elf_section_data
*sec_data
;
7441 sec_data
= elf_section_data (sec
);
7442 switch (sec
->sec_info_type
)
7444 case ELF_INFO_TYPE_STABS
:
7445 return _bfd_stab_section_offset (abfd
,
7446 &elf_hash_table (info
)->merge_info
,
7447 sec
, &sec_data
->sec_info
, offset
);
7448 case ELF_INFO_TYPE_EH_FRAME
:
7449 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);
7455 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
7456 reconstruct an ELF file by reading the segments out of remote memory
7457 based on the ELF file header at EHDR_VMA and the ELF program headers it
7458 points to. If not null, *LOADBASEP is filled in with the difference
7459 between the VMAs from which the segments were read, and the VMAs the
7460 file headers (and hence BFD's idea of each section's VMA) put them at.
7462 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7463 remote memory at target address VMA into the local buffer at MYADDR; it
7464 should return zero on success or an `errno' code on failure. TEMPL must
7465 be a BFD for an ELF target with the word size and byte order found in
7466 the remote memory. */
7469 bfd_elf_bfd_from_remote_memory
7473 int (*target_read_memory
) (bfd_vma
, char *, int))
7475 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
7476 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);