1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 BFD support for ELF formats is being worked on.
27 Currently, the best supported back ends are for sparc and i386
28 (running svr4 or Solaris 2).
30 Documentation of the internals of the support code still needs
31 to be written. The code is changing quickly enough that we
32 haven't bothered yet. */
34 /* For sparc64-cross-sparc32. */
42 #include "libiberty.h"
44 static int elf_sort_sections (const void *, const void *);
45 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
46 static bfd_boolean
prep_headers (bfd
*);
47 static bfd_boolean
swap_out_syms (bfd
*, struct bfd_strtab_hash
**, int) ;
48 static bfd_boolean
elfcore_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
50 /* Swap version information in and out. The version information is
51 currently size independent. If that ever changes, this code will
52 need to move into elfcode.h. */
54 /* Swap in a Verdef structure. */
57 _bfd_elf_swap_verdef_in (bfd
*abfd
,
58 const Elf_External_Verdef
*src
,
59 Elf_Internal_Verdef
*dst
)
61 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
62 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
63 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
64 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
65 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
66 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
67 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
70 /* Swap out a Verdef structure. */
73 _bfd_elf_swap_verdef_out (bfd
*abfd
,
74 const Elf_Internal_Verdef
*src
,
75 Elf_External_Verdef
*dst
)
77 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
78 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
79 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
80 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
81 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
82 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
83 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
86 /* Swap in a Verdaux structure. */
89 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
90 const Elf_External_Verdaux
*src
,
91 Elf_Internal_Verdaux
*dst
)
93 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
94 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
97 /* Swap out a Verdaux structure. */
100 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
101 const Elf_Internal_Verdaux
*src
,
102 Elf_External_Verdaux
*dst
)
104 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
105 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
108 /* Swap in a Verneed structure. */
111 _bfd_elf_swap_verneed_in (bfd
*abfd
,
112 const Elf_External_Verneed
*src
,
113 Elf_Internal_Verneed
*dst
)
115 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
116 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
117 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
118 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
119 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
122 /* Swap out a Verneed structure. */
125 _bfd_elf_swap_verneed_out (bfd
*abfd
,
126 const Elf_Internal_Verneed
*src
,
127 Elf_External_Verneed
*dst
)
129 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
130 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
131 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
132 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
133 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
136 /* Swap in a Vernaux structure. */
139 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
140 const Elf_External_Vernaux
*src
,
141 Elf_Internal_Vernaux
*dst
)
143 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
144 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
145 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
146 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
147 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
150 /* Swap out a Vernaux structure. */
153 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
154 const Elf_Internal_Vernaux
*src
,
155 Elf_External_Vernaux
*dst
)
157 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
158 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
159 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
160 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
161 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
164 /* Swap in a Versym structure. */
167 _bfd_elf_swap_versym_in (bfd
*abfd
,
168 const Elf_External_Versym
*src
,
169 Elf_Internal_Versym
*dst
)
171 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
174 /* Swap out a Versym structure. */
177 _bfd_elf_swap_versym_out (bfd
*abfd
,
178 const Elf_Internal_Versym
*src
,
179 Elf_External_Versym
*dst
)
181 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
184 /* Standard ELF hash function. Do not change this function; you will
185 cause invalid hash tables to be generated. */
188 bfd_elf_hash (const char *namearg
)
190 const unsigned char *name
= (const unsigned char *) namearg
;
195 while ((ch
= *name
++) != '\0')
198 if ((g
= (h
& 0xf0000000)) != 0)
201 /* The ELF ABI says `h &= ~g', but this is equivalent in
202 this case and on some machines one insn instead of two. */
206 return h
& 0xffffffff;
209 /* Read a specified number of bytes at a specified offset in an ELF
210 file, into a newly allocated buffer, and return a pointer to the
214 elf_read (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
218 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
220 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
222 if (bfd_bread (buf
, size
, abfd
) != size
)
224 if (bfd_get_error () != bfd_error_system_call
)
225 bfd_set_error (bfd_error_file_truncated
);
232 bfd_elf_mkobject (bfd
*abfd
)
234 /* This just does initialization. */
235 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
236 elf_tdata (abfd
) = bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
237 if (elf_tdata (abfd
) == 0)
239 /* Since everything is done at close time, do we need any
246 bfd_elf_mkcorefile (bfd
*abfd
)
248 /* I think this can be done just like an object file. */
249 return bfd_elf_mkobject (abfd
);
253 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
255 Elf_Internal_Shdr
**i_shdrp
;
256 char *shstrtab
= NULL
;
258 bfd_size_type shstrtabsize
;
260 i_shdrp
= elf_elfsections (abfd
);
261 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
264 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
265 if (shstrtab
== NULL
)
267 /* No cached one, attempt to read, and cache what we read. */
268 offset
= i_shdrp
[shindex
]->sh_offset
;
269 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
270 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
271 i_shdrp
[shindex
]->contents
= shstrtab
;
277 bfd_elf_string_from_elf_section (bfd
*abfd
,
278 unsigned int shindex
,
279 unsigned int strindex
)
281 Elf_Internal_Shdr
*hdr
;
286 hdr
= elf_elfsections (abfd
)[shindex
];
288 if (hdr
->contents
== NULL
289 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
292 if (strindex
>= hdr
->sh_size
)
294 (*_bfd_error_handler
)
295 (_("%s: invalid string offset %u >= %lu for section `%s'"),
296 bfd_archive_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
297 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
298 && strindex
== hdr
->sh_name
)
300 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
304 return ((char *) hdr
->contents
) + strindex
;
307 /* Read and convert symbols to internal format.
308 SYMCOUNT specifies the number of symbols to read, starting from
309 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
310 are non-NULL, they are used to store the internal symbols, external
311 symbols, and symbol section index extensions, respectively. */
314 bfd_elf_get_elf_syms (bfd
*ibfd
,
315 Elf_Internal_Shdr
*symtab_hdr
,
318 Elf_Internal_Sym
*intsym_buf
,
320 Elf_External_Sym_Shndx
*extshndx_buf
)
322 Elf_Internal_Shdr
*shndx_hdr
;
324 const bfd_byte
*esym
;
325 Elf_External_Sym_Shndx
*alloc_extshndx
;
326 Elf_External_Sym_Shndx
*shndx
;
327 Elf_Internal_Sym
*isym
;
328 Elf_Internal_Sym
*isymend
;
329 const struct elf_backend_data
*bed
;
337 /* Normal syms might have section extension entries. */
339 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
340 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
342 /* Read the symbols. */
344 alloc_extshndx
= NULL
;
345 bed
= get_elf_backend_data (ibfd
);
346 extsym_size
= bed
->s
->sizeof_sym
;
347 amt
= symcount
* extsym_size
;
348 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
349 if (extsym_buf
== NULL
)
351 alloc_ext
= bfd_malloc (amt
);
352 extsym_buf
= alloc_ext
;
354 if (extsym_buf
== NULL
355 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
356 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
362 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
366 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
367 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
368 if (extshndx_buf
== NULL
)
370 alloc_extshndx
= bfd_malloc (amt
);
371 extshndx_buf
= alloc_extshndx
;
373 if (extshndx_buf
== NULL
374 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
375 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
382 if (intsym_buf
== NULL
)
384 bfd_size_type amt
= symcount
* sizeof (Elf_Internal_Sym
);
385 intsym_buf
= bfd_malloc (amt
);
386 if (intsym_buf
== NULL
)
390 /* Convert the symbols to internal form. */
391 isymend
= intsym_buf
+ symcount
;
392 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
394 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
395 (*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
);
398 if (alloc_ext
!= NULL
)
400 if (alloc_extshndx
!= NULL
)
401 free (alloc_extshndx
);
406 /* Look up a symbol name. */
408 bfd_elf_local_sym_name (bfd
*abfd
, Elf_Internal_Sym
*isym
)
410 unsigned int iname
= isym
->st_name
;
411 unsigned int shindex
= elf_tdata (abfd
)->symtab_hdr
.sh_link
;
412 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
414 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
415 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
418 return bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
421 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
422 sections. The first element is the flags, the rest are section
425 typedef union elf_internal_group
{
426 Elf_Internal_Shdr
*shdr
;
428 } Elf_Internal_Group
;
430 /* Return the name of the group signature symbol. Why isn't the
431 signature just a string? */
434 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
436 Elf_Internal_Shdr
*hdr
;
437 unsigned char esym
[sizeof (Elf64_External_Sym
)];
438 Elf_External_Sym_Shndx eshndx
;
439 Elf_Internal_Sym isym
;
441 /* First we need to ensure the symbol table is available. */
442 if (! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
445 /* Go read the symbol. */
446 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
447 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
448 &isym
, esym
, &eshndx
) == NULL
)
451 return bfd_elf_local_sym_name (abfd
, &isym
);
454 /* Set next_in_group list pointer, and group name for NEWSECT. */
457 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
459 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
461 /* If num_group is zero, read in all SHT_GROUP sections. The count
462 is set to -1 if there are no SHT_GROUP sections. */
465 unsigned int i
, shnum
;
467 /* First count the number of groups. If we have a SHT_GROUP
468 section with just a flag word (ie. sh_size is 4), ignore it. */
469 shnum
= elf_numsections (abfd
);
471 for (i
= 0; i
< shnum
; i
++)
473 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
474 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
479 num_group
= (unsigned) -1;
480 elf_tdata (abfd
)->num_group
= num_group
;
484 /* We keep a list of elf section headers for group sections,
485 so we can find them quickly. */
486 bfd_size_type amt
= num_group
* sizeof (Elf_Internal_Shdr
*);
487 elf_tdata (abfd
)->group_sect_ptr
= bfd_alloc (abfd
, amt
);
488 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
492 for (i
= 0; i
< shnum
; i
++)
494 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
495 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
498 Elf_Internal_Group
*dest
;
500 /* Add to list of sections. */
501 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
504 /* Read the raw contents. */
505 BFD_ASSERT (sizeof (*dest
) >= 4);
506 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
507 shdr
->contents
= bfd_alloc (abfd
, amt
);
508 if (shdr
->contents
== NULL
509 || bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
510 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
514 /* Translate raw contents, a flag word followed by an
515 array of elf section indices all in target byte order,
516 to the flag word followed by an array of elf section
518 src
= shdr
->contents
+ shdr
->sh_size
;
519 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
526 idx
= H_GET_32 (abfd
, src
);
527 if (src
== shdr
->contents
)
530 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
531 shdr
->bfd_section
->flags
532 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
537 ((*_bfd_error_handler
)
538 (_("%s: invalid SHT_GROUP entry"),
539 bfd_archive_filename (abfd
)));
542 dest
->shdr
= elf_elfsections (abfd
)[idx
];
549 if (num_group
!= (unsigned) -1)
553 for (i
= 0; i
< num_group
; i
++)
555 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
556 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
557 unsigned int n_elt
= shdr
->sh_size
/ 4;
559 /* Look through this group's sections to see if current
560 section is a member. */
562 if ((++idx
)->shdr
== hdr
)
566 /* We are a member of this group. Go looking through
567 other members to see if any others are linked via
569 idx
= (Elf_Internal_Group
*) shdr
->contents
;
570 n_elt
= shdr
->sh_size
/ 4;
572 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
573 && elf_next_in_group (s
) != NULL
)
577 /* Snarf the group name from other member, and
578 insert current section in circular list. */
579 elf_group_name (newsect
) = elf_group_name (s
);
580 elf_next_in_group (newsect
) = elf_next_in_group (s
);
581 elf_next_in_group (s
) = newsect
;
587 gname
= group_signature (abfd
, shdr
);
590 elf_group_name (newsect
) = gname
;
592 /* Start a circular list with one element. */
593 elf_next_in_group (newsect
) = newsect
;
596 /* If the group section has been created, point to the
598 if (shdr
->bfd_section
!= NULL
)
599 elf_next_in_group (shdr
->bfd_section
) = newsect
;
607 if (elf_group_name (newsect
) == NULL
)
609 (*_bfd_error_handler
) (_("%s: no group info for section %s"),
610 bfd_archive_filename (abfd
), newsect
->name
);
616 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
618 return elf_next_in_group (sec
) != NULL
;
622 bfd_elf_discard_group (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*group
)
624 asection
*first
= elf_next_in_group (group
);
629 s
->output_section
= bfd_abs_section_ptr
;
630 s
= elf_next_in_group (s
);
631 /* These lists are circular. */
638 /* Make a BFD section from an ELF section. We store a pointer to the
639 BFD section in the bfd_section field of the header. */
642 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
643 Elf_Internal_Shdr
*hdr
,
648 const struct elf_backend_data
*bed
;
650 if (hdr
->bfd_section
!= NULL
)
652 BFD_ASSERT (strcmp (name
,
653 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
657 newsect
= bfd_make_section_anyway (abfd
, name
);
661 hdr
->bfd_section
= newsect
;
662 elf_section_data (newsect
)->this_hdr
= *hdr
;
664 /* Always use the real type/flags. */
665 elf_section_type (newsect
) = hdr
->sh_type
;
666 elf_section_flags (newsect
) = hdr
->sh_flags
;
668 newsect
->filepos
= hdr
->sh_offset
;
670 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
671 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
672 || ! bfd_set_section_alignment (abfd
, newsect
,
673 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
676 flags
= SEC_NO_FLAGS
;
677 if (hdr
->sh_type
!= SHT_NOBITS
)
678 flags
|= SEC_HAS_CONTENTS
;
679 if (hdr
->sh_type
== SHT_GROUP
)
680 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
681 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
684 if (hdr
->sh_type
!= SHT_NOBITS
)
687 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
688 flags
|= SEC_READONLY
;
689 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
691 else if ((flags
& SEC_LOAD
) != 0)
693 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
696 newsect
->entsize
= hdr
->sh_entsize
;
697 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
698 flags
|= SEC_STRINGS
;
700 if (hdr
->sh_flags
& SHF_GROUP
)
701 if (!setup_group (abfd
, hdr
, newsect
))
703 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
704 flags
|= SEC_THREAD_LOCAL
;
706 /* The debugging sections appear to be recognized only by name, not
709 static const char *debug_sec_names
[] =
718 for (i
= ARRAY_SIZE (debug_sec_names
); i
--;)
719 if (strncmp (name
, debug_sec_names
[i
], strlen (debug_sec_names
[i
])) == 0)
723 flags
|= SEC_DEBUGGING
;
726 /* As a GNU extension, if the name begins with .gnu.linkonce, we
727 only link a single copy of the section. This is used to support
728 g++. g++ will emit each template expansion in its own section.
729 The symbols will be defined as weak, so that multiple definitions
730 are permitted. The GNU linker extension is to actually discard
731 all but one of the sections. */
732 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
733 && elf_next_in_group (newsect
) == NULL
)
734 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
736 bed
= get_elf_backend_data (abfd
);
737 if (bed
->elf_backend_section_flags
)
738 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
741 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
744 if ((flags
& SEC_ALLOC
) != 0)
746 Elf_Internal_Phdr
*phdr
;
749 /* Look through the phdrs to see if we need to adjust the lma.
750 If all the p_paddr fields are zero, we ignore them, since
751 some ELF linkers produce such output. */
752 phdr
= elf_tdata (abfd
)->phdr
;
753 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
755 if (phdr
->p_paddr
!= 0)
758 if (i
< elf_elfheader (abfd
)->e_phnum
)
760 phdr
= elf_tdata (abfd
)->phdr
;
761 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
763 /* This section is part of this segment if its file
764 offset plus size lies within the segment's memory
765 span and, if the section is loaded, the extent of the
766 loaded data lies within the extent of the segment.
768 Note - we used to check the p_paddr field as well, and
769 refuse to set the LMA if it was 0. This is wrong
770 though, as a perfectly valid initialised segment can
771 have a p_paddr of zero. Some architectures, eg ARM,
772 place special significance on the address 0 and
773 executables need to be able to have a segment which
774 covers this address. */
775 if (phdr
->p_type
== PT_LOAD
776 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
777 && (hdr
->sh_offset
+ hdr
->sh_size
778 <= phdr
->p_offset
+ phdr
->p_memsz
)
779 && ((flags
& SEC_LOAD
) == 0
780 || (hdr
->sh_offset
+ hdr
->sh_size
781 <= phdr
->p_offset
+ phdr
->p_filesz
)))
783 if ((flags
& SEC_LOAD
) == 0)
784 newsect
->lma
= (phdr
->p_paddr
785 + hdr
->sh_addr
- phdr
->p_vaddr
);
787 /* We used to use the same adjustment for SEC_LOAD
788 sections, but that doesn't work if the segment
789 is packed with code from multiple VMAs.
790 Instead we calculate the section LMA based on
791 the segment LMA. It is assumed that the
792 segment will contain sections with contiguous
793 LMAs, even if the VMAs are not. */
794 newsect
->lma
= (phdr
->p_paddr
795 + hdr
->sh_offset
- phdr
->p_offset
);
797 /* With contiguous segments, we can't tell from file
798 offsets whether a section with zero size should
799 be placed at the end of one segment or the
800 beginning of the next. Decide based on vaddr. */
801 if (hdr
->sh_addr
>= phdr
->p_vaddr
802 && (hdr
->sh_addr
+ hdr
->sh_size
803 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
818 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
821 Helper functions for GDB to locate the string tables.
822 Since BFD hides string tables from callers, GDB needs to use an
823 internal hook to find them. Sun's .stabstr, in particular,
824 isn't even pointed to by the .stab section, so ordinary
825 mechanisms wouldn't work to find it, even if we had some.
828 struct elf_internal_shdr
*
829 bfd_elf_find_section (bfd
*abfd
, char *name
)
831 Elf_Internal_Shdr
**i_shdrp
;
836 i_shdrp
= elf_elfsections (abfd
);
839 shstrtab
= bfd_elf_get_str_section (abfd
,
840 elf_elfheader (abfd
)->e_shstrndx
);
841 if (shstrtab
!= NULL
)
843 max
= elf_numsections (abfd
);
844 for (i
= 1; i
< max
; i
++)
845 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
852 const char *const bfd_elf_section_type_names
[] = {
853 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
854 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
855 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
858 /* ELF relocs are against symbols. If we are producing relocatable
859 output, and the reloc is against an external symbol, and nothing
860 has given us any additional addend, the resulting reloc will also
861 be against the same symbol. In such a case, we don't want to
862 change anything about the way the reloc is handled, since it will
863 all be done at final link time. Rather than put special case code
864 into bfd_perform_relocation, all the reloc types use this howto
865 function. It just short circuits the reloc if producing
866 relocatable output against an external symbol. */
868 bfd_reloc_status_type
869 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
870 arelent
*reloc_entry
,
872 void *data ATTRIBUTE_UNUSED
,
873 asection
*input_section
,
875 char **error_message ATTRIBUTE_UNUSED
)
877 if (output_bfd
!= NULL
878 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
879 && (! reloc_entry
->howto
->partial_inplace
880 || reloc_entry
->addend
== 0))
882 reloc_entry
->address
+= input_section
->output_offset
;
886 return bfd_reloc_continue
;
889 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
892 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
895 BFD_ASSERT (sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
896 sec
->sec_info_type
= ELF_INFO_TYPE_NONE
;
899 /* Finish SHF_MERGE section merging. */
902 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
907 if (!is_elf_hash_table (info
->hash
))
910 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
911 if ((ibfd
->flags
& DYNAMIC
) == 0)
912 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
913 if ((sec
->flags
& SEC_MERGE
) != 0
914 && !bfd_is_abs_section (sec
->output_section
))
916 struct bfd_elf_section_data
*secdata
;
918 secdata
= elf_section_data (sec
);
919 if (! _bfd_add_merge_section (abfd
,
920 &elf_hash_table (info
)->merge_info
,
921 sec
, &secdata
->sec_info
))
923 else if (secdata
->sec_info
)
924 sec
->sec_info_type
= ELF_INFO_TYPE_MERGE
;
927 if (elf_hash_table (info
)->merge_info
!= NULL
)
928 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
929 merge_sections_remove_hook
);
934 _bfd_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
936 sec
->output_section
= bfd_abs_section_ptr
;
937 sec
->output_offset
= sec
->vma
;
938 if (!is_elf_hash_table (info
->hash
))
941 sec
->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
944 /* Copy the program header and other data from one object module to
948 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
950 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
951 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
954 BFD_ASSERT (!elf_flags_init (obfd
)
955 || (elf_elfheader (obfd
)->e_flags
956 == elf_elfheader (ibfd
)->e_flags
));
958 elf_gp (obfd
) = elf_gp (ibfd
);
959 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
960 elf_flags_init (obfd
) = TRUE
;
964 /* Print out the program headers. */
967 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
970 Elf_Internal_Phdr
*p
;
972 bfd_byte
*dynbuf
= NULL
;
974 p
= elf_tdata (abfd
)->phdr
;
979 fprintf (f
, _("\nProgram Header:\n"));
980 c
= elf_elfheader (abfd
)->e_phnum
;
981 for (i
= 0; i
< c
; i
++, p
++)
988 case PT_NULL
: pt
= "NULL"; break;
989 case PT_LOAD
: pt
= "LOAD"; break;
990 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
991 case PT_INTERP
: pt
= "INTERP"; break;
992 case PT_NOTE
: pt
= "NOTE"; break;
993 case PT_SHLIB
: pt
= "SHLIB"; break;
994 case PT_PHDR
: pt
= "PHDR"; break;
995 case PT_TLS
: pt
= "TLS"; break;
996 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
997 case PT_GNU_STACK
: pt
= "STACK"; break;
998 case PT_GNU_RELRO
: pt
= "RELRO"; break;
999 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
1001 fprintf (f
, "%8s off 0x", pt
);
1002 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1003 fprintf (f
, " vaddr 0x");
1004 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1005 fprintf (f
, " paddr 0x");
1006 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1007 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1008 fprintf (f
, " filesz 0x");
1009 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1010 fprintf (f
, " memsz 0x");
1011 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1012 fprintf (f
, " flags %c%c%c",
1013 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1014 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1015 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1016 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1017 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1022 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1026 unsigned long shlink
;
1027 bfd_byte
*extdyn
, *extdynend
;
1029 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1031 fprintf (f
, _("\nDynamic Section:\n"));
1033 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1036 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1039 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1041 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1042 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1045 extdynend
= extdyn
+ s
->size
;
1046 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1048 Elf_Internal_Dyn dyn
;
1051 bfd_boolean stringp
;
1053 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1055 if (dyn
.d_tag
== DT_NULL
)
1062 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1066 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1067 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1068 case DT_PLTGOT
: name
= "PLTGOT"; break;
1069 case DT_HASH
: name
= "HASH"; break;
1070 case DT_STRTAB
: name
= "STRTAB"; break;
1071 case DT_SYMTAB
: name
= "SYMTAB"; break;
1072 case DT_RELA
: name
= "RELA"; break;
1073 case DT_RELASZ
: name
= "RELASZ"; break;
1074 case DT_RELAENT
: name
= "RELAENT"; break;
1075 case DT_STRSZ
: name
= "STRSZ"; break;
1076 case DT_SYMENT
: name
= "SYMENT"; break;
1077 case DT_INIT
: name
= "INIT"; break;
1078 case DT_FINI
: name
= "FINI"; break;
1079 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1080 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1081 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1082 case DT_REL
: name
= "REL"; break;
1083 case DT_RELSZ
: name
= "RELSZ"; break;
1084 case DT_RELENT
: name
= "RELENT"; break;
1085 case DT_PLTREL
: name
= "PLTREL"; break;
1086 case DT_DEBUG
: name
= "DEBUG"; break;
1087 case DT_TEXTREL
: name
= "TEXTREL"; break;
1088 case DT_JMPREL
: name
= "JMPREL"; break;
1089 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1090 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1091 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1092 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1093 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1094 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1095 case DT_FLAGS
: name
= "FLAGS"; break;
1096 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1097 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1098 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1099 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1100 case DT_MOVEENT
: name
= "MOVEENT"; break;
1101 case DT_MOVESZ
: name
= "MOVESZ"; break;
1102 case DT_FEATURE
: name
= "FEATURE"; break;
1103 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1104 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1105 case DT_SYMINENT
: name
= "SYMINENT"; break;
1106 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1107 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1108 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1109 case DT_PLTPAD
: name
= "PLTPAD"; break;
1110 case DT_MOVETAB
: name
= "MOVETAB"; break;
1111 case DT_SYMINFO
: name
= "SYMINFO"; break;
1112 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1113 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1114 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1115 case DT_VERSYM
: name
= "VERSYM"; break;
1116 case DT_VERDEF
: name
= "VERDEF"; break;
1117 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1118 case DT_VERNEED
: name
= "VERNEED"; break;
1119 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1120 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1121 case DT_USED
: name
= "USED"; break;
1122 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1125 fprintf (f
, " %-11s ", name
);
1127 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1131 unsigned int tagv
= dyn
.d_un
.d_val
;
1133 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1136 fprintf (f
, "%s", string
);
1145 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1146 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1148 if (! _bfd_elf_slurp_version_tables (abfd
))
1152 if (elf_dynverdef (abfd
) != 0)
1154 Elf_Internal_Verdef
*t
;
1156 fprintf (f
, _("\nVersion definitions:\n"));
1157 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1159 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1160 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1161 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1163 Elf_Internal_Verdaux
*a
;
1166 for (a
= t
->vd_auxptr
->vda_nextptr
;
1169 fprintf (f
, "%s ", a
->vda_nodename
);
1175 if (elf_dynverref (abfd
) != 0)
1177 Elf_Internal_Verneed
*t
;
1179 fprintf (f
, _("\nVersion References:\n"));
1180 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1182 Elf_Internal_Vernaux
*a
;
1184 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1185 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1186 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1187 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1199 /* Display ELF-specific fields of a symbol. */
1202 bfd_elf_print_symbol (bfd
*abfd
,
1205 bfd_print_symbol_type how
)
1210 case bfd_print_symbol_name
:
1211 fprintf (file
, "%s", symbol
->name
);
1213 case bfd_print_symbol_more
:
1214 fprintf (file
, "elf ");
1215 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1216 fprintf (file
, " %lx", (long) symbol
->flags
);
1218 case bfd_print_symbol_all
:
1220 const char *section_name
;
1221 const char *name
= NULL
;
1222 const struct elf_backend_data
*bed
;
1223 unsigned char st_other
;
1226 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1228 bed
= get_elf_backend_data (abfd
);
1229 if (bed
->elf_backend_print_symbol_all
)
1230 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1234 name
= symbol
->name
;
1235 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1238 fprintf (file
, " %s\t", section_name
);
1239 /* Print the "other" value for a symbol. For common symbols,
1240 we've already printed the size; now print the alignment.
1241 For other symbols, we have no specified alignment, and
1242 we've printed the address; now print the size. */
1243 if (bfd_is_com_section (symbol
->section
))
1244 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1246 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1247 bfd_fprintf_vma (abfd
, file
, val
);
1249 /* If we have version information, print it. */
1250 if (elf_tdata (abfd
)->dynversym_section
!= 0
1251 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1252 || elf_tdata (abfd
)->dynverref_section
!= 0))
1254 unsigned int vernum
;
1255 const char *version_string
;
1257 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1260 version_string
= "";
1261 else if (vernum
== 1)
1262 version_string
= "Base";
1263 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1265 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1268 Elf_Internal_Verneed
*t
;
1270 version_string
= "";
1271 for (t
= elf_tdata (abfd
)->verref
;
1275 Elf_Internal_Vernaux
*a
;
1277 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1279 if (a
->vna_other
== vernum
)
1281 version_string
= a
->vna_nodename
;
1288 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1289 fprintf (file
, " %-11s", version_string
);
1294 fprintf (file
, " (%s)", version_string
);
1295 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1300 /* If the st_other field is not zero, print it. */
1301 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1306 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1307 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1308 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1310 /* Some other non-defined flags are also present, so print
1312 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1315 fprintf (file
, " %s", name
);
1321 /* Create an entry in an ELF linker hash table. */
1323 struct bfd_hash_entry
*
1324 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1325 struct bfd_hash_table
*table
,
1328 /* Allocate the structure if it has not already been allocated by a
1332 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1337 /* Call the allocation method of the superclass. */
1338 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1341 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1342 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1344 /* Set local fields. */
1347 ret
->dynstr_index
= 0;
1348 ret
->elf_hash_value
= 0;
1349 ret
->weakdef
= NULL
;
1350 ret
->verinfo
.verdef
= NULL
;
1351 ret
->vtable_entries_size
= 0;
1352 ret
->vtable_entries_used
= NULL
;
1353 ret
->vtable_parent
= NULL
;
1354 ret
->got
= htab
->init_refcount
;
1355 ret
->plt
= htab
->init_refcount
;
1357 ret
->type
= STT_NOTYPE
;
1359 /* Assume that we have been called by a non-ELF symbol reader.
1360 This flag is then reset by the code which reads an ELF input
1361 file. This ensures that a symbol created by a non-ELF symbol
1362 reader will have the flag set correctly. */
1363 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
1369 /* Copy data from an indirect symbol to its direct symbol, hiding the
1370 old indirect symbol. Also used for copying flags to a weakdef. */
1373 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data
*bed
,
1374 struct elf_link_hash_entry
*dir
,
1375 struct elf_link_hash_entry
*ind
)
1378 bfd_signed_vma lowest_valid
= bed
->can_refcount
;
1380 /* Copy down any references that we may have already seen to the
1381 symbol which just became indirect. */
1383 dir
->elf_link_hash_flags
1384 |= ind
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_DYNAMIC
1385 | ELF_LINK_HASH_REF_REGULAR
1386 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1387 | ELF_LINK_NON_GOT_REF
1388 | ELF_LINK_HASH_NEEDS_PLT
1389 | ELF_LINK_POINTER_EQUALITY_NEEDED
);
1391 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1394 /* Copy over the global and procedure linkage table refcount entries.
1395 These may have been already set up by a check_relocs routine. */
1396 tmp
= dir
->got
.refcount
;
1397 if (tmp
< lowest_valid
)
1399 dir
->got
.refcount
= ind
->got
.refcount
;
1400 ind
->got
.refcount
= tmp
;
1403 BFD_ASSERT (ind
->got
.refcount
< lowest_valid
);
1405 tmp
= dir
->plt
.refcount
;
1406 if (tmp
< lowest_valid
)
1408 dir
->plt
.refcount
= ind
->plt
.refcount
;
1409 ind
->plt
.refcount
= tmp
;
1412 BFD_ASSERT (ind
->plt
.refcount
< lowest_valid
);
1414 if (dir
->dynindx
== -1)
1416 dir
->dynindx
= ind
->dynindx
;
1417 dir
->dynstr_index
= ind
->dynstr_index
;
1419 ind
->dynstr_index
= 0;
1422 BFD_ASSERT (ind
->dynindx
== -1);
1426 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
1427 struct elf_link_hash_entry
*h
,
1428 bfd_boolean force_local
)
1430 h
->plt
= elf_hash_table (info
)->init_offset
;
1431 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1434 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
1435 if (h
->dynindx
!= -1)
1438 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1444 /* Initialize an ELF linker hash table. */
1447 _bfd_elf_link_hash_table_init
1448 (struct elf_link_hash_table
*table
,
1450 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
1451 struct bfd_hash_table
*,
1456 table
->dynamic_sections_created
= FALSE
;
1457 table
->dynobj
= NULL
;
1458 /* Make sure can_refcount is extended to the width and signedness of
1459 init_refcount before we subtract one from it. */
1460 table
->init_refcount
.refcount
= get_elf_backend_data (abfd
)->can_refcount
;
1461 table
->init_refcount
.refcount
-= 1;
1462 table
->init_offset
.offset
= -(bfd_vma
) 1;
1463 /* The first dynamic symbol is a dummy. */
1464 table
->dynsymcount
= 1;
1465 table
->dynstr
= NULL
;
1466 table
->bucketcount
= 0;
1467 table
->needed
= NULL
;
1469 table
->merge_info
= NULL
;
1470 memset (&table
->stab_info
, 0, sizeof (table
->stab_info
));
1471 memset (&table
->eh_info
, 0, sizeof (table
->eh_info
));
1472 table
->dynlocal
= NULL
;
1473 table
->runpath
= NULL
;
1474 table
->tls_sec
= NULL
;
1475 table
->tls_size
= 0;
1476 table
->loaded
= NULL
;
1478 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
1479 table
->root
.type
= bfd_link_elf_hash_table
;
1484 /* Create an ELF linker hash table. */
1486 struct bfd_link_hash_table
*
1487 _bfd_elf_link_hash_table_create (bfd
*abfd
)
1489 struct elf_link_hash_table
*ret
;
1490 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1492 ret
= bfd_malloc (amt
);
1496 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1505 /* This is a hook for the ELF emulation code in the generic linker to
1506 tell the backend linker what file name to use for the DT_NEEDED
1507 entry for a dynamic object. */
1510 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
1512 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1513 && bfd_get_format (abfd
) == bfd_object
)
1514 elf_dt_name (abfd
) = name
;
1518 bfd_elf_set_dyn_lib_class (bfd
*abfd
, int lib_class
)
1520 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1521 && bfd_get_format (abfd
) == bfd_object
)
1522 elf_dyn_lib_class (abfd
) = lib_class
;
1525 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1526 the linker ELF emulation code. */
1528 struct bfd_link_needed_list
*
1529 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1530 struct bfd_link_info
*info
)
1532 if (! is_elf_hash_table (info
->hash
))
1534 return elf_hash_table (info
)->needed
;
1537 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1538 hook for the linker ELF emulation code. */
1540 struct bfd_link_needed_list
*
1541 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1542 struct bfd_link_info
*info
)
1544 if (! is_elf_hash_table (info
->hash
))
1546 return elf_hash_table (info
)->runpath
;
1549 /* Get the name actually used for a dynamic object for a link. This
1550 is the SONAME entry if there is one. Otherwise, it is the string
1551 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1554 bfd_elf_get_dt_soname (bfd
*abfd
)
1556 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1557 && bfd_get_format (abfd
) == bfd_object
)
1558 return elf_dt_name (abfd
);
1562 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1563 the ELF linker emulation code. */
1566 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
1567 struct bfd_link_needed_list
**pneeded
)
1570 bfd_byte
*dynbuf
= NULL
;
1572 unsigned long shlink
;
1573 bfd_byte
*extdyn
, *extdynend
;
1575 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1579 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1580 || bfd_get_format (abfd
) != bfd_object
)
1583 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1584 if (s
== NULL
|| s
->size
== 0)
1587 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1590 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1594 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1596 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1597 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1600 extdynend
= extdyn
+ s
->size
;
1601 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1603 Elf_Internal_Dyn dyn
;
1605 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1607 if (dyn
.d_tag
== DT_NULL
)
1610 if (dyn
.d_tag
== DT_NEEDED
)
1613 struct bfd_link_needed_list
*l
;
1614 unsigned int tagv
= dyn
.d_un
.d_val
;
1617 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1622 l
= bfd_alloc (abfd
, amt
);
1643 /* Allocate an ELF string table--force the first byte to be zero. */
1645 struct bfd_strtab_hash
*
1646 _bfd_elf_stringtab_init (void)
1648 struct bfd_strtab_hash
*ret
;
1650 ret
= _bfd_stringtab_init ();
1655 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1656 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1657 if (loc
== (bfd_size_type
) -1)
1659 _bfd_stringtab_free (ret
);
1666 /* ELF .o/exec file reading */
1668 /* Create a new bfd section from an ELF section header. */
1671 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1673 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1674 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1675 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1678 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1680 switch (hdr
->sh_type
)
1683 /* Inactive section. Throw it away. */
1686 case SHT_PROGBITS
: /* Normal section with contents. */
1687 case SHT_NOBITS
: /* .bss section. */
1688 case SHT_HASH
: /* .hash section. */
1689 case SHT_NOTE
: /* .note section. */
1690 case SHT_INIT_ARRAY
: /* .init_array section. */
1691 case SHT_FINI_ARRAY
: /* .fini_array section. */
1692 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1693 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1695 case SHT_DYNAMIC
: /* Dynamic linking information. */
1696 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1698 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1700 Elf_Internal_Shdr
*dynsymhdr
;
1702 /* The shared libraries distributed with hpux11 have a bogus
1703 sh_link field for the ".dynamic" section. Find the
1704 string table for the ".dynsym" section instead. */
1705 if (elf_dynsymtab (abfd
) != 0)
1707 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1708 hdr
->sh_link
= dynsymhdr
->sh_link
;
1712 unsigned int i
, num_sec
;
1714 num_sec
= elf_numsections (abfd
);
1715 for (i
= 1; i
< num_sec
; i
++)
1717 dynsymhdr
= elf_elfsections (abfd
)[i
];
1718 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1720 hdr
->sh_link
= dynsymhdr
->sh_link
;
1728 case SHT_SYMTAB
: /* A symbol table */
1729 if (elf_onesymtab (abfd
) == shindex
)
1732 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1733 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1734 elf_onesymtab (abfd
) = shindex
;
1735 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1736 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1737 abfd
->flags
|= HAS_SYMS
;
1739 /* Sometimes a shared object will map in the symbol table. If
1740 SHF_ALLOC is set, and this is a shared object, then we also
1741 treat this section as a BFD section. We can not base the
1742 decision purely on SHF_ALLOC, because that flag is sometimes
1743 set in a relocatable object file, which would confuse the
1745 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1746 && (abfd
->flags
& DYNAMIC
) != 0
1747 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1752 case SHT_DYNSYM
: /* A dynamic symbol table */
1753 if (elf_dynsymtab (abfd
) == shindex
)
1756 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1757 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1758 elf_dynsymtab (abfd
) = shindex
;
1759 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1760 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1761 abfd
->flags
|= HAS_SYMS
;
1763 /* Besides being a symbol table, we also treat this as a regular
1764 section, so that objcopy can handle it. */
1765 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1767 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1768 if (elf_symtab_shndx (abfd
) == shindex
)
1771 /* Get the associated symbol table. */
1772 if (! bfd_section_from_shdr (abfd
, hdr
->sh_link
)
1773 || hdr
->sh_link
!= elf_onesymtab (abfd
))
1776 elf_symtab_shndx (abfd
) = shindex
;
1777 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1778 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1781 case SHT_STRTAB
: /* A string table */
1782 if (hdr
->bfd_section
!= NULL
)
1784 if (ehdr
->e_shstrndx
== shindex
)
1786 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1787 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1791 unsigned int i
, num_sec
;
1793 num_sec
= elf_numsections (abfd
);
1794 for (i
= 1; i
< num_sec
; i
++)
1796 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1797 if (hdr2
->sh_link
== shindex
)
1799 if (! bfd_section_from_shdr (abfd
, i
))
1801 if (elf_onesymtab (abfd
) == i
)
1803 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1804 elf_elfsections (abfd
)[shindex
] =
1805 &elf_tdata (abfd
)->strtab_hdr
;
1808 if (elf_dynsymtab (abfd
) == i
)
1810 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1811 elf_elfsections (abfd
)[shindex
] = hdr
=
1812 &elf_tdata (abfd
)->dynstrtab_hdr
;
1813 /* We also treat this as a regular section, so
1814 that objcopy can handle it. */
1817 #if 0 /* Not handling other string tables specially right now. */
1818 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1819 /* We have a strtab for some random other section. */
1820 newsect
= (asection
*) hdr2
->bfd_section
;
1823 hdr
->bfd_section
= newsect
;
1824 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1826 elf_elfsections (abfd
)[shindex
] = hdr2
;
1832 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1836 /* *These* do a lot of work -- but build no sections! */
1838 asection
*target_sect
;
1839 Elf_Internal_Shdr
*hdr2
;
1840 unsigned int num_sec
= elf_numsections (abfd
);
1842 /* Check for a bogus link to avoid crashing. */
1843 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1844 || hdr
->sh_link
>= num_sec
)
1846 ((*_bfd_error_handler
)
1847 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1848 bfd_archive_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1849 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1852 /* For some incomprehensible reason Oracle distributes
1853 libraries for Solaris in which some of the objects have
1854 bogus sh_link fields. It would be nice if we could just
1855 reject them, but, unfortunately, some people need to use
1856 them. We scan through the section headers; if we find only
1857 one suitable symbol table, we clobber the sh_link to point
1858 to it. I hope this doesn't break anything. */
1859 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1860 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1866 for (scan
= 1; scan
< num_sec
; scan
++)
1868 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1869 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1880 hdr
->sh_link
= found
;
1883 /* Get the symbol table. */
1884 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1885 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1888 /* If this reloc section does not use the main symbol table we
1889 don't treat it as a reloc section. BFD can't adequately
1890 represent such a section, so at least for now, we don't
1891 try. We just present it as a normal section. We also
1892 can't use it as a reloc section if it points to the null
1894 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
1895 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1897 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1899 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1900 if (target_sect
== NULL
)
1903 if ((target_sect
->flags
& SEC_RELOC
) == 0
1904 || target_sect
->reloc_count
== 0)
1905 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1909 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1910 amt
= sizeof (*hdr2
);
1911 hdr2
= bfd_alloc (abfd
, amt
);
1912 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1915 elf_elfsections (abfd
)[shindex
] = hdr2
;
1916 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1917 target_sect
->flags
|= SEC_RELOC
;
1918 target_sect
->relocation
= NULL
;
1919 target_sect
->rel_filepos
= hdr
->sh_offset
;
1920 /* In the section to which the relocations apply, mark whether
1921 its relocations are of the REL or RELA variety. */
1922 if (hdr
->sh_size
!= 0)
1923 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1924 abfd
->flags
|= HAS_RELOC
;
1929 case SHT_GNU_verdef
:
1930 elf_dynverdef (abfd
) = shindex
;
1931 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1932 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1935 case SHT_GNU_versym
:
1936 elf_dynversym (abfd
) = shindex
;
1937 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1938 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1941 case SHT_GNU_verneed
:
1942 elf_dynverref (abfd
) = shindex
;
1943 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1944 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1951 /* We need a BFD section for objcopy and relocatable linking,
1952 and it's handy to have the signature available as the section
1954 name
= group_signature (abfd
, hdr
);
1957 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1959 if (hdr
->contents
!= NULL
)
1961 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1962 unsigned int n_elt
= hdr
->sh_size
/ 4;
1965 if (idx
->flags
& GRP_COMDAT
)
1966 hdr
->bfd_section
->flags
1967 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1969 /* We try to keep the same section order as it comes in. */
1971 while (--n_elt
!= 0)
1972 if ((s
= (--idx
)->shdr
->bfd_section
) != NULL
1973 && elf_next_in_group (s
) != NULL
)
1975 elf_next_in_group (hdr
->bfd_section
) = s
;
1982 /* Check for any processor-specific section types. */
1984 if (bed
->elf_backend_section_from_shdr
)
1985 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1993 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1994 Return SEC for sections that have no elf section, and NULL on error. */
1997 bfd_section_from_r_symndx (bfd
*abfd
,
1998 struct sym_sec_cache
*cache
,
2000 unsigned long r_symndx
)
2002 Elf_Internal_Shdr
*symtab_hdr
;
2003 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2004 Elf_External_Sym_Shndx eshndx
;
2005 Elf_Internal_Sym isym
;
2006 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2008 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
2009 return cache
->sec
[ent
];
2011 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2012 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2013 &isym
, esym
, &eshndx
) == NULL
)
2016 if (cache
->abfd
!= abfd
)
2018 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2021 cache
->indx
[ent
] = r_symndx
;
2022 cache
->sec
[ent
] = sec
;
2023 if ((isym
.st_shndx
!= SHN_UNDEF
&& isym
.st_shndx
< SHN_LORESERVE
)
2024 || isym
.st_shndx
> SHN_HIRESERVE
)
2027 s
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
2029 cache
->sec
[ent
] = s
;
2031 return cache
->sec
[ent
];
2034 /* Given an ELF section number, retrieve the corresponding BFD
2038 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
2040 if (index
>= elf_numsections (abfd
))
2042 return elf_elfsections (abfd
)[index
]->bfd_section
;
2045 static struct bfd_elf_special_section
const special_sections
[] =
2047 { ".bss", 4, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2048 { ".comment", 8, 0, SHT_PROGBITS
, 0 },
2049 { ".data", 5, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2050 { ".data1", 6, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2051 { ".debug", 6, 0, SHT_PROGBITS
, 0 },
2052 { ".fini", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2053 { ".init", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2054 { ".line", 5, 0, SHT_PROGBITS
, 0 },
2055 { ".rodata", 7, -2, SHT_PROGBITS
, SHF_ALLOC
},
2056 { ".rodata1", 8, 0, SHT_PROGBITS
, SHF_ALLOC
},
2057 { ".tbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2058 { ".tdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2059 { ".text", 5, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2060 { ".init_array", 11, 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2061 { ".fini_array", 11, 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2062 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2063 { ".debug_line", 11, 0, SHT_PROGBITS
, 0 },
2064 { ".debug_info", 11, 0, SHT_PROGBITS
, 0 },
2065 { ".debug_abbrev", 13, 0, SHT_PROGBITS
, 0 },
2066 { ".debug_aranges", 14, 0, SHT_PROGBITS
, 0 },
2067 { ".dynamic", 8, 0, SHT_DYNAMIC
, SHF_ALLOC
},
2068 { ".dynstr", 7, 0, SHT_STRTAB
, SHF_ALLOC
},
2069 { ".dynsym", 7, 0, SHT_DYNSYM
, SHF_ALLOC
},
2070 { ".got", 4, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2071 { ".hash", 5, 0, SHT_HASH
, SHF_ALLOC
},
2072 { ".interp", 7, 0, SHT_PROGBITS
, 0 },
2073 { ".plt", 4, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2074 { ".shstrtab", 9, 0, SHT_STRTAB
, 0 },
2075 { ".strtab", 7, 0, SHT_STRTAB
, 0 },
2076 { ".symtab", 7, 0, SHT_SYMTAB
, 0 },
2077 { ".gnu.version", 12, 0, SHT_GNU_versym
, 0 },
2078 { ".gnu.version_d", 14, 0, SHT_GNU_verdef
, 0 },
2079 { ".gnu.version_r", 14, 0, SHT_GNU_verneed
, 0 },
2080 { ".note.GNU-stack",15, 0, SHT_PROGBITS
, 0 },
2081 { ".note", 5, -1, SHT_NOTE
, 0 },
2082 { ".rela", 5, -1, SHT_RELA
, 0 },
2083 { ".rel", 4, -1, SHT_REL
, 0 },
2084 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2085 { NULL
, 0, 0, 0, 0 }
2088 static const struct bfd_elf_special_section
*
2089 get_special_section (const char *name
,
2090 const struct bfd_elf_special_section
*special_sections
,
2094 int len
= strlen (name
);
2096 for (i
= 0; special_sections
[i
].prefix
!= NULL
; i
++)
2099 int prefix_len
= special_sections
[i
].prefix_length
;
2101 if (len
< prefix_len
)
2103 if (memcmp (name
, special_sections
[i
].prefix
, prefix_len
) != 0)
2106 suffix_len
= special_sections
[i
].suffix_length
;
2107 if (suffix_len
<= 0)
2109 if (name
[prefix_len
] != 0)
2111 if (suffix_len
== 0)
2113 if (name
[prefix_len
] != '.'
2114 && (suffix_len
== -2
2115 || (rela
&& special_sections
[i
].type
== SHT_REL
)))
2121 if (len
< prefix_len
+ suffix_len
)
2123 if (memcmp (name
+ len
- suffix_len
,
2124 special_sections
[i
].prefix
+ prefix_len
,
2128 return &special_sections
[i
];
2134 const struct bfd_elf_special_section
*
2135 _bfd_elf_get_sec_type_attr (bfd
*abfd
, const char *name
)
2137 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2138 const struct bfd_elf_special_section
*ssect
= NULL
;
2140 /* See if this is one of the special sections. */
2143 unsigned int rela
= bed
->default_use_rela_p
;
2145 if (bed
->special_sections
)
2146 ssect
= get_special_section (name
, bed
->special_sections
, rela
);
2149 ssect
= get_special_section (name
, special_sections
, rela
);
2156 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2158 struct bfd_elf_section_data
*sdata
;
2159 const struct bfd_elf_special_section
*ssect
;
2161 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2164 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2167 sec
->used_by_bfd
= sdata
;
2170 elf_section_type (sec
) = SHT_NULL
;
2171 ssect
= _bfd_elf_get_sec_type_attr (abfd
, sec
->name
);
2174 elf_section_type (sec
) = ssect
->type
;
2175 elf_section_flags (sec
) = ssect
->attr
;
2178 /* Indicate whether or not this section should use RELA relocations. */
2179 sec
->use_rela_p
= get_elf_backend_data (abfd
)->default_use_rela_p
;
2184 /* Create a new bfd section from an ELF program header.
2186 Since program segments have no names, we generate a synthetic name
2187 of the form segment<NUM>, where NUM is generally the index in the
2188 program header table. For segments that are split (see below) we
2189 generate the names segment<NUM>a and segment<NUM>b.
2191 Note that some program segments may have a file size that is different than
2192 (less than) the memory size. All this means is that at execution the
2193 system must allocate the amount of memory specified by the memory size,
2194 but only initialize it with the first "file size" bytes read from the
2195 file. This would occur for example, with program segments consisting
2196 of combined data+bss.
2198 To handle the above situation, this routine generates TWO bfd sections
2199 for the single program segment. The first has the length specified by
2200 the file size of the segment, and the second has the length specified
2201 by the difference between the two sizes. In effect, the segment is split
2202 into it's initialized and uninitialized parts.
2207 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2208 Elf_Internal_Phdr
*hdr
,
2210 const char *typename
)
2218 split
= ((hdr
->p_memsz
> 0)
2219 && (hdr
->p_filesz
> 0)
2220 && (hdr
->p_memsz
> hdr
->p_filesz
));
2221 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2222 len
= strlen (namebuf
) + 1;
2223 name
= bfd_alloc (abfd
, len
);
2226 memcpy (name
, namebuf
, len
);
2227 newsect
= bfd_make_section (abfd
, name
);
2228 if (newsect
== NULL
)
2230 newsect
->vma
= hdr
->p_vaddr
;
2231 newsect
->lma
= hdr
->p_paddr
;
2232 newsect
->size
= hdr
->p_filesz
;
2233 newsect
->filepos
= hdr
->p_offset
;
2234 newsect
->flags
|= SEC_HAS_CONTENTS
;
2235 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2236 if (hdr
->p_type
== PT_LOAD
)
2238 newsect
->flags
|= SEC_ALLOC
;
2239 newsect
->flags
|= SEC_LOAD
;
2240 if (hdr
->p_flags
& PF_X
)
2242 /* FIXME: all we known is that it has execute PERMISSION,
2244 newsect
->flags
|= SEC_CODE
;
2247 if (!(hdr
->p_flags
& PF_W
))
2249 newsect
->flags
|= SEC_READONLY
;
2254 sprintf (namebuf
, "%s%db", typename
, index
);
2255 len
= strlen (namebuf
) + 1;
2256 name
= bfd_alloc (abfd
, len
);
2259 memcpy (name
, namebuf
, len
);
2260 newsect
= bfd_make_section (abfd
, name
);
2261 if (newsect
== NULL
)
2263 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2264 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2265 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2266 if (hdr
->p_type
== PT_LOAD
)
2268 newsect
->flags
|= SEC_ALLOC
;
2269 if (hdr
->p_flags
& PF_X
)
2270 newsect
->flags
|= SEC_CODE
;
2272 if (!(hdr
->p_flags
& PF_W
))
2273 newsect
->flags
|= SEC_READONLY
;
2280 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2282 const struct elf_backend_data
*bed
;
2284 switch (hdr
->p_type
)
2287 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2290 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2293 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2296 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2299 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2301 if (! elfcore_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2306 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2309 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2311 case PT_GNU_EH_FRAME
:
2312 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2316 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2319 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2322 /* Check for any processor-specific program segment types.
2323 If no handler for them, default to making "segment" sections. */
2324 bed
= get_elf_backend_data (abfd
);
2325 if (bed
->elf_backend_section_from_phdr
)
2326 return (*bed
->elf_backend_section_from_phdr
) (abfd
, hdr
, index
);
2328 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "segment");
2332 /* Initialize REL_HDR, the section-header for new section, containing
2333 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2334 relocations; otherwise, we use REL relocations. */
2337 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2338 Elf_Internal_Shdr
*rel_hdr
,
2340 bfd_boolean use_rela_p
)
2343 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2344 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2346 name
= bfd_alloc (abfd
, amt
);
2349 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2351 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2353 if (rel_hdr
->sh_name
== (unsigned int) -1)
2355 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2356 rel_hdr
->sh_entsize
= (use_rela_p
2357 ? bed
->s
->sizeof_rela
2358 : bed
->s
->sizeof_rel
);
2359 rel_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
2360 rel_hdr
->sh_flags
= 0;
2361 rel_hdr
->sh_addr
= 0;
2362 rel_hdr
->sh_size
= 0;
2363 rel_hdr
->sh_offset
= 0;
2368 /* Set up an ELF internal section header for a section. */
2371 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2373 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2374 bfd_boolean
*failedptr
= failedptrarg
;
2375 Elf_Internal_Shdr
*this_hdr
;
2379 /* We already failed; just get out of the bfd_map_over_sections
2384 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2386 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2387 asect
->name
, FALSE
);
2388 if (this_hdr
->sh_name
== (unsigned int) -1)
2394 this_hdr
->sh_flags
= 0;
2396 if ((asect
->flags
& SEC_ALLOC
) != 0
2397 || asect
->user_set_vma
)
2398 this_hdr
->sh_addr
= asect
->vma
;
2400 this_hdr
->sh_addr
= 0;
2402 this_hdr
->sh_offset
= 0;
2403 this_hdr
->sh_size
= asect
->size
;
2404 this_hdr
->sh_link
= 0;
2405 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2406 /* The sh_entsize and sh_info fields may have been set already by
2407 copy_private_section_data. */
2409 this_hdr
->bfd_section
= asect
;
2410 this_hdr
->contents
= NULL
;
2412 /* If the section type is unspecified, we set it based on
2414 if (this_hdr
->sh_type
== SHT_NULL
)
2416 if ((asect
->flags
& SEC_GROUP
) != 0)
2418 /* We also need to mark SHF_GROUP here for relocatable
2420 struct bfd_link_order
*l
;
2423 for (l
= asect
->link_order_head
; l
!= NULL
; l
= l
->next
)
2424 if (l
->type
== bfd_indirect_link_order
2425 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2428 /* The name is not important. Anything will do. */
2429 elf_group_name (elt
->output_section
) = "G";
2430 elf_section_flags (elt
->output_section
) |= SHF_GROUP
;
2432 elt
= elf_next_in_group (elt
);
2433 /* During a relocatable link, the lists are
2436 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2438 this_hdr
->sh_type
= SHT_GROUP
;
2440 else if ((asect
->flags
& SEC_ALLOC
) != 0
2441 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2442 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2443 this_hdr
->sh_type
= SHT_NOBITS
;
2445 this_hdr
->sh_type
= SHT_PROGBITS
;
2448 switch (this_hdr
->sh_type
)
2454 case SHT_INIT_ARRAY
:
2455 case SHT_FINI_ARRAY
:
2456 case SHT_PREINIT_ARRAY
:
2463 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2467 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2471 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2475 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2476 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2480 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2481 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2484 case SHT_GNU_versym
:
2485 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2488 case SHT_GNU_verdef
:
2489 this_hdr
->sh_entsize
= 0;
2490 /* objcopy or strip will copy over sh_info, but may not set
2491 cverdefs. The linker will set cverdefs, but sh_info will be
2493 if (this_hdr
->sh_info
== 0)
2494 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2496 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2497 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2500 case SHT_GNU_verneed
:
2501 this_hdr
->sh_entsize
= 0;
2502 /* objcopy or strip will copy over sh_info, but may not set
2503 cverrefs. The linker will set cverrefs, but sh_info will be
2505 if (this_hdr
->sh_info
== 0)
2506 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2508 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2509 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2513 this_hdr
->sh_entsize
= 4;
2517 if ((asect
->flags
& SEC_ALLOC
) != 0)
2518 this_hdr
->sh_flags
|= SHF_ALLOC
;
2519 if ((asect
->flags
& SEC_READONLY
) == 0)
2520 this_hdr
->sh_flags
|= SHF_WRITE
;
2521 if ((asect
->flags
& SEC_CODE
) != 0)
2522 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2523 if ((asect
->flags
& SEC_MERGE
) != 0)
2525 this_hdr
->sh_flags
|= SHF_MERGE
;
2526 this_hdr
->sh_entsize
= asect
->entsize
;
2527 if ((asect
->flags
& SEC_STRINGS
) != 0)
2528 this_hdr
->sh_flags
|= SHF_STRINGS
;
2530 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2531 this_hdr
->sh_flags
|= SHF_GROUP
;
2532 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2534 this_hdr
->sh_flags
|= SHF_TLS
;
2535 if (asect
->size
== 0 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2537 struct bfd_link_order
*o
;
2539 this_hdr
->sh_size
= 0;
2540 for (o
= asect
->link_order_head
; o
!= NULL
; o
= o
->next
)
2541 if (this_hdr
->sh_size
< o
->offset
+ o
->size
)
2542 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2543 if (this_hdr
->sh_size
)
2544 this_hdr
->sh_type
= SHT_NOBITS
;
2548 /* Check for processor-specific section types. */
2549 if (bed
->elf_backend_fake_sections
2550 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2553 /* If the section has relocs, set up a section header for the
2554 SHT_REL[A] section. If two relocation sections are required for
2555 this section, it is up to the processor-specific back-end to
2556 create the other. */
2557 if ((asect
->flags
& SEC_RELOC
) != 0
2558 && !_bfd_elf_init_reloc_shdr (abfd
,
2559 &elf_section_data (asect
)->rel_hdr
,
2565 /* Fill in the contents of a SHT_GROUP section. */
2568 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2570 bfd_boolean
*failedptr
= failedptrarg
;
2571 unsigned long symindx
;
2572 asection
*elt
, *first
;
2574 struct bfd_link_order
*l
;
2577 if (elf_section_data (sec
)->this_hdr
.sh_type
!= SHT_GROUP
2582 if (elf_group_id (sec
) != NULL
)
2583 symindx
= elf_group_id (sec
)->udata
.i
;
2587 /* If called from the assembler, swap_out_syms will have set up
2588 elf_section_syms; If called for "ld -r", use target_index. */
2589 if (elf_section_syms (abfd
) != NULL
)
2590 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2592 symindx
= sec
->target_index
;
2594 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2596 /* The contents won't be allocated for "ld -r" or objcopy. */
2598 if (sec
->contents
== NULL
)
2601 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2603 /* Arrange for the section to be written out. */
2604 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2605 if (sec
->contents
== NULL
)
2612 loc
= sec
->contents
+ sec
->size
;
2614 /* Get the pointer to the first section in the group that gas
2615 squirreled away here. objcopy arranges for this to be set to the
2616 start of the input section group. */
2617 first
= elt
= elf_next_in_group (sec
);
2619 /* First element is a flag word. Rest of section is elf section
2620 indices for all the sections of the group. Write them backwards
2621 just to keep the group in the same order as given in .section
2622 directives, not that it matters. */
2631 s
= s
->output_section
;
2634 idx
= elf_section_data (s
)->this_idx
;
2635 H_PUT_32 (abfd
, idx
, loc
);
2636 elt
= elf_next_in_group (elt
);
2641 /* If this is a relocatable link, then the above did nothing because
2642 SEC is the output section. Look through the input sections
2644 for (l
= sec
->link_order_head
; l
!= NULL
; l
= l
->next
)
2645 if (l
->type
== bfd_indirect_link_order
2646 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2651 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2652 elt
= elf_next_in_group (elt
);
2653 /* During a relocatable link, the lists are circular. */
2655 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2657 /* With ld -r, merging SHT_GROUP sections results in wasted space
2658 due to allowing for the flag word on each input. We may well
2659 duplicate entries too. */
2660 while ((loc
-= 4) > sec
->contents
)
2661 H_PUT_32 (abfd
, 0, loc
);
2663 if (loc
!= sec
->contents
)
2666 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2669 /* Assign all ELF section numbers. The dummy first section is handled here
2670 too. The link/info pointers for the standard section types are filled
2671 in here too, while we're at it. */
2674 assign_section_numbers (bfd
*abfd
)
2676 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2678 unsigned int section_number
, secn
;
2679 Elf_Internal_Shdr
**i_shdrp
;
2684 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2686 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2688 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2690 if (section_number
== SHN_LORESERVE
)
2691 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2692 d
->this_idx
= section_number
++;
2693 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2694 if ((sec
->flags
& SEC_RELOC
) == 0)
2698 if (section_number
== SHN_LORESERVE
)
2699 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2700 d
->rel_idx
= section_number
++;
2701 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2706 if (section_number
== SHN_LORESERVE
)
2707 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2708 d
->rel_idx2
= section_number
++;
2709 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2715 if (section_number
== SHN_LORESERVE
)
2716 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2717 t
->shstrtab_section
= section_number
++;
2718 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2719 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2721 if (bfd_get_symcount (abfd
) > 0)
2723 if (section_number
== SHN_LORESERVE
)
2724 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2725 t
->symtab_section
= section_number
++;
2726 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2727 if (section_number
> SHN_LORESERVE
- 2)
2729 if (section_number
== SHN_LORESERVE
)
2730 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2731 t
->symtab_shndx_section
= section_number
++;
2732 t
->symtab_shndx_hdr
.sh_name
2733 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2734 ".symtab_shndx", FALSE
);
2735 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2738 if (section_number
== SHN_LORESERVE
)
2739 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2740 t
->strtab_section
= section_number
++;
2741 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2744 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2745 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2747 elf_numsections (abfd
) = section_number
;
2748 elf_elfheader (abfd
)->e_shnum
= section_number
;
2749 if (section_number
> SHN_LORESERVE
)
2750 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2752 /* Set up the list of section header pointers, in agreement with the
2754 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2755 i_shdrp
= bfd_zalloc (abfd
, amt
);
2756 if (i_shdrp
== NULL
)
2759 amt
= sizeof (Elf_Internal_Shdr
);
2760 i_shdrp
[0] = bfd_zalloc (abfd
, amt
);
2761 if (i_shdrp
[0] == NULL
)
2763 bfd_release (abfd
, i_shdrp
);
2767 elf_elfsections (abfd
) = i_shdrp
;
2769 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2770 if (bfd_get_symcount (abfd
) > 0)
2772 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2773 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2775 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2776 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2778 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2779 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2781 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2783 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2787 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2788 if (d
->rel_idx
!= 0)
2789 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2790 if (d
->rel_idx2
!= 0)
2791 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2793 /* Fill in the sh_link and sh_info fields while we're at it. */
2795 /* sh_link of a reloc section is the section index of the symbol
2796 table. sh_info is the section index of the section to which
2797 the relocation entries apply. */
2798 if (d
->rel_idx
!= 0)
2800 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2801 d
->rel_hdr
.sh_info
= d
->this_idx
;
2803 if (d
->rel_idx2
!= 0)
2805 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2806 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2809 switch (d
->this_hdr
.sh_type
)
2813 /* A reloc section which we are treating as a normal BFD
2814 section. sh_link is the section index of the symbol
2815 table. sh_info is the section index of the section to
2816 which the relocation entries apply. We assume that an
2817 allocated reloc section uses the dynamic symbol table.
2818 FIXME: How can we be sure? */
2819 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2821 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2823 /* We look up the section the relocs apply to by name. */
2825 if (d
->this_hdr
.sh_type
== SHT_REL
)
2829 s
= bfd_get_section_by_name (abfd
, name
);
2831 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2835 /* We assume that a section named .stab*str is a stabs
2836 string section. We look for a section with the same name
2837 but without the trailing ``str'', and set its sh_link
2838 field to point to this section. */
2839 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
2840 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2845 len
= strlen (sec
->name
);
2846 alc
= bfd_malloc (len
- 2);
2849 memcpy (alc
, sec
->name
, len
- 3);
2850 alc
[len
- 3] = '\0';
2851 s
= bfd_get_section_by_name (abfd
, alc
);
2855 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2857 /* This is a .stab section. */
2858 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
2859 elf_section_data (s
)->this_hdr
.sh_entsize
2860 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2867 case SHT_GNU_verneed
:
2868 case SHT_GNU_verdef
:
2869 /* sh_link is the section header index of the string table
2870 used for the dynamic entries, or the symbol table, or the
2872 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2874 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2878 case SHT_GNU_versym
:
2879 /* sh_link is the section header index of the symbol table
2880 this hash table or version table is for. */
2881 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2883 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2887 d
->this_hdr
.sh_link
= t
->symtab_section
;
2891 for (secn
= 1; secn
< section_number
; ++secn
)
2892 if (i_shdrp
[secn
] == NULL
)
2893 i_shdrp
[secn
] = i_shdrp
[0];
2895 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
2896 i_shdrp
[secn
]->sh_name
);
2900 /* Map symbol from it's internal number to the external number, moving
2901 all local symbols to be at the head of the list. */
2904 sym_is_global (bfd
*abfd
, asymbol
*sym
)
2906 /* If the backend has a special mapping, use it. */
2907 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2908 if (bed
->elf_backend_sym_is_global
)
2909 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
2911 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
2912 || bfd_is_und_section (bfd_get_section (sym
))
2913 || bfd_is_com_section (bfd_get_section (sym
)));
2917 elf_map_symbols (bfd
*abfd
)
2919 unsigned int symcount
= bfd_get_symcount (abfd
);
2920 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2921 asymbol
**sect_syms
;
2922 unsigned int num_locals
= 0;
2923 unsigned int num_globals
= 0;
2924 unsigned int num_locals2
= 0;
2925 unsigned int num_globals2
= 0;
2933 fprintf (stderr
, "elf_map_symbols\n");
2937 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
2939 if (max_index
< asect
->index
)
2940 max_index
= asect
->index
;
2944 amt
= max_index
* sizeof (asymbol
*);
2945 sect_syms
= bfd_zalloc (abfd
, amt
);
2946 if (sect_syms
== NULL
)
2948 elf_section_syms (abfd
) = sect_syms
;
2949 elf_num_section_syms (abfd
) = max_index
;
2951 /* Init sect_syms entries for any section symbols we have already
2952 decided to output. */
2953 for (idx
= 0; idx
< symcount
; idx
++)
2955 asymbol
*sym
= syms
[idx
];
2957 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
2964 if (sec
->owner
!= NULL
)
2966 if (sec
->owner
!= abfd
)
2968 if (sec
->output_offset
!= 0)
2971 sec
= sec
->output_section
;
2973 /* Empty sections in the input files may have had a
2974 section symbol created for them. (See the comment
2975 near the end of _bfd_generic_link_output_symbols in
2976 linker.c). If the linker script discards such
2977 sections then we will reach this point. Since we know
2978 that we cannot avoid this case, we detect it and skip
2979 the abort and the assignment to the sect_syms array.
2980 To reproduce this particular case try running the
2981 linker testsuite test ld-scripts/weak.exp for an ELF
2982 port that uses the generic linker. */
2983 if (sec
->owner
== NULL
)
2986 BFD_ASSERT (sec
->owner
== abfd
);
2988 sect_syms
[sec
->index
] = syms
[idx
];
2993 /* Classify all of the symbols. */
2994 for (idx
= 0; idx
< symcount
; idx
++)
2996 if (!sym_is_global (abfd
, syms
[idx
]))
3002 /* We will be adding a section symbol for each BFD section. Most normal
3003 sections will already have a section symbol in outsymbols, but
3004 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3005 at least in that case. */
3006 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3008 if (sect_syms
[asect
->index
] == NULL
)
3010 if (!sym_is_global (abfd
, asect
->symbol
))
3017 /* Now sort the symbols so the local symbols are first. */
3018 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
3019 new_syms
= bfd_alloc (abfd
, amt
);
3021 if (new_syms
== NULL
)
3024 for (idx
= 0; idx
< symcount
; idx
++)
3026 asymbol
*sym
= syms
[idx
];
3029 if (!sym_is_global (abfd
, sym
))
3032 i
= num_locals
+ num_globals2
++;
3034 sym
->udata
.i
= i
+ 1;
3036 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3038 if (sect_syms
[asect
->index
] == NULL
)
3040 asymbol
*sym
= asect
->symbol
;
3043 sect_syms
[asect
->index
] = sym
;
3044 if (!sym_is_global (abfd
, sym
))
3047 i
= num_locals
+ num_globals2
++;
3049 sym
->udata
.i
= i
+ 1;
3053 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3055 elf_num_locals (abfd
) = num_locals
;
3056 elf_num_globals (abfd
) = num_globals
;
3060 /* Align to the maximum file alignment that could be required for any
3061 ELF data structure. */
3063 static inline file_ptr
3064 align_file_position (file_ptr off
, int align
)
3066 return (off
+ align
- 1) & ~(align
- 1);
3069 /* Assign a file position to a section, optionally aligning to the
3070 required section alignment. */
3073 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3081 al
= i_shdrp
->sh_addralign
;
3083 offset
= BFD_ALIGN (offset
, al
);
3085 i_shdrp
->sh_offset
= offset
;
3086 if (i_shdrp
->bfd_section
!= NULL
)
3087 i_shdrp
->bfd_section
->filepos
= offset
;
3088 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3089 offset
+= i_shdrp
->sh_size
;
3093 /* Compute the file positions we are going to put the sections at, and
3094 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3095 is not NULL, this is being called by the ELF backend linker. */
3098 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3099 struct bfd_link_info
*link_info
)
3101 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3103 struct bfd_strtab_hash
*strtab
;
3104 Elf_Internal_Shdr
*shstrtab_hdr
;
3106 if (abfd
->output_has_begun
)
3109 /* Do any elf backend specific processing first. */
3110 if (bed
->elf_backend_begin_write_processing
)
3111 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3113 if (! prep_headers (abfd
))
3116 /* Post process the headers if necessary. */
3117 if (bed
->elf_backend_post_process_headers
)
3118 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3121 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3125 if (!assign_section_numbers (abfd
))
3128 /* The backend linker builds symbol table information itself. */
3129 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3131 /* Non-zero if doing a relocatable link. */
3132 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3134 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3138 if (link_info
== NULL
)
3140 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3145 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3146 /* sh_name was set in prep_headers. */
3147 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3148 shstrtab_hdr
->sh_flags
= 0;
3149 shstrtab_hdr
->sh_addr
= 0;
3150 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3151 shstrtab_hdr
->sh_entsize
= 0;
3152 shstrtab_hdr
->sh_link
= 0;
3153 shstrtab_hdr
->sh_info
= 0;
3154 /* sh_offset is set in assign_file_positions_except_relocs. */
3155 shstrtab_hdr
->sh_addralign
= 1;
3157 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3160 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3163 Elf_Internal_Shdr
*hdr
;
3165 off
= elf_tdata (abfd
)->next_file_pos
;
3167 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3168 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3170 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3171 if (hdr
->sh_size
!= 0)
3172 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3174 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3175 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3177 elf_tdata (abfd
)->next_file_pos
= off
;
3179 /* Now that we know where the .strtab section goes, write it
3181 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3182 || ! _bfd_stringtab_emit (abfd
, strtab
))
3184 _bfd_stringtab_free (strtab
);
3187 abfd
->output_has_begun
= TRUE
;
3192 /* Create a mapping from a set of sections to a program segment. */
3194 static struct elf_segment_map
*
3195 make_mapping (bfd
*abfd
,
3196 asection
**sections
,
3201 struct elf_segment_map
*m
;
3206 amt
= sizeof (struct elf_segment_map
);
3207 amt
+= (to
- from
- 1) * sizeof (asection
*);
3208 m
= bfd_zalloc (abfd
, amt
);
3212 m
->p_type
= PT_LOAD
;
3213 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3214 m
->sections
[i
- from
] = *hdrpp
;
3215 m
->count
= to
- from
;
3217 if (from
== 0 && phdr
)
3219 /* Include the headers in the first PT_LOAD segment. */
3220 m
->includes_filehdr
= 1;
3221 m
->includes_phdrs
= 1;
3227 /* Set up a mapping from BFD sections to program segments. */
3230 map_sections_to_segments (bfd
*abfd
)
3232 asection
**sections
= NULL
;
3236 struct elf_segment_map
*mfirst
;
3237 struct elf_segment_map
**pm
;
3238 struct elf_segment_map
*m
;
3241 unsigned int phdr_index
;
3242 bfd_vma maxpagesize
;
3244 bfd_boolean phdr_in_segment
= TRUE
;
3245 bfd_boolean writable
;
3247 asection
*first_tls
= NULL
;
3248 asection
*dynsec
, *eh_frame_hdr
;
3251 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3254 if (bfd_count_sections (abfd
) == 0)
3257 /* Select the allocated sections, and sort them. */
3259 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
3260 sections
= bfd_malloc (amt
);
3261 if (sections
== NULL
)
3265 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3267 if ((s
->flags
& SEC_ALLOC
) != 0)
3273 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3276 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3278 /* Build the mapping. */
3283 /* If we have a .interp section, then create a PT_PHDR segment for
3284 the program headers and a PT_INTERP segment for the .interp
3286 s
= bfd_get_section_by_name (abfd
, ".interp");
3287 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3289 amt
= sizeof (struct elf_segment_map
);
3290 m
= bfd_zalloc (abfd
, amt
);
3294 m
->p_type
= PT_PHDR
;
3295 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3296 m
->p_flags
= PF_R
| PF_X
;
3297 m
->p_flags_valid
= 1;
3298 m
->includes_phdrs
= 1;
3303 amt
= sizeof (struct elf_segment_map
);
3304 m
= bfd_zalloc (abfd
, amt
);
3308 m
->p_type
= PT_INTERP
;
3316 /* Look through the sections. We put sections in the same program
3317 segment when the start of the second section can be placed within
3318 a few bytes of the end of the first section. */
3322 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3324 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3326 && (dynsec
->flags
& SEC_LOAD
) == 0)
3329 /* Deal with -Ttext or something similar such that the first section
3330 is not adjacent to the program headers. This is an
3331 approximation, since at this point we don't know exactly how many
3332 program headers we will need. */
3335 bfd_size_type phdr_size
;
3337 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3339 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3340 if ((abfd
->flags
& D_PAGED
) == 0
3341 || sections
[0]->lma
< phdr_size
3342 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3343 phdr_in_segment
= FALSE
;
3346 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3349 bfd_boolean new_segment
;
3353 /* See if this section and the last one will fit in the same
3356 if (last_hdr
== NULL
)
3358 /* If we don't have a segment yet, then we don't need a new
3359 one (we build the last one after this loop). */
3360 new_segment
= FALSE
;
3362 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3364 /* If this section has a different relation between the
3365 virtual address and the load address, then we need a new
3369 else if (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
3370 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3372 /* If putting this section in this segment would force us to
3373 skip a page in the segment, then we need a new segment. */
3376 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3377 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3379 /* We don't want to put a loadable section after a
3380 nonloadable section in the same segment.
3381 Consider .tbss sections as loadable for this purpose. */
3384 else if ((abfd
->flags
& D_PAGED
) == 0)
3386 /* If the file is not demand paged, which means that we
3387 don't require the sections to be correctly aligned in the
3388 file, then there is no other reason for a new segment. */
3389 new_segment
= FALSE
;
3392 && (hdr
->flags
& SEC_READONLY
) == 0
3393 && (((last_hdr
->lma
+ last_size
- 1)
3394 & ~(maxpagesize
- 1))
3395 != (hdr
->lma
& ~(maxpagesize
- 1))))
3397 /* We don't want to put a writable section in a read only
3398 segment, unless they are on the same page in memory
3399 anyhow. We already know that the last section does not
3400 bring us past the current section on the page, so the
3401 only case in which the new section is not on the same
3402 page as the previous section is when the previous section
3403 ends precisely on a page boundary. */
3408 /* Otherwise, we can use the same segment. */
3409 new_segment
= FALSE
;
3414 if ((hdr
->flags
& SEC_READONLY
) == 0)
3417 /* .tbss sections effectively have zero size. */
3418 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3419 last_size
= hdr
->size
;
3425 /* We need a new program segment. We must create a new program
3426 header holding all the sections from phdr_index until hdr. */
3428 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3435 if ((hdr
->flags
& SEC_READONLY
) == 0)
3441 /* .tbss sections effectively have zero size. */
3442 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3443 last_size
= hdr
->size
;
3447 phdr_in_segment
= FALSE
;
3450 /* Create a final PT_LOAD program segment. */
3451 if (last_hdr
!= NULL
)
3453 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3461 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3464 amt
= sizeof (struct elf_segment_map
);
3465 m
= bfd_zalloc (abfd
, amt
);
3469 m
->p_type
= PT_DYNAMIC
;
3471 m
->sections
[0] = dynsec
;
3477 /* For each loadable .note section, add a PT_NOTE segment. We don't
3478 use bfd_get_section_by_name, because if we link together
3479 nonloadable .note sections and loadable .note sections, we will
3480 generate two .note sections in the output file. FIXME: Using
3481 names for section types is bogus anyhow. */
3482 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3484 if ((s
->flags
& SEC_LOAD
) != 0
3485 && strncmp (s
->name
, ".note", 5) == 0)
3487 amt
= sizeof (struct elf_segment_map
);
3488 m
= bfd_zalloc (abfd
, amt
);
3492 m
->p_type
= PT_NOTE
;
3499 if (s
->flags
& SEC_THREAD_LOCAL
)
3507 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3512 amt
= sizeof (struct elf_segment_map
);
3513 amt
+= (tls_count
- 1) * sizeof (asection
*);
3514 m
= bfd_zalloc (abfd
, amt
);
3519 m
->count
= tls_count
;
3520 /* Mandated PF_R. */
3522 m
->p_flags_valid
= 1;
3523 for (i
= 0; i
< tls_count
; ++i
)
3525 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3526 m
->sections
[i
] = first_tls
;
3527 first_tls
= first_tls
->next
;
3534 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3536 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3537 if (eh_frame_hdr
!= NULL
3538 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3540 amt
= sizeof (struct elf_segment_map
);
3541 m
= bfd_zalloc (abfd
, amt
);
3545 m
->p_type
= PT_GNU_EH_FRAME
;
3547 m
->sections
[0] = eh_frame_hdr
->output_section
;
3553 if (elf_tdata (abfd
)->stack_flags
)
3555 amt
= sizeof (struct elf_segment_map
);
3556 m
= bfd_zalloc (abfd
, amt
);
3560 m
->p_type
= PT_GNU_STACK
;
3561 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3562 m
->p_flags_valid
= 1;
3568 if (elf_tdata (abfd
)->relro
)
3570 amt
= sizeof (struct elf_segment_map
);
3571 m
= bfd_zalloc (abfd
, amt
);
3575 m
->p_type
= PT_GNU_RELRO
;
3577 m
->p_flags_valid
= 1;
3586 elf_tdata (abfd
)->segment_map
= mfirst
;
3590 if (sections
!= NULL
)
3595 /* Sort sections by address. */
3598 elf_sort_sections (const void *arg1
, const void *arg2
)
3600 const asection
*sec1
= *(const asection
**) arg1
;
3601 const asection
*sec2
= *(const asection
**) arg2
;
3602 bfd_size_type size1
, size2
;
3604 /* Sort by LMA first, since this is the address used to
3605 place the section into a segment. */
3606 if (sec1
->lma
< sec2
->lma
)
3608 else if (sec1
->lma
> sec2
->lma
)
3611 /* Then sort by VMA. Normally the LMA and the VMA will be
3612 the same, and this will do nothing. */
3613 if (sec1
->vma
< sec2
->vma
)
3615 else if (sec1
->vma
> sec2
->vma
)
3618 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3620 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3626 /* If the indicies are the same, do not return 0
3627 here, but continue to try the next comparison. */
3628 if (sec1
->target_index
- sec2
->target_index
!= 0)
3629 return sec1
->target_index
- sec2
->target_index
;
3634 else if (TOEND (sec2
))
3639 /* Sort by size, to put zero sized sections
3640 before others at the same address. */
3642 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
3643 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
3650 return sec1
->target_index
- sec2
->target_index
;
3653 /* Ian Lance Taylor writes:
3655 We shouldn't be using % with a negative signed number. That's just
3656 not good. We have to make sure either that the number is not
3657 negative, or that the number has an unsigned type. When the types
3658 are all the same size they wind up as unsigned. When file_ptr is a
3659 larger signed type, the arithmetic winds up as signed long long,
3662 What we're trying to say here is something like ``increase OFF by
3663 the least amount that will cause it to be equal to the VMA modulo
3665 /* In other words, something like:
3667 vma_offset = m->sections[0]->vma % bed->maxpagesize;
3668 off_offset = off % bed->maxpagesize;
3669 if (vma_offset < off_offset)
3670 adjustment = vma_offset + bed->maxpagesize - off_offset;
3672 adjustment = vma_offset - off_offset;
3674 which can can be collapsed into the expression below. */
3677 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
3679 return ((vma
- off
) % maxpagesize
);
3682 /* Assign file positions to the sections based on the mapping from
3683 sections to segments. This function also sets up some fields in
3684 the file header, and writes out the program headers. */
3687 assign_file_positions_for_segments (bfd
*abfd
, struct bfd_link_info
*link_info
)
3689 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3691 struct elf_segment_map
*m
;
3693 Elf_Internal_Phdr
*phdrs
;
3695 bfd_vma filehdr_vaddr
, filehdr_paddr
;
3696 bfd_vma phdrs_vaddr
, phdrs_paddr
;
3697 Elf_Internal_Phdr
*p
;
3700 if (elf_tdata (abfd
)->segment_map
== NULL
)
3702 if (! map_sections_to_segments (abfd
))
3707 /* The placement algorithm assumes that non allocated sections are
3708 not in PT_LOAD segments. We ensure this here by removing such
3709 sections from the segment map. */
3710 for (m
= elf_tdata (abfd
)->segment_map
;
3714 unsigned int new_count
;
3717 if (m
->p_type
!= PT_LOAD
)
3721 for (i
= 0; i
< m
->count
; i
++)
3723 if ((m
->sections
[i
]->flags
& SEC_ALLOC
) != 0)
3726 m
->sections
[new_count
] = m
->sections
[i
];
3732 if (new_count
!= m
->count
)
3733 m
->count
= new_count
;
3737 if (bed
->elf_backend_modify_segment_map
)
3739 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
, link_info
))
3744 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3747 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
3748 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
3749 elf_elfheader (abfd
)->e_phnum
= count
;
3754 /* If we already counted the number of program segments, make sure
3755 that we allocated enough space. This happens when SIZEOF_HEADERS
3756 is used in a linker script. */
3757 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
3758 if (alloc
!= 0 && count
> alloc
)
3760 ((*_bfd_error_handler
)
3761 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3762 bfd_get_filename (abfd
), alloc
, count
));
3763 bfd_set_error (bfd_error_bad_value
);
3770 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
3771 phdrs
= bfd_alloc (abfd
, amt
);
3775 off
= bed
->s
->sizeof_ehdr
;
3776 off
+= alloc
* bed
->s
->sizeof_phdr
;
3783 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
3790 /* If elf_segment_map is not from map_sections_to_segments, the
3791 sections may not be correctly ordered. NOTE: sorting should
3792 not be done to the PT_NOTE section of a corefile, which may
3793 contain several pseudo-sections artificially created by bfd.
3794 Sorting these pseudo-sections breaks things badly. */
3796 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
3797 && m
->p_type
== PT_NOTE
))
3798 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
3801 p
->p_type
= m
->p_type
;
3802 p
->p_flags
= m
->p_flags
;
3804 if (p
->p_type
== PT_LOAD
3806 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
3808 if ((abfd
->flags
& D_PAGED
) != 0)
3809 off
+= vma_page_aligned_bias (m
->sections
[0]->vma
, off
,
3813 bfd_size_type align
;
3816 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3818 bfd_size_type secalign
;
3820 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
3821 if (secalign
> align
)
3825 off
+= vma_page_aligned_bias (m
->sections
[0]->vma
, off
,
3833 p
->p_vaddr
= m
->sections
[0]->vma
;
3835 if (m
->p_paddr_valid
)
3836 p
->p_paddr
= m
->p_paddr
;
3837 else if (m
->count
== 0)
3840 p
->p_paddr
= m
->sections
[0]->lma
;
3842 if (p
->p_type
== PT_LOAD
3843 && (abfd
->flags
& D_PAGED
) != 0)
3844 p
->p_align
= bed
->maxpagesize
;
3845 else if (m
->count
== 0)
3846 p
->p_align
= 1 << bed
->s
->log_file_align
;
3854 if (m
->includes_filehdr
)
3856 if (! m
->p_flags_valid
)
3859 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3860 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3863 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3865 if (p
->p_vaddr
< (bfd_vma
) off
)
3867 (*_bfd_error_handler
)
3868 (_("%s: Not enough room for program headers, try linking with -N"),
3869 bfd_get_filename (abfd
));
3870 bfd_set_error (bfd_error_bad_value
);
3875 if (! m
->p_paddr_valid
)
3878 if (p
->p_type
== PT_LOAD
)
3880 filehdr_vaddr
= p
->p_vaddr
;
3881 filehdr_paddr
= p
->p_paddr
;
3885 if (m
->includes_phdrs
)
3887 if (! m
->p_flags_valid
)
3890 if (m
->includes_filehdr
)
3892 if (p
->p_type
== PT_LOAD
)
3894 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3895 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3900 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3904 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3905 p
->p_vaddr
-= off
- p
->p_offset
;
3906 if (! m
->p_paddr_valid
)
3907 p
->p_paddr
-= off
- p
->p_offset
;
3910 if (p
->p_type
== PT_LOAD
)
3912 phdrs_vaddr
= p
->p_vaddr
;
3913 phdrs_paddr
= p
->p_paddr
;
3916 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3919 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3920 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3923 if (p
->p_type
== PT_LOAD
3924 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3926 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3932 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3933 p
->p_filesz
+= adjust
;
3934 p
->p_memsz
+= adjust
;
3940 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3944 bfd_size_type align
;
3948 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3950 /* The section may have artificial alignment forced by a
3951 link script. Notice this case by the gap between the
3952 cumulative phdr lma and the section's lma. */
3953 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3955 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3957 p
->p_memsz
+= adjust
;
3958 if (p
->p_type
== PT_LOAD
3959 || (p
->p_type
== PT_NOTE
3960 && bfd_get_format (abfd
) == bfd_core
))
3965 if ((flags
& SEC_LOAD
) != 0
3966 || (flags
& SEC_THREAD_LOCAL
) != 0)
3967 p
->p_filesz
+= adjust
;
3970 if (p
->p_type
== PT_LOAD
)
3972 bfd_signed_vma adjust
;
3974 if ((flags
& SEC_LOAD
) != 0)
3976 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3980 else if ((flags
& SEC_ALLOC
) != 0)
3982 /* The section VMA must equal the file position
3983 modulo the page size. FIXME: I'm not sure if
3984 this adjustment is really necessary. We used to
3985 not have the SEC_LOAD case just above, and then
3986 this was necessary, but now I'm not sure. */
3987 if ((abfd
->flags
& D_PAGED
) != 0)
3988 adjust
= vma_page_aligned_bias (sec
->vma
, voff
,
3991 adjust
= vma_page_aligned_bias (sec
->vma
, voff
,
4001 (* _bfd_error_handler
) (_("\
4002 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
4003 bfd_section_name (abfd
, sec
),
4008 p
->p_memsz
+= adjust
;
4011 if ((flags
& SEC_LOAD
) != 0)
4012 p
->p_filesz
+= adjust
;
4017 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
4018 used in a linker script we may have a section with
4019 SEC_LOAD clear but which is supposed to have
4021 if ((flags
& SEC_LOAD
) != 0
4022 || (flags
& SEC_HAS_CONTENTS
) != 0)
4025 if ((flags
& SEC_ALLOC
) != 0
4026 && ((flags
& SEC_LOAD
) != 0
4027 || (flags
& SEC_THREAD_LOCAL
) == 0))
4031 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4033 /* The actual "note" segment has i == 0.
4034 This is the one that actually contains everything. */
4038 p
->p_filesz
= sec
->size
;
4044 /* Fake sections -- don't need to be written. */
4047 flags
= sec
->flags
= 0;
4054 if ((sec
->flags
& SEC_LOAD
) != 0
4055 || (sec
->flags
& SEC_THREAD_LOCAL
) == 0
4056 || p
->p_type
== PT_TLS
)
4057 p
->p_memsz
+= sec
->size
;
4059 if ((flags
& SEC_LOAD
) != 0)
4060 p
->p_filesz
+= sec
->size
;
4062 if (p
->p_type
== PT_TLS
4064 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
4066 struct bfd_link_order
*o
;
4067 bfd_vma tbss_size
= 0;
4069 for (o
= sec
->link_order_head
; o
!= NULL
; o
= o
->next
)
4070 if (tbss_size
< o
->offset
+ o
->size
)
4071 tbss_size
= o
->offset
+ o
->size
;
4073 p
->p_memsz
+= tbss_size
;
4076 if (align
> p
->p_align
4077 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
4081 if (! m
->p_flags_valid
)
4084 if ((flags
& SEC_CODE
) != 0)
4086 if ((flags
& SEC_READONLY
) == 0)
4092 /* Now that we have set the section file positions, we can set up
4093 the file positions for the non PT_LOAD segments. */
4094 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4098 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
4100 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
4101 p
->p_offset
= m
->sections
[0]->filepos
;
4105 if (m
->includes_filehdr
)
4107 p
->p_vaddr
= filehdr_vaddr
;
4108 if (! m
->p_paddr_valid
)
4109 p
->p_paddr
= filehdr_paddr
;
4111 else if (m
->includes_phdrs
)
4113 p
->p_vaddr
= phdrs_vaddr
;
4114 if (! m
->p_paddr_valid
)
4115 p
->p_paddr
= phdrs_paddr
;
4117 else if (p
->p_type
== PT_GNU_RELRO
)
4119 Elf_Internal_Phdr
*lp
;
4121 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4123 if (lp
->p_type
== PT_LOAD
4124 && lp
->p_vaddr
<= link_info
->relro_end
4125 && lp
->p_vaddr
>= link_info
->relro_start
4126 && lp
->p_vaddr
+ lp
->p_filesz
4127 >= link_info
->relro_end
)
4131 if (lp
< phdrs
+ count
4132 && link_info
->relro_end
> lp
->p_vaddr
)
4134 p
->p_vaddr
= lp
->p_vaddr
;
4135 p
->p_paddr
= lp
->p_paddr
;
4136 p
->p_offset
= lp
->p_offset
;
4137 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4138 p
->p_memsz
= p
->p_filesz
;
4140 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4144 memset (p
, 0, sizeof *p
);
4145 p
->p_type
= PT_NULL
;
4151 /* Clear out any program headers we allocated but did not use. */
4152 for (; count
< alloc
; count
++, p
++)
4154 memset (p
, 0, sizeof *p
);
4155 p
->p_type
= PT_NULL
;
4158 elf_tdata (abfd
)->phdr
= phdrs
;
4160 elf_tdata (abfd
)->next_file_pos
= off
;
4162 /* Write out the program headers. */
4163 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4164 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
4170 /* Get the size of the program header.
4172 If this is called by the linker before any of the section VMA's are set, it
4173 can't calculate the correct value for a strange memory layout. This only
4174 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4175 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4176 data segment (exclusive of .interp and .dynamic).
4178 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4179 will be two segments. */
4181 static bfd_size_type
4182 get_program_header_size (bfd
*abfd
)
4186 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4188 /* We can't return a different result each time we're called. */
4189 if (elf_tdata (abfd
)->program_header_size
!= 0)
4190 return elf_tdata (abfd
)->program_header_size
;
4192 if (elf_tdata (abfd
)->segment_map
!= NULL
)
4194 struct elf_segment_map
*m
;
4197 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4199 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4200 return elf_tdata (abfd
)->program_header_size
;
4203 /* Assume we will need exactly two PT_LOAD segments: one for text
4204 and one for data. */
4207 s
= bfd_get_section_by_name (abfd
, ".interp");
4208 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4210 /* If we have a loadable interpreter section, we need a
4211 PT_INTERP segment. In this case, assume we also need a
4212 PT_PHDR segment, although that may not be true for all
4217 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4219 /* We need a PT_DYNAMIC segment. */
4223 if (elf_tdata (abfd
)->eh_frame_hdr
)
4225 /* We need a PT_GNU_EH_FRAME segment. */
4229 if (elf_tdata (abfd
)->stack_flags
)
4231 /* We need a PT_GNU_STACK segment. */
4235 if (elf_tdata (abfd
)->relro
)
4237 /* We need a PT_GNU_RELRO segment. */
4241 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4243 if ((s
->flags
& SEC_LOAD
) != 0
4244 && strncmp (s
->name
, ".note", 5) == 0)
4246 /* We need a PT_NOTE segment. */
4251 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4253 if (s
->flags
& SEC_THREAD_LOCAL
)
4255 /* We need a PT_TLS segment. */
4261 /* Let the backend count up any program headers it might need. */
4262 if (bed
->elf_backend_additional_program_headers
)
4266 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
4272 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4273 return elf_tdata (abfd
)->program_header_size
;
4276 /* Work out the file positions of all the sections. This is called by
4277 _bfd_elf_compute_section_file_positions. All the section sizes and
4278 VMAs must be known before this is called.
4280 We do not consider reloc sections at this point, unless they form
4281 part of the loadable image. Reloc sections are assigned file
4282 positions in assign_file_positions_for_relocs, which is called by
4283 write_object_contents and final_link.
4285 We also don't set the positions of the .symtab and .strtab here. */
4288 assign_file_positions_except_relocs (bfd
*abfd
,
4289 struct bfd_link_info
*link_info
)
4291 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
4292 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
4293 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4294 unsigned int num_sec
= elf_numsections (abfd
);
4296 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4298 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4299 && bfd_get_format (abfd
) != bfd_core
)
4301 Elf_Internal_Shdr
**hdrpp
;
4304 /* Start after the ELF header. */
4305 off
= i_ehdrp
->e_ehsize
;
4307 /* We are not creating an executable, which means that we are
4308 not creating a program header, and that the actual order of
4309 the sections in the file is unimportant. */
4310 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4312 Elf_Internal_Shdr
*hdr
;
4315 if (hdr
->sh_type
== SHT_REL
4316 || hdr
->sh_type
== SHT_RELA
4317 || i
== tdata
->symtab_section
4318 || i
== tdata
->symtab_shndx_section
4319 || i
== tdata
->strtab_section
)
4321 hdr
->sh_offset
= -1;
4324 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4326 if (i
== SHN_LORESERVE
- 1)
4328 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4329 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4336 Elf_Internal_Shdr
**hdrpp
;
4338 /* Assign file positions for the loaded sections based on the
4339 assignment of sections to segments. */
4340 if (! assign_file_positions_for_segments (abfd
, link_info
))
4343 /* Assign file positions for the other sections. */
4345 off
= elf_tdata (abfd
)->next_file_pos
;
4346 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4348 Elf_Internal_Shdr
*hdr
;
4351 if (hdr
->bfd_section
!= NULL
4352 && hdr
->bfd_section
->filepos
!= 0)
4353 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
4354 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4356 ((*_bfd_error_handler
)
4357 (_("%s: warning: allocated section `%s' not in segment"),
4358 bfd_get_filename (abfd
),
4359 (hdr
->bfd_section
== NULL
4361 : hdr
->bfd_section
->name
)));
4362 if ((abfd
->flags
& D_PAGED
) != 0)
4363 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4366 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4368 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4371 else if (hdr
->sh_type
== SHT_REL
4372 || hdr
->sh_type
== SHT_RELA
4373 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4374 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4375 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4376 hdr
->sh_offset
= -1;
4378 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4380 if (i
== SHN_LORESERVE
- 1)
4382 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4383 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4388 /* Place the section headers. */
4389 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4390 i_ehdrp
->e_shoff
= off
;
4391 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4393 elf_tdata (abfd
)->next_file_pos
= off
;
4399 prep_headers (bfd
*abfd
)
4401 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4402 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4403 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4404 struct elf_strtab_hash
*shstrtab
;
4405 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4407 i_ehdrp
= elf_elfheader (abfd
);
4408 i_shdrp
= elf_elfsections (abfd
);
4410 shstrtab
= _bfd_elf_strtab_init ();
4411 if (shstrtab
== NULL
)
4414 elf_shstrtab (abfd
) = shstrtab
;
4416 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4417 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4418 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4419 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4421 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4422 i_ehdrp
->e_ident
[EI_DATA
] =
4423 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4424 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4426 if ((abfd
->flags
& DYNAMIC
) != 0)
4427 i_ehdrp
->e_type
= ET_DYN
;
4428 else if ((abfd
->flags
& EXEC_P
) != 0)
4429 i_ehdrp
->e_type
= ET_EXEC
;
4430 else if (bfd_get_format (abfd
) == bfd_core
)
4431 i_ehdrp
->e_type
= ET_CORE
;
4433 i_ehdrp
->e_type
= ET_REL
;
4435 switch (bfd_get_arch (abfd
))
4437 case bfd_arch_unknown
:
4438 i_ehdrp
->e_machine
= EM_NONE
;
4441 /* There used to be a long list of cases here, each one setting
4442 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4443 in the corresponding bfd definition. To avoid duplication,
4444 the switch was removed. Machines that need special handling
4445 can generally do it in elf_backend_final_write_processing(),
4446 unless they need the information earlier than the final write.
4447 Such need can generally be supplied by replacing the tests for
4448 e_machine with the conditions used to determine it. */
4450 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4453 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4454 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4456 /* No program header, for now. */
4457 i_ehdrp
->e_phoff
= 0;
4458 i_ehdrp
->e_phentsize
= 0;
4459 i_ehdrp
->e_phnum
= 0;
4461 /* Each bfd section is section header entry. */
4462 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4463 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4465 /* If we're building an executable, we'll need a program header table. */
4466 if (abfd
->flags
& EXEC_P
)
4468 /* It all happens later. */
4470 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
4472 /* elf_build_phdrs() returns a (NULL-terminated) array of
4473 Elf_Internal_Phdrs. */
4474 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
4475 i_ehdrp
->e_phoff
= outbase
;
4476 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
4481 i_ehdrp
->e_phentsize
= 0;
4483 i_ehdrp
->e_phoff
= 0;
4486 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4487 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4488 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4489 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4490 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4491 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4492 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4493 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4494 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4500 /* Assign file positions for all the reloc sections which are not part
4501 of the loadable file image. */
4504 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4507 unsigned int i
, num_sec
;
4508 Elf_Internal_Shdr
**shdrpp
;
4510 off
= elf_tdata (abfd
)->next_file_pos
;
4512 num_sec
= elf_numsections (abfd
);
4513 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4515 Elf_Internal_Shdr
*shdrp
;
4518 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4519 && shdrp
->sh_offset
== -1)
4520 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4523 elf_tdata (abfd
)->next_file_pos
= off
;
4527 _bfd_elf_write_object_contents (bfd
*abfd
)
4529 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4530 Elf_Internal_Ehdr
*i_ehdrp
;
4531 Elf_Internal_Shdr
**i_shdrp
;
4533 unsigned int count
, num_sec
;
4535 if (! abfd
->output_has_begun
4536 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4539 i_shdrp
= elf_elfsections (abfd
);
4540 i_ehdrp
= elf_elfheader (abfd
);
4543 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4547 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4549 /* After writing the headers, we need to write the sections too... */
4550 num_sec
= elf_numsections (abfd
);
4551 for (count
= 1; count
< num_sec
; count
++)
4553 if (bed
->elf_backend_section_processing
)
4554 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4555 if (i_shdrp
[count
]->contents
)
4557 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4559 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4560 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4563 if (count
== SHN_LORESERVE
- 1)
4564 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4567 /* Write out the section header names. */
4568 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4569 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4572 if (bed
->elf_backend_final_write_processing
)
4573 (*bed
->elf_backend_final_write_processing
) (abfd
,
4574 elf_tdata (abfd
)->linker
);
4576 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4580 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4582 /* Hopefully this can be done just like an object file. */
4583 return _bfd_elf_write_object_contents (abfd
);
4586 /* Given a section, search the header to find them. */
4589 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4591 const struct elf_backend_data
*bed
;
4594 if (elf_section_data (asect
) != NULL
4595 && elf_section_data (asect
)->this_idx
!= 0)
4596 return elf_section_data (asect
)->this_idx
;
4598 if (bfd_is_abs_section (asect
))
4600 else if (bfd_is_com_section (asect
))
4602 else if (bfd_is_und_section (asect
))
4606 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4607 int maxindex
= elf_numsections (abfd
);
4609 for (index
= 1; index
< maxindex
; index
++)
4611 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4613 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4619 bed
= get_elf_backend_data (abfd
);
4620 if (bed
->elf_backend_section_from_bfd_section
)
4624 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4629 bfd_set_error (bfd_error_nonrepresentable_section
);
4634 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4638 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
4640 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4642 flagword flags
= asym_ptr
->flags
;
4644 /* When gas creates relocations against local labels, it creates its
4645 own symbol for the section, but does put the symbol into the
4646 symbol chain, so udata is 0. When the linker is generating
4647 relocatable output, this section symbol may be for one of the
4648 input sections rather than the output section. */
4649 if (asym_ptr
->udata
.i
== 0
4650 && (flags
& BSF_SECTION_SYM
)
4651 && asym_ptr
->section
)
4655 if (asym_ptr
->section
->output_section
!= NULL
)
4656 indx
= asym_ptr
->section
->output_section
->index
;
4658 indx
= asym_ptr
->section
->index
;
4659 if (indx
< elf_num_section_syms (abfd
)
4660 && elf_section_syms (abfd
)[indx
] != NULL
)
4661 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4664 idx
= asym_ptr
->udata
.i
;
4668 /* This case can occur when using --strip-symbol on a symbol
4669 which is used in a relocation entry. */
4670 (*_bfd_error_handler
)
4671 (_("%s: symbol `%s' required but not present"),
4672 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4673 bfd_set_error (bfd_error_no_symbols
);
4680 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4681 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4682 elf_symbol_flags (flags
));
4690 /* Copy private BFD data. This copies any program header information. */
4693 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4695 Elf_Internal_Ehdr
*iehdr
;
4696 struct elf_segment_map
*map
;
4697 struct elf_segment_map
*map_first
;
4698 struct elf_segment_map
**pointer_to_map
;
4699 Elf_Internal_Phdr
*segment
;
4702 unsigned int num_segments
;
4703 bfd_boolean phdr_included
= FALSE
;
4704 bfd_vma maxpagesize
;
4705 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
4706 unsigned int phdr_adjust_num
= 0;
4707 const struct elf_backend_data
*bed
;
4709 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4710 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4713 if (elf_tdata (ibfd
)->phdr
== NULL
)
4716 bed
= get_elf_backend_data (ibfd
);
4717 iehdr
= elf_elfheader (ibfd
);
4720 pointer_to_map
= &map_first
;
4722 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4723 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4725 /* Returns the end address of the segment + 1. */
4726 #define SEGMENT_END(segment, start) \
4727 (start + (segment->p_memsz > segment->p_filesz \
4728 ? segment->p_memsz : segment->p_filesz))
4730 #define SECTION_SIZE(section, segment) \
4731 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4732 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
4733 ? section->size : 0)
4735 /* Returns TRUE if the given section is contained within
4736 the given segment. VMA addresses are compared. */
4737 #define IS_CONTAINED_BY_VMA(section, segment) \
4738 (section->vma >= segment->p_vaddr \
4739 && (section->vma + SECTION_SIZE (section, segment) \
4740 <= (SEGMENT_END (segment, segment->p_vaddr))))
4742 /* Returns TRUE if the given section is contained within
4743 the given segment. LMA addresses are compared. */
4744 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4745 (section->lma >= base \
4746 && (section->lma + SECTION_SIZE (section, segment) \
4747 <= SEGMENT_END (segment, base)))
4749 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4750 #define IS_COREFILE_NOTE(p, s) \
4751 (p->p_type == PT_NOTE \
4752 && bfd_get_format (ibfd) == bfd_core \
4753 && s->vma == 0 && s->lma == 0 \
4754 && (bfd_vma) s->filepos >= p->p_offset \
4755 && ((bfd_vma) s->filepos + s->size \
4756 <= p->p_offset + p->p_filesz))
4758 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4759 linker, which generates a PT_INTERP section with p_vaddr and
4760 p_memsz set to 0. */
4761 #define IS_SOLARIS_PT_INTERP(p, s) \
4763 && p->p_paddr == 0 \
4764 && p->p_memsz == 0 \
4765 && p->p_filesz > 0 \
4766 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4768 && (bfd_vma) s->filepos >= p->p_offset \
4769 && ((bfd_vma) s->filepos + s->size \
4770 <= p->p_offset + p->p_filesz))
4772 /* Decide if the given section should be included in the given segment.
4773 A section will be included if:
4774 1. It is within the address space of the segment -- we use the LMA
4775 if that is set for the segment and the VMA otherwise,
4776 2. It is an allocated segment,
4777 3. There is an output section associated with it,
4778 4. The section has not already been allocated to a previous segment.
4779 5. PT_GNU_STACK segments do not include any sections.
4780 6. PT_TLS segment includes only SHF_TLS sections.
4781 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
4782 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4783 ((((segment->p_paddr \
4784 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4785 : IS_CONTAINED_BY_VMA (section, segment)) \
4786 && (section->flags & SEC_ALLOC) != 0) \
4787 || IS_COREFILE_NOTE (segment, section)) \
4788 && section->output_section != NULL \
4789 && segment->p_type != PT_GNU_STACK \
4790 && (segment->p_type != PT_TLS \
4791 || (section->flags & SEC_THREAD_LOCAL)) \
4792 && (segment->p_type == PT_LOAD \
4793 || segment->p_type == PT_TLS \
4794 || (section->flags & SEC_THREAD_LOCAL) == 0) \
4795 && ! section->segment_mark)
4797 /* Returns TRUE iff seg1 starts after the end of seg2. */
4798 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
4799 (seg1->field >= SEGMENT_END (seg2, seg2->field))
4801 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4802 their VMA address ranges and their LMA address ranges overlap.
4803 It is possible to have overlapping VMA ranges without overlapping LMA
4804 ranges. RedBoot images for example can have both .data and .bss mapped
4805 to the same VMA range, but with the .data section mapped to a different
4807 #define SEGMENT_OVERLAPS(seg1, seg2) \
4808 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
4809 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
4810 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
4811 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4813 /* Initialise the segment mark field. */
4814 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4815 section
->segment_mark
= FALSE
;
4817 /* Scan through the segments specified in the program header
4818 of the input BFD. For this first scan we look for overlaps
4819 in the loadable segments. These can be created by weird
4820 parameters to objcopy. Also, fix some solaris weirdness. */
4821 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4826 Elf_Internal_Phdr
*segment2
;
4828 if (segment
->p_type
== PT_INTERP
)
4829 for (section
= ibfd
->sections
; section
; section
= section
->next
)
4830 if (IS_SOLARIS_PT_INTERP (segment
, section
))
4832 /* Mininal change so that the normal section to segment
4833 assignment code will work. */
4834 segment
->p_vaddr
= section
->vma
;
4838 if (segment
->p_type
!= PT_LOAD
)
4841 /* Determine if this segment overlaps any previous segments. */
4842 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4844 bfd_signed_vma extra_length
;
4846 if (segment2
->p_type
!= PT_LOAD
4847 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4850 /* Merge the two segments together. */
4851 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4853 /* Extend SEGMENT2 to include SEGMENT and then delete
4856 SEGMENT_END (segment
, segment
->p_vaddr
)
4857 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4859 if (extra_length
> 0)
4861 segment2
->p_memsz
+= extra_length
;
4862 segment2
->p_filesz
+= extra_length
;
4865 segment
->p_type
= PT_NULL
;
4867 /* Since we have deleted P we must restart the outer loop. */
4869 segment
= elf_tdata (ibfd
)->phdr
;
4874 /* Extend SEGMENT to include SEGMENT2 and then delete
4877 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4878 - SEGMENT_END (segment
, segment
->p_vaddr
);
4880 if (extra_length
> 0)
4882 segment
->p_memsz
+= extra_length
;
4883 segment
->p_filesz
+= extra_length
;
4886 segment2
->p_type
= PT_NULL
;
4891 /* The second scan attempts to assign sections to segments. */
4892 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4896 unsigned int section_count
;
4897 asection
** sections
;
4898 asection
* output_section
;
4900 bfd_vma matching_lma
;
4901 bfd_vma suggested_lma
;
4905 if (segment
->p_type
== PT_NULL
)
4908 /* Compute how many sections might be placed into this segment. */
4909 for (section
= ibfd
->sections
, section_count
= 0;
4911 section
= section
->next
)
4912 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
4915 /* Allocate a segment map big enough to contain
4916 all of the sections we have selected. */
4917 amt
= sizeof (struct elf_segment_map
);
4918 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4919 map
= bfd_alloc (obfd
, amt
);
4923 /* Initialise the fields of the segment map. Default to
4924 using the physical address of the segment in the input BFD. */
4926 map
->p_type
= segment
->p_type
;
4927 map
->p_flags
= segment
->p_flags
;
4928 map
->p_flags_valid
= 1;
4929 map
->p_paddr
= segment
->p_paddr
;
4930 map
->p_paddr_valid
= 1;
4932 /* Determine if this segment contains the ELF file header
4933 and if it contains the program headers themselves. */
4934 map
->includes_filehdr
= (segment
->p_offset
== 0
4935 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4937 map
->includes_phdrs
= 0;
4939 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4941 map
->includes_phdrs
=
4942 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4943 && (segment
->p_offset
+ segment
->p_filesz
4944 >= ((bfd_vma
) iehdr
->e_phoff
4945 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4947 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4948 phdr_included
= TRUE
;
4951 if (section_count
== 0)
4953 /* Special segments, such as the PT_PHDR segment, may contain
4954 no sections, but ordinary, loadable segments should contain
4955 something. They are allowed by the ELF spec however, so only
4956 a warning is produced. */
4957 if (segment
->p_type
== PT_LOAD
)
4958 (*_bfd_error_handler
)
4959 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4960 bfd_archive_filename (ibfd
));
4963 *pointer_to_map
= map
;
4964 pointer_to_map
= &map
->next
;
4969 /* Now scan the sections in the input BFD again and attempt
4970 to add their corresponding output sections to the segment map.
4971 The problem here is how to handle an output section which has
4972 been moved (ie had its LMA changed). There are four possibilities:
4974 1. None of the sections have been moved.
4975 In this case we can continue to use the segment LMA from the
4978 2. All of the sections have been moved by the same amount.
4979 In this case we can change the segment's LMA to match the LMA
4980 of the first section.
4982 3. Some of the sections have been moved, others have not.
4983 In this case those sections which have not been moved can be
4984 placed in the current segment which will have to have its size,
4985 and possibly its LMA changed, and a new segment or segments will
4986 have to be created to contain the other sections.
4988 4. The sections have been moved, but not by the same amount.
4989 In this case we can change the segment's LMA to match the LMA
4990 of the first section and we will have to create a new segment
4991 or segments to contain the other sections.
4993 In order to save time, we allocate an array to hold the section
4994 pointers that we are interested in. As these sections get assigned
4995 to a segment, they are removed from this array. */
4997 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4998 to work around this long long bug. */
4999 amt
= section_count
* sizeof (asection
*);
5000 sections
= bfd_malloc (amt
);
5001 if (sections
== NULL
)
5004 /* Step One: Scan for segment vs section LMA conflicts.
5005 Also add the sections to the section array allocated above.
5006 Also add the sections to the current segment. In the common
5007 case, where the sections have not been moved, this means that
5008 we have completely filled the segment, and there is nothing
5014 for (j
= 0, section
= ibfd
->sections
;
5016 section
= section
->next
)
5018 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5020 output_section
= section
->output_section
;
5022 sections
[j
++] = section
;
5024 /* The Solaris native linker always sets p_paddr to 0.
5025 We try to catch that case here, and set it to the
5026 correct value. Note - some backends require that
5027 p_paddr be left as zero. */
5028 if (segment
->p_paddr
== 0
5029 && segment
->p_vaddr
!= 0
5030 && (! bed
->want_p_paddr_set_to_zero
)
5032 && output_section
->lma
!= 0
5033 && (output_section
->vma
== (segment
->p_vaddr
5034 + (map
->includes_filehdr
5037 + (map
->includes_phdrs
5039 * iehdr
->e_phentsize
)
5041 map
->p_paddr
= segment
->p_vaddr
;
5043 /* Match up the physical address of the segment with the
5044 LMA address of the output section. */
5045 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5046 || IS_COREFILE_NOTE (segment
, section
)
5047 || (bed
->want_p_paddr_set_to_zero
&&
5048 IS_CONTAINED_BY_VMA (output_section
, segment
))
5051 if (matching_lma
== 0)
5052 matching_lma
= output_section
->lma
;
5054 /* We assume that if the section fits within the segment
5055 then it does not overlap any other section within that
5057 map
->sections
[isec
++] = output_section
;
5059 else if (suggested_lma
== 0)
5060 suggested_lma
= output_section
->lma
;
5064 BFD_ASSERT (j
== section_count
);
5066 /* Step Two: Adjust the physical address of the current segment,
5068 if (isec
== section_count
)
5070 /* All of the sections fitted within the segment as currently
5071 specified. This is the default case. Add the segment to
5072 the list of built segments and carry on to process the next
5073 program header in the input BFD. */
5074 map
->count
= section_count
;
5075 *pointer_to_map
= map
;
5076 pointer_to_map
= &map
->next
;
5083 if (matching_lma
!= 0)
5085 /* At least one section fits inside the current segment.
5086 Keep it, but modify its physical address to match the
5087 LMA of the first section that fitted. */
5088 map
->p_paddr
= matching_lma
;
5092 /* None of the sections fitted inside the current segment.
5093 Change the current segment's physical address to match
5094 the LMA of the first section. */
5095 map
->p_paddr
= suggested_lma
;
5098 /* Offset the segment physical address from the lma
5099 to allow for space taken up by elf headers. */
5100 if (map
->includes_filehdr
)
5101 map
->p_paddr
-= iehdr
->e_ehsize
;
5103 if (map
->includes_phdrs
)
5105 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5107 /* iehdr->e_phnum is just an estimate of the number
5108 of program headers that we will need. Make a note
5109 here of the number we used and the segment we chose
5110 to hold these headers, so that we can adjust the
5111 offset when we know the correct value. */
5112 phdr_adjust_num
= iehdr
->e_phnum
;
5113 phdr_adjust_seg
= map
;
5117 /* Step Three: Loop over the sections again, this time assigning
5118 those that fit to the current segment and removing them from the
5119 sections array; but making sure not to leave large gaps. Once all
5120 possible sections have been assigned to the current segment it is
5121 added to the list of built segments and if sections still remain
5122 to be assigned, a new segment is constructed before repeating
5130 /* Fill the current segment with sections that fit. */
5131 for (j
= 0; j
< section_count
; j
++)
5133 section
= sections
[j
];
5135 if (section
== NULL
)
5138 output_section
= section
->output_section
;
5140 BFD_ASSERT (output_section
!= NULL
);
5142 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5143 || IS_COREFILE_NOTE (segment
, section
))
5145 if (map
->count
== 0)
5147 /* If the first section in a segment does not start at
5148 the beginning of the segment, then something is
5150 if (output_section
->lma
!=
5152 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5153 + (map
->includes_phdrs
5154 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5160 asection
* prev_sec
;
5162 prev_sec
= map
->sections
[map
->count
- 1];
5164 /* If the gap between the end of the previous section
5165 and the start of this section is more than
5166 maxpagesize then we need to start a new segment. */
5167 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5169 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5170 || ((prev_sec
->lma
+ prev_sec
->size
)
5171 > output_section
->lma
))
5173 if (suggested_lma
== 0)
5174 suggested_lma
= output_section
->lma
;
5180 map
->sections
[map
->count
++] = output_section
;
5183 section
->segment_mark
= TRUE
;
5185 else if (suggested_lma
== 0)
5186 suggested_lma
= output_section
->lma
;
5189 BFD_ASSERT (map
->count
> 0);
5191 /* Add the current segment to the list of built segments. */
5192 *pointer_to_map
= map
;
5193 pointer_to_map
= &map
->next
;
5195 if (isec
< section_count
)
5197 /* We still have not allocated all of the sections to
5198 segments. Create a new segment here, initialise it
5199 and carry on looping. */
5200 amt
= sizeof (struct elf_segment_map
);
5201 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5202 map
= bfd_alloc (obfd
, amt
);
5209 /* Initialise the fields of the segment map. Set the physical
5210 physical address to the LMA of the first section that has
5211 not yet been assigned. */
5213 map
->p_type
= segment
->p_type
;
5214 map
->p_flags
= segment
->p_flags
;
5215 map
->p_flags_valid
= 1;
5216 map
->p_paddr
= suggested_lma
;
5217 map
->p_paddr_valid
= 1;
5218 map
->includes_filehdr
= 0;
5219 map
->includes_phdrs
= 0;
5222 while (isec
< section_count
);
5227 /* The Solaris linker creates program headers in which all the
5228 p_paddr fields are zero. When we try to objcopy or strip such a
5229 file, we get confused. Check for this case, and if we find it
5230 reset the p_paddr_valid fields. */
5231 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5232 if (map
->p_paddr
!= 0)
5235 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5236 map
->p_paddr_valid
= 0;
5238 elf_tdata (obfd
)->segment_map
= map_first
;
5240 /* If we had to estimate the number of program headers that were
5241 going to be needed, then check our estimate now and adjust
5242 the offset if necessary. */
5243 if (phdr_adjust_seg
!= NULL
)
5247 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5250 if (count
> phdr_adjust_num
)
5251 phdr_adjust_seg
->p_paddr
5252 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5256 /* Final Step: Sort the segments into ascending order of physical
5258 if (map_first
!= NULL
)
5260 struct elf_segment_map
*prev
;
5263 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
5265 /* Yes I know - its a bubble sort.... */
5266 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
5268 /* Swap map and map->next. */
5269 prev
->next
= map
->next
;
5270 map
->next
= map
->next
->next
;
5271 prev
->next
->next
= map
;
5282 #undef IS_CONTAINED_BY_VMA
5283 #undef IS_CONTAINED_BY_LMA
5284 #undef IS_COREFILE_NOTE
5285 #undef IS_SOLARIS_PT_INTERP
5286 #undef INCLUDE_SECTION_IN_SEGMENT
5287 #undef SEGMENT_AFTER_SEGMENT
5288 #undef SEGMENT_OVERLAPS
5292 /* Copy private section information. This copies over the entsize
5293 field, and sometimes the info field. */
5296 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
5301 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5303 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5304 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5307 ihdr
= &elf_section_data (isec
)->this_hdr
;
5308 ohdr
= &elf_section_data (osec
)->this_hdr
;
5310 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
5312 if (ihdr
->sh_type
== SHT_SYMTAB
5313 || ihdr
->sh_type
== SHT_DYNSYM
5314 || ihdr
->sh_type
== SHT_GNU_verneed
5315 || ihdr
->sh_type
== SHT_GNU_verdef
)
5316 ohdr
->sh_info
= ihdr
->sh_info
;
5318 /* Set things up for objcopy. The output SHT_GROUP section will
5319 have its elf_next_in_group pointing back to the input group
5321 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5322 elf_group_name (osec
) = elf_group_name (isec
);
5324 osec
->use_rela_p
= isec
->use_rela_p
;
5329 /* Copy private header information. */
5332 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
5334 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5335 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5338 /* Copy over private BFD data if it has not already been copied.
5339 This must be done here, rather than in the copy_private_bfd_data
5340 entry point, because the latter is called after the section
5341 contents have been set, which means that the program headers have
5342 already been worked out. */
5343 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
5345 if (! copy_private_bfd_data (ibfd
, obfd
))
5352 /* Copy private symbol information. If this symbol is in a section
5353 which we did not map into a BFD section, try to map the section
5354 index correctly. We use special macro definitions for the mapped
5355 section indices; these definitions are interpreted by the
5356 swap_out_syms function. */
5358 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5359 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5360 #define MAP_STRTAB (SHN_HIOS + 3)
5361 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5362 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5365 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
5370 elf_symbol_type
*isym
, *osym
;
5372 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5373 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5376 isym
= elf_symbol_from (ibfd
, isymarg
);
5377 osym
= elf_symbol_from (obfd
, osymarg
);
5381 && bfd_is_abs_section (isym
->symbol
.section
))
5385 shndx
= isym
->internal_elf_sym
.st_shndx
;
5386 if (shndx
== elf_onesymtab (ibfd
))
5387 shndx
= MAP_ONESYMTAB
;
5388 else if (shndx
== elf_dynsymtab (ibfd
))
5389 shndx
= MAP_DYNSYMTAB
;
5390 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
5392 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
5393 shndx
= MAP_SHSTRTAB
;
5394 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
5395 shndx
= MAP_SYM_SHNDX
;
5396 osym
->internal_elf_sym
.st_shndx
= shndx
;
5402 /* Swap out the symbols. */
5405 swap_out_syms (bfd
*abfd
,
5406 struct bfd_strtab_hash
**sttp
,
5409 const struct elf_backend_data
*bed
;
5412 struct bfd_strtab_hash
*stt
;
5413 Elf_Internal_Shdr
*symtab_hdr
;
5414 Elf_Internal_Shdr
*symtab_shndx_hdr
;
5415 Elf_Internal_Shdr
*symstrtab_hdr
;
5416 char *outbound_syms
;
5417 char *outbound_shndx
;
5420 bfd_boolean name_local_sections
;
5422 if (!elf_map_symbols (abfd
))
5425 /* Dump out the symtabs. */
5426 stt
= _bfd_elf_stringtab_init ();
5430 bed
= get_elf_backend_data (abfd
);
5431 symcount
= bfd_get_symcount (abfd
);
5432 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5433 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5434 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
5435 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
5436 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
5437 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
5439 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5440 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5442 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
5443 outbound_syms
= bfd_alloc (abfd
, amt
);
5444 if (outbound_syms
== NULL
)
5446 _bfd_stringtab_free (stt
);
5449 symtab_hdr
->contents
= outbound_syms
;
5451 outbound_shndx
= NULL
;
5452 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
5453 if (symtab_shndx_hdr
->sh_name
!= 0)
5455 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
5456 outbound_shndx
= bfd_zalloc (abfd
, amt
);
5457 if (outbound_shndx
== NULL
)
5459 _bfd_stringtab_free (stt
);
5463 symtab_shndx_hdr
->contents
= outbound_shndx
;
5464 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
5465 symtab_shndx_hdr
->sh_size
= amt
;
5466 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
5467 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
5470 /* Now generate the data (for "contents"). */
5472 /* Fill in zeroth symbol and swap it out. */
5473 Elf_Internal_Sym sym
;
5479 sym
.st_shndx
= SHN_UNDEF
;
5480 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5481 outbound_syms
+= bed
->s
->sizeof_sym
;
5482 if (outbound_shndx
!= NULL
)
5483 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5487 = (bed
->elf_backend_name_local_section_symbols
5488 && bed
->elf_backend_name_local_section_symbols (abfd
));
5490 syms
= bfd_get_outsymbols (abfd
);
5491 for (idx
= 0; idx
< symcount
; idx
++)
5493 Elf_Internal_Sym sym
;
5494 bfd_vma value
= syms
[idx
]->value
;
5495 elf_symbol_type
*type_ptr
;
5496 flagword flags
= syms
[idx
]->flags
;
5499 if (!name_local_sections
5500 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
5502 /* Local section symbols have no name. */
5507 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
5510 if (sym
.st_name
== (unsigned long) -1)
5512 _bfd_stringtab_free (stt
);
5517 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
5519 if ((flags
& BSF_SECTION_SYM
) == 0
5520 && bfd_is_com_section (syms
[idx
]->section
))
5522 /* ELF common symbols put the alignment into the `value' field,
5523 and the size into the `size' field. This is backwards from
5524 how BFD handles it, so reverse it here. */
5525 sym
.st_size
= value
;
5526 if (type_ptr
== NULL
5527 || type_ptr
->internal_elf_sym
.st_value
== 0)
5528 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
5530 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
5531 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
5532 (abfd
, syms
[idx
]->section
);
5536 asection
*sec
= syms
[idx
]->section
;
5539 if (sec
->output_section
)
5541 value
+= sec
->output_offset
;
5542 sec
= sec
->output_section
;
5545 /* Don't add in the section vma for relocatable output. */
5546 if (! relocatable_p
)
5548 sym
.st_value
= value
;
5549 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
5551 if (bfd_is_abs_section (sec
)
5553 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
5555 /* This symbol is in a real ELF section which we did
5556 not create as a BFD section. Undo the mapping done
5557 by copy_private_symbol_data. */
5558 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
5562 shndx
= elf_onesymtab (abfd
);
5565 shndx
= elf_dynsymtab (abfd
);
5568 shndx
= elf_tdata (abfd
)->strtab_section
;
5571 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5574 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5582 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5588 /* Writing this would be a hell of a lot easier if
5589 we had some decent documentation on bfd, and
5590 knew what to expect of the library, and what to
5591 demand of applications. For example, it
5592 appears that `objcopy' might not set the
5593 section of a symbol to be a section that is
5594 actually in the output file. */
5595 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5598 _bfd_error_handler (_("\
5599 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5600 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
5602 bfd_set_error (bfd_error_invalid_operation
);
5603 _bfd_stringtab_free (stt
);
5607 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5608 BFD_ASSERT (shndx
!= -1);
5612 sym
.st_shndx
= shndx
;
5615 if ((flags
& BSF_THREAD_LOCAL
) != 0)
5617 else if ((flags
& BSF_FUNCTION
) != 0)
5619 else if ((flags
& BSF_OBJECT
) != 0)
5624 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
5627 /* Processor-specific types. */
5628 if (type_ptr
!= NULL
5629 && bed
->elf_backend_get_symbol_type
)
5630 type
= ((*bed
->elf_backend_get_symbol_type
)
5631 (&type_ptr
->internal_elf_sym
, type
));
5633 if (flags
& BSF_SECTION_SYM
)
5635 if (flags
& BSF_GLOBAL
)
5636 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5638 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5640 else if (bfd_is_com_section (syms
[idx
]->section
))
5641 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5642 else if (bfd_is_und_section (syms
[idx
]->section
))
5643 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5647 else if (flags
& BSF_FILE
)
5648 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5651 int bind
= STB_LOCAL
;
5653 if (flags
& BSF_LOCAL
)
5655 else if (flags
& BSF_WEAK
)
5657 else if (flags
& BSF_GLOBAL
)
5660 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5663 if (type_ptr
!= NULL
)
5664 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5668 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5669 outbound_syms
+= bed
->s
->sizeof_sym
;
5670 if (outbound_shndx
!= NULL
)
5671 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5675 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5676 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5678 symstrtab_hdr
->sh_flags
= 0;
5679 symstrtab_hdr
->sh_addr
= 0;
5680 symstrtab_hdr
->sh_entsize
= 0;
5681 symstrtab_hdr
->sh_link
= 0;
5682 symstrtab_hdr
->sh_info
= 0;
5683 symstrtab_hdr
->sh_addralign
= 1;
5688 /* Return the number of bytes required to hold the symtab vector.
5690 Note that we base it on the count plus 1, since we will null terminate
5691 the vector allocated based on this size. However, the ELF symbol table
5692 always has a dummy entry as symbol #0, so it ends up even. */
5695 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
5699 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5701 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5702 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5704 symtab_size
-= sizeof (asymbol
*);
5710 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
5714 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5716 if (elf_dynsymtab (abfd
) == 0)
5718 bfd_set_error (bfd_error_invalid_operation
);
5722 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5723 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5725 symtab_size
-= sizeof (asymbol
*);
5731 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
5734 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5737 /* Canonicalize the relocs. */
5740 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
5747 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5749 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
5752 tblptr
= section
->relocation
;
5753 for (i
= 0; i
< section
->reloc_count
; i
++)
5754 *relptr
++ = tblptr
++;
5758 return section
->reloc_count
;
5762 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
5764 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5765 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
5768 bfd_get_symcount (abfd
) = symcount
;
5773 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
5774 asymbol
**allocation
)
5776 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5777 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
5780 bfd_get_dynamic_symcount (abfd
) = symcount
;
5784 /* Return the size required for the dynamic reloc entries. Any
5785 section that was actually installed in the BFD, and has type
5786 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5787 considered to be a dynamic reloc section. */
5790 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
5795 if (elf_dynsymtab (abfd
) == 0)
5797 bfd_set_error (bfd_error_invalid_operation
);
5801 ret
= sizeof (arelent
*);
5802 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5803 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5804 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5805 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5806 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5807 * sizeof (arelent
*));
5812 /* Canonicalize the dynamic relocation entries. Note that we return
5813 the dynamic relocations as a single block, although they are
5814 actually associated with particular sections; the interface, which
5815 was designed for SunOS style shared libraries, expects that there
5816 is only one set of dynamic relocs. Any section that was actually
5817 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5818 the dynamic symbol table, is considered to be a dynamic reloc
5822 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
5826 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5830 if (elf_dynsymtab (abfd
) == 0)
5832 bfd_set_error (bfd_error_invalid_operation
);
5836 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5838 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5840 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5841 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5842 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5847 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
5849 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5851 for (i
= 0; i
< count
; i
++)
5862 /* Read in the version information. */
5865 _bfd_elf_slurp_version_tables (bfd
*abfd
)
5867 bfd_byte
*contents
= NULL
;
5870 if (elf_dynverdef (abfd
) != 0)
5872 Elf_Internal_Shdr
*hdr
;
5873 Elf_External_Verdef
*everdef
;
5874 Elf_Internal_Verdef
*iverdef
;
5875 Elf_Internal_Verdef
*iverdefarr
;
5876 Elf_Internal_Verdef iverdefmem
;
5878 unsigned int maxidx
;
5880 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5882 contents
= bfd_malloc (hdr
->sh_size
);
5883 if (contents
== NULL
)
5885 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5886 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5889 /* We know the number of entries in the section but not the maximum
5890 index. Therefore we have to run through all entries and find
5892 everdef
= (Elf_External_Verdef
*) contents
;
5894 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5896 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5898 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5899 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5901 everdef
= ((Elf_External_Verdef
*)
5902 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5905 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5906 elf_tdata (abfd
)->verdef
= bfd_zalloc (abfd
, amt
);
5907 if (elf_tdata (abfd
)->verdef
== NULL
)
5910 elf_tdata (abfd
)->cverdefs
= maxidx
;
5912 everdef
= (Elf_External_Verdef
*) contents
;
5913 iverdefarr
= elf_tdata (abfd
)->verdef
;
5914 for (i
= 0; i
< hdr
->sh_info
; i
++)
5916 Elf_External_Verdaux
*everdaux
;
5917 Elf_Internal_Verdaux
*iverdaux
;
5920 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5922 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5923 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5925 iverdef
->vd_bfd
= abfd
;
5927 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5928 iverdef
->vd_auxptr
= bfd_alloc (abfd
, amt
);
5929 if (iverdef
->vd_auxptr
== NULL
)
5932 everdaux
= ((Elf_External_Verdaux
*)
5933 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5934 iverdaux
= iverdef
->vd_auxptr
;
5935 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5937 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5939 iverdaux
->vda_nodename
=
5940 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5941 iverdaux
->vda_name
);
5942 if (iverdaux
->vda_nodename
== NULL
)
5945 if (j
+ 1 < iverdef
->vd_cnt
)
5946 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5948 iverdaux
->vda_nextptr
= NULL
;
5950 everdaux
= ((Elf_External_Verdaux
*)
5951 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5954 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5956 if (i
+ 1 < hdr
->sh_info
)
5957 iverdef
->vd_nextdef
= iverdef
+ 1;
5959 iverdef
->vd_nextdef
= NULL
;
5961 everdef
= ((Elf_External_Verdef
*)
5962 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5969 if (elf_dynverref (abfd
) != 0)
5971 Elf_Internal_Shdr
*hdr
;
5972 Elf_External_Verneed
*everneed
;
5973 Elf_Internal_Verneed
*iverneed
;
5976 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5978 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5979 elf_tdata (abfd
)->verref
= bfd_zalloc (abfd
, amt
);
5980 if (elf_tdata (abfd
)->verref
== NULL
)
5983 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5985 contents
= bfd_malloc (hdr
->sh_size
);
5986 if (contents
== NULL
)
5988 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5989 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5992 everneed
= (Elf_External_Verneed
*) contents
;
5993 iverneed
= elf_tdata (abfd
)->verref
;
5994 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
5996 Elf_External_Vernaux
*evernaux
;
5997 Elf_Internal_Vernaux
*ivernaux
;
6000 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6002 iverneed
->vn_bfd
= abfd
;
6004 iverneed
->vn_filename
=
6005 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6007 if (iverneed
->vn_filename
== NULL
)
6010 amt
= iverneed
->vn_cnt
;
6011 amt
*= sizeof (Elf_Internal_Vernaux
);
6012 iverneed
->vn_auxptr
= bfd_alloc (abfd
, amt
);
6014 evernaux
= ((Elf_External_Vernaux
*)
6015 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6016 ivernaux
= iverneed
->vn_auxptr
;
6017 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6019 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6021 ivernaux
->vna_nodename
=
6022 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6023 ivernaux
->vna_name
);
6024 if (ivernaux
->vna_nodename
== NULL
)
6027 if (j
+ 1 < iverneed
->vn_cnt
)
6028 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6030 ivernaux
->vna_nextptr
= NULL
;
6032 evernaux
= ((Elf_External_Vernaux
*)
6033 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6036 if (i
+ 1 < hdr
->sh_info
)
6037 iverneed
->vn_nextref
= iverneed
+ 1;
6039 iverneed
->vn_nextref
= NULL
;
6041 everneed
= ((Elf_External_Verneed
*)
6042 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6052 if (contents
!= NULL
)
6058 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6060 elf_symbol_type
*newsym
;
6061 bfd_size_type amt
= sizeof (elf_symbol_type
);
6063 newsym
= bfd_zalloc (abfd
, amt
);
6068 newsym
->symbol
.the_bfd
= abfd
;
6069 return &newsym
->symbol
;
6074 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6078 bfd_symbol_info (symbol
, ret
);
6081 /* Return whether a symbol name implies a local symbol. Most targets
6082 use this function for the is_local_label_name entry point, but some
6086 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6089 /* Normal local symbols start with ``.L''. */
6090 if (name
[0] == '.' && name
[1] == 'L')
6093 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6094 DWARF debugging symbols starting with ``..''. */
6095 if (name
[0] == '.' && name
[1] == '.')
6098 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6099 emitting DWARF debugging output. I suspect this is actually a
6100 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6101 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6102 underscore to be emitted on some ELF targets). For ease of use,
6103 we treat such symbols as local. */
6104 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6111 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
6112 asymbol
*symbol ATTRIBUTE_UNUSED
)
6119 _bfd_elf_set_arch_mach (bfd
*abfd
,
6120 enum bfd_architecture arch
,
6121 unsigned long machine
)
6123 /* If this isn't the right architecture for this backend, and this
6124 isn't the generic backend, fail. */
6125 if (arch
!= get_elf_backend_data (abfd
)->arch
6126 && arch
!= bfd_arch_unknown
6127 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
6130 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
6133 /* Find the function to a particular section and offset,
6134 for error reporting. */
6137 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
6141 const char **filename_ptr
,
6142 const char **functionname_ptr
)
6144 const char *filename
;
6153 for (p
= symbols
; *p
!= NULL
; p
++)
6157 q
= (elf_symbol_type
*) *p
;
6159 if (bfd_get_section (&q
->symbol
) != section
)
6162 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
6167 filename
= bfd_asymbol_name (&q
->symbol
);
6171 if (q
->symbol
.section
== section
6172 && q
->symbol
.value
>= low_func
6173 && q
->symbol
.value
<= offset
)
6175 func
= (asymbol
*) q
;
6176 low_func
= q
->symbol
.value
;
6186 *filename_ptr
= filename
;
6187 if (functionname_ptr
)
6188 *functionname_ptr
= bfd_asymbol_name (func
);
6193 /* Find the nearest line to a particular section and offset,
6194 for error reporting. */
6197 _bfd_elf_find_nearest_line (bfd
*abfd
,
6201 const char **filename_ptr
,
6202 const char **functionname_ptr
,
6203 unsigned int *line_ptr
)
6207 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
6208 filename_ptr
, functionname_ptr
,
6211 if (!*functionname_ptr
)
6212 elf_find_function (abfd
, section
, symbols
, offset
,
6213 *filename_ptr
? NULL
: filename_ptr
,
6219 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
6220 filename_ptr
, functionname_ptr
,
6222 &elf_tdata (abfd
)->dwarf2_find_line_info
))
6224 if (!*functionname_ptr
)
6225 elf_find_function (abfd
, section
, symbols
, offset
,
6226 *filename_ptr
? NULL
: filename_ptr
,
6232 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
6233 &found
, filename_ptr
,
6234 functionname_ptr
, line_ptr
,
6235 &elf_tdata (abfd
)->line_info
))
6237 if (found
&& (*functionname_ptr
|| *line_ptr
))
6240 if (symbols
== NULL
)
6243 if (! elf_find_function (abfd
, section
, symbols
, offset
,
6244 filename_ptr
, functionname_ptr
))
6252 _bfd_elf_sizeof_headers (bfd
*abfd
, bfd_boolean reloc
)
6256 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
6258 ret
+= get_program_header_size (abfd
);
6263 _bfd_elf_set_section_contents (bfd
*abfd
,
6265 const void *location
,
6267 bfd_size_type count
)
6269 Elf_Internal_Shdr
*hdr
;
6272 if (! abfd
->output_has_begun
6273 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6276 hdr
= &elf_section_data (section
)->this_hdr
;
6277 pos
= hdr
->sh_offset
+ offset
;
6278 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6279 || bfd_bwrite (location
, count
, abfd
) != count
)
6286 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
6287 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
6288 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
6293 /* Try to convert a non-ELF reloc into an ELF one. */
6296 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
6298 /* Check whether we really have an ELF howto. */
6300 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
6302 bfd_reloc_code_real_type code
;
6303 reloc_howto_type
*howto
;
6305 /* Alien reloc: Try to determine its type to replace it with an
6306 equivalent ELF reloc. */
6308 if (areloc
->howto
->pc_relative
)
6310 switch (areloc
->howto
->bitsize
)
6313 code
= BFD_RELOC_8_PCREL
;
6316 code
= BFD_RELOC_12_PCREL
;
6319 code
= BFD_RELOC_16_PCREL
;
6322 code
= BFD_RELOC_24_PCREL
;
6325 code
= BFD_RELOC_32_PCREL
;
6328 code
= BFD_RELOC_64_PCREL
;
6334 howto
= bfd_reloc_type_lookup (abfd
, code
);
6336 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
6338 if (howto
->pcrel_offset
)
6339 areloc
->addend
+= areloc
->address
;
6341 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
6346 switch (areloc
->howto
->bitsize
)
6352 code
= BFD_RELOC_14
;
6355 code
= BFD_RELOC_16
;
6358 code
= BFD_RELOC_26
;
6361 code
= BFD_RELOC_32
;
6364 code
= BFD_RELOC_64
;
6370 howto
= bfd_reloc_type_lookup (abfd
, code
);
6374 areloc
->howto
= howto
;
6382 (*_bfd_error_handler
)
6383 (_("%s: unsupported relocation type %s"),
6384 bfd_archive_filename (abfd
), areloc
->howto
->name
);
6385 bfd_set_error (bfd_error_bad_value
);
6390 _bfd_elf_close_and_cleanup (bfd
*abfd
)
6392 if (bfd_get_format (abfd
) == bfd_object
)
6394 if (elf_shstrtab (abfd
) != NULL
)
6395 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
6398 return _bfd_generic_close_and_cleanup (abfd
);
6401 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6402 in the relocation's offset. Thus we cannot allow any sort of sanity
6403 range-checking to interfere. There is nothing else to do in processing
6406 bfd_reloc_status_type
6407 _bfd_elf_rel_vtable_reloc_fn
6408 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
6409 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
6410 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
6411 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
6413 return bfd_reloc_ok
;
6416 /* Elf core file support. Much of this only works on native
6417 toolchains, since we rely on knowing the
6418 machine-dependent procfs structure in order to pick
6419 out details about the corefile. */
6421 #ifdef HAVE_SYS_PROCFS_H
6422 # include <sys/procfs.h>
6425 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6428 elfcore_make_pid (bfd
*abfd
)
6430 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
6431 + (elf_tdata (abfd
)->core_pid
));
6434 /* If there isn't a section called NAME, make one, using
6435 data from SECT. Note, this function will generate a
6436 reference to NAME, so you shouldn't deallocate or
6440 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
6444 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
6447 sect2
= bfd_make_section (abfd
, name
);
6451 sect2
->size
= sect
->size
;
6452 sect2
->filepos
= sect
->filepos
;
6453 sect2
->flags
= sect
->flags
;
6454 sect2
->alignment_power
= sect
->alignment_power
;
6458 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6459 actually creates up to two pseudosections:
6460 - For the single-threaded case, a section named NAME, unless
6461 such a section already exists.
6462 - For the multi-threaded case, a section named "NAME/PID", where
6463 PID is elfcore_make_pid (abfd).
6464 Both pseudosections have identical contents. */
6466 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
6472 char *threaded_name
;
6476 /* Build the section name. */
6478 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
6479 len
= strlen (buf
) + 1;
6480 threaded_name
= bfd_alloc (abfd
, len
);
6481 if (threaded_name
== NULL
)
6483 memcpy (threaded_name
, buf
, len
);
6485 sect
= bfd_make_section_anyway (abfd
, threaded_name
);
6489 sect
->filepos
= filepos
;
6490 sect
->flags
= SEC_HAS_CONTENTS
;
6491 sect
->alignment_power
= 2;
6493 return elfcore_maybe_make_sect (abfd
, name
, sect
);
6496 /* prstatus_t exists on:
6498 linux 2.[01] + glibc
6502 #if defined (HAVE_PRSTATUS_T)
6505 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6510 if (note
->descsz
== sizeof (prstatus_t
))
6514 size
= sizeof (prstat
.pr_reg
);
6515 offset
= offsetof (prstatus_t
, pr_reg
);
6516 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6518 /* Do not overwrite the core signal if it
6519 has already been set by another thread. */
6520 if (elf_tdata (abfd
)->core_signal
== 0)
6521 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6522 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6524 /* pr_who exists on:
6527 pr_who doesn't exist on:
6530 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6531 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6534 #if defined (HAVE_PRSTATUS32_T)
6535 else if (note
->descsz
== sizeof (prstatus32_t
))
6537 /* 64-bit host, 32-bit corefile */
6538 prstatus32_t prstat
;
6540 size
= sizeof (prstat
.pr_reg
);
6541 offset
= offsetof (prstatus32_t
, pr_reg
);
6542 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6544 /* Do not overwrite the core signal if it
6545 has already been set by another thread. */
6546 if (elf_tdata (abfd
)->core_signal
== 0)
6547 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6548 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6550 /* pr_who exists on:
6553 pr_who doesn't exist on:
6556 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6557 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6560 #endif /* HAVE_PRSTATUS32_T */
6563 /* Fail - we don't know how to handle any other
6564 note size (ie. data object type). */
6568 /* Make a ".reg/999" section and a ".reg" section. */
6569 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6570 size
, note
->descpos
+ offset
);
6572 #endif /* defined (HAVE_PRSTATUS_T) */
6574 /* Create a pseudosection containing the exact contents of NOTE. */
6576 elfcore_make_note_pseudosection (bfd
*abfd
,
6578 Elf_Internal_Note
*note
)
6580 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6581 note
->descsz
, note
->descpos
);
6584 /* There isn't a consistent prfpregset_t across platforms,
6585 but it doesn't matter, because we don't have to pick this
6586 data structure apart. */
6589 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
6591 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6594 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6595 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6599 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
6601 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6604 #if defined (HAVE_PRPSINFO_T)
6605 typedef prpsinfo_t elfcore_psinfo_t
;
6606 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6607 typedef prpsinfo32_t elfcore_psinfo32_t
;
6611 #if defined (HAVE_PSINFO_T)
6612 typedef psinfo_t elfcore_psinfo_t
;
6613 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6614 typedef psinfo32_t elfcore_psinfo32_t
;
6618 /* return a malloc'ed copy of a string at START which is at
6619 most MAX bytes long, possibly without a terminating '\0'.
6620 the copy will always have a terminating '\0'. */
6623 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
6626 char *end
= memchr (start
, '\0', max
);
6634 dups
= bfd_alloc (abfd
, len
+ 1);
6638 memcpy (dups
, start
, len
);
6644 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6646 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6648 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6650 elfcore_psinfo_t psinfo
;
6652 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6654 elf_tdata (abfd
)->core_program
6655 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6656 sizeof (psinfo
.pr_fname
));
6658 elf_tdata (abfd
)->core_command
6659 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6660 sizeof (psinfo
.pr_psargs
));
6662 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6663 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6665 /* 64-bit host, 32-bit corefile */
6666 elfcore_psinfo32_t psinfo
;
6668 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6670 elf_tdata (abfd
)->core_program
6671 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6672 sizeof (psinfo
.pr_fname
));
6674 elf_tdata (abfd
)->core_command
6675 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6676 sizeof (psinfo
.pr_psargs
));
6682 /* Fail - we don't know how to handle any other
6683 note size (ie. data object type). */
6687 /* Note that for some reason, a spurious space is tacked
6688 onto the end of the args in some (at least one anyway)
6689 implementations, so strip it off if it exists. */
6692 char *command
= elf_tdata (abfd
)->core_command
;
6693 int n
= strlen (command
);
6695 if (0 < n
&& command
[n
- 1] == ' ')
6696 command
[n
- 1] = '\0';
6701 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6703 #if defined (HAVE_PSTATUS_T)
6705 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6707 if (note
->descsz
== sizeof (pstatus_t
)
6708 #if defined (HAVE_PXSTATUS_T)
6709 || note
->descsz
== sizeof (pxstatus_t
)
6715 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6717 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6719 #if defined (HAVE_PSTATUS32_T)
6720 else if (note
->descsz
== sizeof (pstatus32_t
))
6722 /* 64-bit host, 32-bit corefile */
6725 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6727 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6730 /* Could grab some more details from the "representative"
6731 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6732 NT_LWPSTATUS note, presumably. */
6736 #endif /* defined (HAVE_PSTATUS_T) */
6738 #if defined (HAVE_LWPSTATUS_T)
6740 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6742 lwpstatus_t lwpstat
;
6748 if (note
->descsz
!= sizeof (lwpstat
)
6749 #if defined (HAVE_LWPXSTATUS_T)
6750 && note
->descsz
!= sizeof (lwpxstatus_t
)
6755 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6757 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6758 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6760 /* Make a ".reg/999" section. */
6762 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6763 len
= strlen (buf
) + 1;
6764 name
= bfd_alloc (abfd
, len
);
6767 memcpy (name
, buf
, len
);
6769 sect
= bfd_make_section_anyway (abfd
, name
);
6773 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6774 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6775 sect
->filepos
= note
->descpos
6776 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6779 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6780 sect
->size
= sizeof (lwpstat
.pr_reg
);
6781 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6784 sect
->flags
= SEC_HAS_CONTENTS
;
6785 sect
->alignment_power
= 2;
6787 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6790 /* Make a ".reg2/999" section */
6792 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6793 len
= strlen (buf
) + 1;
6794 name
= bfd_alloc (abfd
, len
);
6797 memcpy (name
, buf
, len
);
6799 sect
= bfd_make_section_anyway (abfd
, name
);
6803 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6804 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6805 sect
->filepos
= note
->descpos
6806 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6809 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6810 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
6811 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6814 sect
->flags
= SEC_HAS_CONTENTS
;
6815 sect
->alignment_power
= 2;
6817 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6819 #endif /* defined (HAVE_LWPSTATUS_T) */
6821 #if defined (HAVE_WIN32_PSTATUS_T)
6823 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6829 win32_pstatus_t pstatus
;
6831 if (note
->descsz
< sizeof (pstatus
))
6834 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6836 switch (pstatus
.data_type
)
6838 case NOTE_INFO_PROCESS
:
6839 /* FIXME: need to add ->core_command. */
6840 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6841 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6844 case NOTE_INFO_THREAD
:
6845 /* Make a ".reg/999" section. */
6846 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6848 len
= strlen (buf
) + 1;
6849 name
= bfd_alloc (abfd
, len
);
6853 memcpy (name
, buf
, len
);
6855 sect
= bfd_make_section_anyway (abfd
, name
);
6859 sect
->size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6860 sect
->filepos
= (note
->descpos
6861 + offsetof (struct win32_pstatus
,
6862 data
.thread_info
.thread_context
));
6863 sect
->flags
= SEC_HAS_CONTENTS
;
6864 sect
->alignment_power
= 2;
6866 if (pstatus
.data
.thread_info
.is_active_thread
)
6867 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6871 case NOTE_INFO_MODULE
:
6872 /* Make a ".module/xxxxxxxx" section. */
6873 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6875 len
= strlen (buf
) + 1;
6876 name
= bfd_alloc (abfd
, len
);
6880 memcpy (name
, buf
, len
);
6882 sect
= bfd_make_section_anyway (abfd
, name
);
6887 sect
->size
= note
->descsz
;
6888 sect
->filepos
= note
->descpos
;
6889 sect
->flags
= SEC_HAS_CONTENTS
;
6890 sect
->alignment_power
= 2;
6899 #endif /* HAVE_WIN32_PSTATUS_T */
6902 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
6904 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6912 if (bed
->elf_backend_grok_prstatus
)
6913 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6915 #if defined (HAVE_PRSTATUS_T)
6916 return elfcore_grok_prstatus (abfd
, note
);
6921 #if defined (HAVE_PSTATUS_T)
6923 return elfcore_grok_pstatus (abfd
, note
);
6926 #if defined (HAVE_LWPSTATUS_T)
6928 return elfcore_grok_lwpstatus (abfd
, note
);
6931 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6932 return elfcore_grok_prfpreg (abfd
, note
);
6934 #if defined (HAVE_WIN32_PSTATUS_T)
6935 case NT_WIN32PSTATUS
:
6936 return elfcore_grok_win32pstatus (abfd
, note
);
6939 case NT_PRXFPREG
: /* Linux SSE extension */
6940 if (note
->namesz
== 6
6941 && strcmp (note
->namedata
, "LINUX") == 0)
6942 return elfcore_grok_prxfpreg (abfd
, note
);
6948 if (bed
->elf_backend_grok_psinfo
)
6949 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6951 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6952 return elfcore_grok_psinfo (abfd
, note
);
6959 asection
*sect
= bfd_make_section_anyway (abfd
, ".auxv");
6963 sect
->size
= note
->descsz
;
6964 sect
->filepos
= note
->descpos
;
6965 sect
->flags
= SEC_HAS_CONTENTS
;
6966 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
6974 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
6978 cp
= strchr (note
->namedata
, '@');
6981 *lwpidp
= atoi(cp
+ 1);
6988 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6991 /* Signal number at offset 0x08. */
6992 elf_tdata (abfd
)->core_signal
6993 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
6995 /* Process ID at offset 0x50. */
6996 elf_tdata (abfd
)->core_pid
6997 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
6999 /* Command name at 0x7c (max 32 bytes, including nul). */
7000 elf_tdata (abfd
)->core_command
7001 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
7003 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
7008 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7012 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
7013 elf_tdata (abfd
)->core_lwpid
= lwp
;
7015 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
7017 /* NetBSD-specific core "procinfo". Note that we expect to
7018 find this note before any of the others, which is fine,
7019 since the kernel writes this note out first when it
7020 creates a core file. */
7022 return elfcore_grok_netbsd_procinfo (abfd
, note
);
7025 /* As of Jan 2002 there are no other machine-independent notes
7026 defined for NetBSD core files. If the note type is less
7027 than the start of the machine-dependent note types, we don't
7030 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
7034 switch (bfd_get_arch (abfd
))
7036 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7037 PT_GETFPREGS == mach+2. */
7039 case bfd_arch_alpha
:
7040 case bfd_arch_sparc
:
7043 case NT_NETBSDCORE_FIRSTMACH
+0:
7044 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7046 case NT_NETBSDCORE_FIRSTMACH
+2:
7047 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7053 /* On all other arch's, PT_GETREGS == mach+1 and
7054 PT_GETFPREGS == mach+3. */
7059 case NT_NETBSDCORE_FIRSTMACH
+1:
7060 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7062 case NT_NETBSDCORE_FIRSTMACH
+3:
7063 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7073 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t
*tid
)
7075 void *ddata
= note
->descdata
;
7082 /* nto_procfs_status 'pid' field is at offset 0. */
7083 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
7085 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7086 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
7088 /* nto_procfs_status 'flags' field is at offset 8. */
7089 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
7091 /* nto_procfs_status 'what' field is at offset 14. */
7092 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
7094 elf_tdata (abfd
)->core_signal
= sig
;
7095 elf_tdata (abfd
)->core_lwpid
= *tid
;
7098 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7099 do not come from signals so we make sure we set the current
7100 thread just in case. */
7101 if (flags
& 0x00000080)
7102 elf_tdata (abfd
)->core_lwpid
= *tid
;
7104 /* Make a ".qnx_core_status/%d" section. */
7105 sprintf (buf
, ".qnx_core_status/%d", *tid
);
7107 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7112 sect
= bfd_make_section_anyway (abfd
, name
);
7116 sect
->size
= note
->descsz
;
7117 sect
->filepos
= note
->descpos
;
7118 sect
->flags
= SEC_HAS_CONTENTS
;
7119 sect
->alignment_power
= 2;
7121 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
7125 elfcore_grok_nto_gregs (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t tid
)
7131 /* Make a ".reg/%d" section. */
7132 sprintf (buf
, ".reg/%d", tid
);
7134 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7139 sect
= bfd_make_section_anyway (abfd
, name
);
7143 sect
->size
= note
->descsz
;
7144 sect
->filepos
= note
->descpos
;
7145 sect
->flags
= SEC_HAS_CONTENTS
;
7146 sect
->alignment_power
= 2;
7148 /* This is the current thread. */
7149 if (elf_tdata (abfd
)->core_lwpid
== tid
)
7150 return elfcore_maybe_make_sect (abfd
, ".reg", sect
);
7155 #define BFD_QNT_CORE_INFO 7
7156 #define BFD_QNT_CORE_STATUS 8
7157 #define BFD_QNT_CORE_GREG 9
7158 #define BFD_QNT_CORE_FPREG 10
7161 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7163 /* Every GREG section has a STATUS section before it. Store the
7164 tid from the previous call to pass down to the next gregs
7166 static pid_t tid
= 1;
7170 case BFD_QNT_CORE_INFO
: return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
7171 case BFD_QNT_CORE_STATUS
: return elfcore_grok_nto_status (abfd
, note
, &tid
);
7172 case BFD_QNT_CORE_GREG
: return elfcore_grok_nto_gregs (abfd
, note
, tid
);
7173 case BFD_QNT_CORE_FPREG
: return elfcore_grok_prfpreg (abfd
, note
);
7174 default: return TRUE
;
7178 /* Function: elfcore_write_note
7185 size of data for note
7188 End of buffer containing note. */
7191 elfcore_write_note (bfd
*abfd
,
7199 Elf_External_Note
*xnp
;
7209 const struct elf_backend_data
*bed
;
7211 namesz
= strlen (name
) + 1;
7212 bed
= get_elf_backend_data (abfd
);
7213 pad
= -namesz
& ((1 << bed
->s
->log_file_align
) - 1);
7216 newspace
= 12 + namesz
+ pad
+ size
;
7218 p
= realloc (buf
, *bufsiz
+ newspace
);
7220 *bufsiz
+= newspace
;
7221 xnp
= (Elf_External_Note
*) dest
;
7222 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
7223 H_PUT_32 (abfd
, size
, xnp
->descsz
);
7224 H_PUT_32 (abfd
, type
, xnp
->type
);
7228 memcpy (dest
, name
, namesz
);
7236 memcpy (dest
, input
, size
);
7240 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7242 elfcore_write_prpsinfo (bfd
*abfd
,
7249 char *note_name
= "CORE";
7251 #if defined (HAVE_PSINFO_T)
7253 note_type
= NT_PSINFO
;
7256 note_type
= NT_PRPSINFO
;
7259 memset (&data
, 0, sizeof (data
));
7260 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
7261 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
7262 return elfcore_write_note (abfd
, buf
, bufsiz
,
7263 note_name
, note_type
, &data
, sizeof (data
));
7265 #endif /* PSINFO_T or PRPSINFO_T */
7267 #if defined (HAVE_PRSTATUS_T)
7269 elfcore_write_prstatus (bfd
*abfd
,
7277 char *note_name
= "CORE";
7279 memset (&prstat
, 0, sizeof (prstat
));
7280 prstat
.pr_pid
= pid
;
7281 prstat
.pr_cursig
= cursig
;
7282 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
7283 return elfcore_write_note (abfd
, buf
, bufsiz
,
7284 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
7286 #endif /* HAVE_PRSTATUS_T */
7288 #if defined (HAVE_LWPSTATUS_T)
7290 elfcore_write_lwpstatus (bfd
*abfd
,
7297 lwpstatus_t lwpstat
;
7298 char *note_name
= "CORE";
7300 memset (&lwpstat
, 0, sizeof (lwpstat
));
7301 lwpstat
.pr_lwpid
= pid
>> 16;
7302 lwpstat
.pr_cursig
= cursig
;
7303 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7304 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
7305 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7307 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
7308 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
7310 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
7311 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
7314 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7315 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
7317 #endif /* HAVE_LWPSTATUS_T */
7319 #if defined (HAVE_PSTATUS_T)
7321 elfcore_write_pstatus (bfd
*abfd
,
7329 char *note_name
= "CORE";
7331 memset (&pstat
, 0, sizeof (pstat
));
7332 pstat
.pr_pid
= pid
& 0xffff;
7333 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7334 NT_PSTATUS
, &pstat
, sizeof (pstat
));
7337 #endif /* HAVE_PSTATUS_T */
7340 elfcore_write_prfpreg (bfd
*abfd
,
7346 char *note_name
= "CORE";
7347 return elfcore_write_note (abfd
, buf
, bufsiz
,
7348 note_name
, NT_FPREGSET
, fpregs
, size
);
7352 elfcore_write_prxfpreg (bfd
*abfd
,
7355 const void *xfpregs
,
7358 char *note_name
= "LINUX";
7359 return elfcore_write_note (abfd
, buf
, bufsiz
,
7360 note_name
, NT_PRXFPREG
, xfpregs
, size
);
7364 elfcore_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
7372 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
7375 buf
= bfd_malloc (size
);
7379 if (bfd_bread (buf
, size
, abfd
) != size
)
7387 while (p
< buf
+ size
)
7389 /* FIXME: bad alignment assumption. */
7390 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
7391 Elf_Internal_Note in
;
7393 in
.type
= H_GET_32 (abfd
, xnp
->type
);
7395 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
7396 in
.namedata
= xnp
->name
;
7398 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
7399 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
7400 in
.descpos
= offset
+ (in
.descdata
- buf
);
7402 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
7404 if (! elfcore_grok_netbsd_note (abfd
, &in
))
7407 else if (strncmp (in
.namedata
, "QNX", 3) == 0)
7409 if (! elfcore_grok_nto_note (abfd
, &in
))
7414 if (! elfcore_grok_note (abfd
, &in
))
7418 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
7425 /* Providing external access to the ELF program header table. */
7427 /* Return an upper bound on the number of bytes required to store a
7428 copy of ABFD's program header table entries. Return -1 if an error
7429 occurs; bfd_get_error will return an appropriate code. */
7432 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
7434 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7436 bfd_set_error (bfd_error_wrong_format
);
7440 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
7443 /* Copy ABFD's program header table entries to *PHDRS. The entries
7444 will be stored as an array of Elf_Internal_Phdr structures, as
7445 defined in include/elf/internal.h. To find out how large the
7446 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7448 Return the number of program header table entries read, or -1 if an
7449 error occurs; bfd_get_error will return an appropriate code. */
7452 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
7456 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7458 bfd_set_error (bfd_error_wrong_format
);
7462 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
7463 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
7464 num_phdrs
* sizeof (Elf_Internal_Phdr
));
7470 _bfd_elf_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
7473 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7475 i_ehdrp
= elf_elfheader (abfd
);
7476 if (i_ehdrp
== NULL
)
7477 sprintf_vma (buf
, value
);
7480 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7482 #if BFD_HOST_64BIT_LONG
7483 sprintf (buf
, "%016lx", value
);
7485 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
7486 _bfd_int64_low (value
));
7490 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
7493 sprintf_vma (buf
, value
);
7498 _bfd_elf_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
7501 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7503 i_ehdrp
= elf_elfheader (abfd
);
7504 if (i_ehdrp
== NULL
)
7505 fprintf_vma ((FILE *) stream
, value
);
7508 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7510 #if BFD_HOST_64BIT_LONG
7511 fprintf ((FILE *) stream
, "%016lx", value
);
7513 fprintf ((FILE *) stream
, "%08lx%08lx",
7514 _bfd_int64_high (value
), _bfd_int64_low (value
));
7518 fprintf ((FILE *) stream
, "%08lx",
7519 (unsigned long) (value
& 0xffffffff));
7522 fprintf_vma ((FILE *) stream
, value
);
7526 enum elf_reloc_type_class
7527 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
7529 return reloc_class_normal
;
7532 /* For RELA architectures, return the relocation value for a
7533 relocation against a local symbol. */
7536 _bfd_elf_rela_local_sym (bfd
*abfd
,
7537 Elf_Internal_Sym
*sym
,
7539 Elf_Internal_Rela
*rel
)
7541 asection
*sec
= *psec
;
7544 relocation
= (sec
->output_section
->vma
7545 + sec
->output_offset
7547 if ((sec
->flags
& SEC_MERGE
)
7548 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
7549 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
7552 _bfd_merged_section_offset (abfd
, psec
,
7553 elf_section_data (sec
)->sec_info
,
7554 sym
->st_value
+ rel
->r_addend
);
7557 /* If we have changed the section, and our original section is
7558 marked with SEC_EXCLUDE, it means that the original
7559 SEC_MERGE section has been completely subsumed in some
7560 other SEC_MERGE section. In this case, we need to leave
7561 some info around for --emit-relocs. */
7562 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
7563 sec
->kept_section
= *psec
;
7566 rel
->r_addend
-= relocation
;
7567 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
7573 _bfd_elf_rel_local_sym (bfd
*abfd
,
7574 Elf_Internal_Sym
*sym
,
7578 asection
*sec
= *psec
;
7580 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
7581 return sym
->st_value
+ addend
;
7583 return _bfd_merged_section_offset (abfd
, psec
,
7584 elf_section_data (sec
)->sec_info
,
7585 sym
->st_value
+ addend
);
7589 _bfd_elf_section_offset (bfd
*abfd
,
7590 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7594 switch (sec
->sec_info_type
)
7596 case ELF_INFO_TYPE_STABS
:
7597 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
7599 case ELF_INFO_TYPE_EH_FRAME
:
7600 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);
7606 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
7607 reconstruct an ELF file by reading the segments out of remote memory
7608 based on the ELF file header at EHDR_VMA and the ELF program headers it
7609 points to. If not null, *LOADBASEP is filled in with the difference
7610 between the VMAs from which the segments were read, and the VMAs the
7611 file headers (and hence BFD's idea of each section's VMA) put them at.
7613 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7614 remote memory at target address VMA into the local buffer at MYADDR; it
7615 should return zero on success or an `errno' code on failure. TEMPL must
7616 be a BFD for an ELF target with the word size and byte order found in
7617 the remote memory. */
7620 bfd_elf_bfd_from_remote_memory
7624 int (*target_read_memory
) (bfd_vma
, char *, int))
7626 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
7627 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
7631 _bfd_elf_get_synthetic_symtab (bfd
*abfd
, asymbol
**dynsyms
, asymbol
**ret
)
7633 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7636 const char *relplt_name
;
7637 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
7641 Elf_Internal_Shdr
*hdr
;
7646 if (!bed
->plt_sym_val
)
7649 relplt_name
= bed
->relplt_name
;
7650 if (relplt_name
== NULL
)
7651 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
7652 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
7656 hdr
= &elf_section_data (relplt
)->this_hdr
;
7657 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
7658 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
7661 plt
= bfd_get_section_by_name (abfd
, ".plt");
7665 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
7666 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
7669 count
= relplt
->size
/ hdr
->sh_entsize
;
7670 size
= count
* sizeof (asymbol
);
7671 p
= relplt
->relocation
;
7672 for (i
= 0; i
< count
; i
++, s
++, p
++)
7673 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
7675 s
= *ret
= bfd_malloc (size
);
7679 names
= (char *) (s
+ count
);
7680 p
= relplt
->relocation
;
7682 for (i
= 0; i
< count
; i
++, s
++, p
++)
7687 addr
= bed
->plt_sym_val (i
, plt
, p
);
7688 if (addr
== (bfd_vma
) -1)
7691 *s
= **p
->sym_ptr_ptr
;
7693 s
->value
= addr
- plt
->vma
;
7695 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
7696 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
7698 memcpy (names
, "@plt", sizeof ("@plt"));
7699 names
+= sizeof ("@plt");