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
,
3829 /* Make sure the .dynamic section is the first section in the
3830 PT_DYNAMIC segment. */
3831 else if (p
->p_type
== PT_DYNAMIC
3833 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
3836 (_("%s: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
3837 bfd_get_filename (abfd
));
3838 bfd_set_error (bfd_error_bad_value
);
3845 p
->p_vaddr
= m
->sections
[0]->vma
;
3847 if (m
->p_paddr_valid
)
3848 p
->p_paddr
= m
->p_paddr
;
3849 else if (m
->count
== 0)
3852 p
->p_paddr
= m
->sections
[0]->lma
;
3854 if (p
->p_type
== PT_LOAD
3855 && (abfd
->flags
& D_PAGED
) != 0)
3856 p
->p_align
= bed
->maxpagesize
;
3857 else if (m
->count
== 0)
3858 p
->p_align
= 1 << bed
->s
->log_file_align
;
3866 if (m
->includes_filehdr
)
3868 if (! m
->p_flags_valid
)
3871 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
3872 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
3875 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3877 if (p
->p_vaddr
< (bfd_vma
) off
)
3879 (*_bfd_error_handler
)
3880 (_("%s: Not enough room for program headers, try linking with -N"),
3881 bfd_get_filename (abfd
));
3882 bfd_set_error (bfd_error_bad_value
);
3887 if (! m
->p_paddr_valid
)
3890 if (p
->p_type
== PT_LOAD
)
3892 filehdr_vaddr
= p
->p_vaddr
;
3893 filehdr_paddr
= p
->p_paddr
;
3897 if (m
->includes_phdrs
)
3899 if (! m
->p_flags_valid
)
3902 if (m
->includes_filehdr
)
3904 if (p
->p_type
== PT_LOAD
)
3906 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
3907 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
3912 p
->p_offset
= bed
->s
->sizeof_ehdr
;
3916 BFD_ASSERT (p
->p_type
== PT_LOAD
);
3917 p
->p_vaddr
-= off
- p
->p_offset
;
3918 if (! m
->p_paddr_valid
)
3919 p
->p_paddr
-= off
- p
->p_offset
;
3922 if (p
->p_type
== PT_LOAD
)
3924 phdrs_vaddr
= p
->p_vaddr
;
3925 phdrs_paddr
= p
->p_paddr
;
3928 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
3931 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
3932 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
3935 if (p
->p_type
== PT_LOAD
3936 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
3938 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
3944 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
3945 p
->p_filesz
+= adjust
;
3946 p
->p_memsz
+= adjust
;
3952 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
3956 bfd_size_type align
;
3960 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
3962 /* The section may have artificial alignment forced by a
3963 link script. Notice this case by the gap between the
3964 cumulative phdr lma and the section's lma. */
3965 if (p
->p_paddr
+ p
->p_memsz
< sec
->lma
)
3967 bfd_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3969 p
->p_memsz
+= adjust
;
3970 if (p
->p_type
== PT_LOAD
3971 || (p
->p_type
== PT_NOTE
3972 && bfd_get_format (abfd
) == bfd_core
))
3977 if ((flags
& SEC_LOAD
) != 0
3978 || (flags
& SEC_THREAD_LOCAL
) != 0)
3979 p
->p_filesz
+= adjust
;
3982 if (p
->p_type
== PT_LOAD
)
3984 bfd_signed_vma adjust
;
3986 if ((flags
& SEC_LOAD
) != 0)
3988 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
3992 else if ((flags
& SEC_ALLOC
) != 0)
3994 /* The section VMA must equal the file position
3995 modulo the page size. FIXME: I'm not sure if
3996 this adjustment is really necessary. We used to
3997 not have the SEC_LOAD case just above, and then
3998 this was necessary, but now I'm not sure. */
3999 if ((abfd
->flags
& D_PAGED
) != 0)
4000 adjust
= vma_page_aligned_bias (sec
->vma
, voff
,
4003 adjust
= vma_page_aligned_bias (sec
->vma
, voff
,
4013 (* _bfd_error_handler
) (_("\
4014 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
4015 bfd_section_name (abfd
, sec
),
4020 p
->p_memsz
+= adjust
;
4023 if ((flags
& SEC_LOAD
) != 0)
4024 p
->p_filesz
+= adjust
;
4029 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
4030 used in a linker script we may have a section with
4031 SEC_LOAD clear but which is supposed to have
4033 if ((flags
& SEC_LOAD
) != 0
4034 || (flags
& SEC_HAS_CONTENTS
) != 0)
4037 if ((flags
& SEC_ALLOC
) != 0
4038 && ((flags
& SEC_LOAD
) != 0
4039 || (flags
& SEC_THREAD_LOCAL
) == 0))
4043 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4045 /* The actual "note" segment has i == 0.
4046 This is the one that actually contains everything. */
4050 p
->p_filesz
= sec
->size
;
4056 /* Fake sections -- don't need to be written. */
4059 flags
= sec
->flags
= 0;
4066 if ((sec
->flags
& SEC_LOAD
) != 0
4067 || (sec
->flags
& SEC_THREAD_LOCAL
) == 0
4068 || p
->p_type
== PT_TLS
)
4069 p
->p_memsz
+= sec
->size
;
4071 if ((flags
& SEC_LOAD
) != 0)
4072 p
->p_filesz
+= sec
->size
;
4074 if (p
->p_type
== PT_TLS
4076 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
4078 struct bfd_link_order
*o
;
4079 bfd_vma tbss_size
= 0;
4081 for (o
= sec
->link_order_head
; o
!= NULL
; o
= o
->next
)
4082 if (tbss_size
< o
->offset
+ o
->size
)
4083 tbss_size
= o
->offset
+ o
->size
;
4085 p
->p_memsz
+= tbss_size
;
4088 if (align
> p
->p_align
4089 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
4093 if (! m
->p_flags_valid
)
4096 if ((flags
& SEC_CODE
) != 0)
4098 if ((flags
& SEC_READONLY
) == 0)
4104 /* Now that we have set the section file positions, we can set up
4105 the file positions for the non PT_LOAD segments. */
4106 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4110 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
4112 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
4113 p
->p_offset
= m
->sections
[0]->filepos
;
4117 if (m
->includes_filehdr
)
4119 p
->p_vaddr
= filehdr_vaddr
;
4120 if (! m
->p_paddr_valid
)
4121 p
->p_paddr
= filehdr_paddr
;
4123 else if (m
->includes_phdrs
)
4125 p
->p_vaddr
= phdrs_vaddr
;
4126 if (! m
->p_paddr_valid
)
4127 p
->p_paddr
= phdrs_paddr
;
4129 else if (p
->p_type
== PT_GNU_RELRO
)
4131 Elf_Internal_Phdr
*lp
;
4133 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4135 if (lp
->p_type
== PT_LOAD
4136 && lp
->p_vaddr
<= link_info
->relro_end
4137 && lp
->p_vaddr
>= link_info
->relro_start
4138 && lp
->p_vaddr
+ lp
->p_filesz
4139 >= link_info
->relro_end
)
4143 if (lp
< phdrs
+ count
4144 && link_info
->relro_end
> lp
->p_vaddr
)
4146 p
->p_vaddr
= lp
->p_vaddr
;
4147 p
->p_paddr
= lp
->p_paddr
;
4148 p
->p_offset
= lp
->p_offset
;
4149 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4150 p
->p_memsz
= p
->p_filesz
;
4152 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4156 memset (p
, 0, sizeof *p
);
4157 p
->p_type
= PT_NULL
;
4163 /* Clear out any program headers we allocated but did not use. */
4164 for (; count
< alloc
; count
++, p
++)
4166 memset (p
, 0, sizeof *p
);
4167 p
->p_type
= PT_NULL
;
4170 elf_tdata (abfd
)->phdr
= phdrs
;
4172 elf_tdata (abfd
)->next_file_pos
= off
;
4174 /* Write out the program headers. */
4175 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4176 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
4182 /* Get the size of the program header.
4184 If this is called by the linker before any of the section VMA's are set, it
4185 can't calculate the correct value for a strange memory layout. This only
4186 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4187 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4188 data segment (exclusive of .interp and .dynamic).
4190 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4191 will be two segments. */
4193 static bfd_size_type
4194 get_program_header_size (bfd
*abfd
)
4198 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4200 /* We can't return a different result each time we're called. */
4201 if (elf_tdata (abfd
)->program_header_size
!= 0)
4202 return elf_tdata (abfd
)->program_header_size
;
4204 if (elf_tdata (abfd
)->segment_map
!= NULL
)
4206 struct elf_segment_map
*m
;
4209 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4211 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4212 return elf_tdata (abfd
)->program_header_size
;
4215 /* Assume we will need exactly two PT_LOAD segments: one for text
4216 and one for data. */
4219 s
= bfd_get_section_by_name (abfd
, ".interp");
4220 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4222 /* If we have a loadable interpreter section, we need a
4223 PT_INTERP segment. In this case, assume we also need a
4224 PT_PHDR segment, although that may not be true for all
4229 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4231 /* We need a PT_DYNAMIC segment. */
4235 if (elf_tdata (abfd
)->eh_frame_hdr
)
4237 /* We need a PT_GNU_EH_FRAME segment. */
4241 if (elf_tdata (abfd
)->stack_flags
)
4243 /* We need a PT_GNU_STACK segment. */
4247 if (elf_tdata (abfd
)->relro
)
4249 /* We need a PT_GNU_RELRO segment. */
4253 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4255 if ((s
->flags
& SEC_LOAD
) != 0
4256 && strncmp (s
->name
, ".note", 5) == 0)
4258 /* We need a PT_NOTE segment. */
4263 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4265 if (s
->flags
& SEC_THREAD_LOCAL
)
4267 /* We need a PT_TLS segment. */
4273 /* Let the backend count up any program headers it might need. */
4274 if (bed
->elf_backend_additional_program_headers
)
4278 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
4284 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4285 return elf_tdata (abfd
)->program_header_size
;
4288 /* Work out the file positions of all the sections. This is called by
4289 _bfd_elf_compute_section_file_positions. All the section sizes and
4290 VMAs must be known before this is called.
4292 We do not consider reloc sections at this point, unless they form
4293 part of the loadable image. Reloc sections are assigned file
4294 positions in assign_file_positions_for_relocs, which is called by
4295 write_object_contents and final_link.
4297 We also don't set the positions of the .symtab and .strtab here. */
4300 assign_file_positions_except_relocs (bfd
*abfd
,
4301 struct bfd_link_info
*link_info
)
4303 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
4304 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
4305 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4306 unsigned int num_sec
= elf_numsections (abfd
);
4308 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4310 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4311 && bfd_get_format (abfd
) != bfd_core
)
4313 Elf_Internal_Shdr
**hdrpp
;
4316 /* Start after the ELF header. */
4317 off
= i_ehdrp
->e_ehsize
;
4319 /* We are not creating an executable, which means that we are
4320 not creating a program header, and that the actual order of
4321 the sections in the file is unimportant. */
4322 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4324 Elf_Internal_Shdr
*hdr
;
4327 if (hdr
->sh_type
== SHT_REL
4328 || hdr
->sh_type
== SHT_RELA
4329 || i
== tdata
->symtab_section
4330 || i
== tdata
->symtab_shndx_section
4331 || i
== tdata
->strtab_section
)
4333 hdr
->sh_offset
= -1;
4336 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4338 if (i
== SHN_LORESERVE
- 1)
4340 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4341 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4348 Elf_Internal_Shdr
**hdrpp
;
4350 /* Assign file positions for the loaded sections based on the
4351 assignment of sections to segments. */
4352 if (! assign_file_positions_for_segments (abfd
, link_info
))
4355 /* Assign file positions for the other sections. */
4357 off
= elf_tdata (abfd
)->next_file_pos
;
4358 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4360 Elf_Internal_Shdr
*hdr
;
4363 if (hdr
->bfd_section
!= NULL
4364 && hdr
->bfd_section
->filepos
!= 0)
4365 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
4366 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4368 ((*_bfd_error_handler
)
4369 (_("%s: warning: allocated section `%s' not in segment"),
4370 bfd_get_filename (abfd
),
4371 (hdr
->bfd_section
== NULL
4373 : hdr
->bfd_section
->name
)));
4374 if ((abfd
->flags
& D_PAGED
) != 0)
4375 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4378 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4380 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4383 else if (hdr
->sh_type
== SHT_REL
4384 || hdr
->sh_type
== SHT_RELA
4385 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4386 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4387 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4388 hdr
->sh_offset
= -1;
4390 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4392 if (i
== SHN_LORESERVE
- 1)
4394 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4395 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4400 /* Place the section headers. */
4401 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4402 i_ehdrp
->e_shoff
= off
;
4403 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4405 elf_tdata (abfd
)->next_file_pos
= off
;
4411 prep_headers (bfd
*abfd
)
4413 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4414 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4415 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4416 struct elf_strtab_hash
*shstrtab
;
4417 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4419 i_ehdrp
= elf_elfheader (abfd
);
4420 i_shdrp
= elf_elfsections (abfd
);
4422 shstrtab
= _bfd_elf_strtab_init ();
4423 if (shstrtab
== NULL
)
4426 elf_shstrtab (abfd
) = shstrtab
;
4428 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4429 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4430 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4431 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4433 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4434 i_ehdrp
->e_ident
[EI_DATA
] =
4435 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4436 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4438 if ((abfd
->flags
& DYNAMIC
) != 0)
4439 i_ehdrp
->e_type
= ET_DYN
;
4440 else if ((abfd
->flags
& EXEC_P
) != 0)
4441 i_ehdrp
->e_type
= ET_EXEC
;
4442 else if (bfd_get_format (abfd
) == bfd_core
)
4443 i_ehdrp
->e_type
= ET_CORE
;
4445 i_ehdrp
->e_type
= ET_REL
;
4447 switch (bfd_get_arch (abfd
))
4449 case bfd_arch_unknown
:
4450 i_ehdrp
->e_machine
= EM_NONE
;
4453 /* There used to be a long list of cases here, each one setting
4454 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4455 in the corresponding bfd definition. To avoid duplication,
4456 the switch was removed. Machines that need special handling
4457 can generally do it in elf_backend_final_write_processing(),
4458 unless they need the information earlier than the final write.
4459 Such need can generally be supplied by replacing the tests for
4460 e_machine with the conditions used to determine it. */
4462 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4465 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4466 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4468 /* No program header, for now. */
4469 i_ehdrp
->e_phoff
= 0;
4470 i_ehdrp
->e_phentsize
= 0;
4471 i_ehdrp
->e_phnum
= 0;
4473 /* Each bfd section is section header entry. */
4474 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4475 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4477 /* If we're building an executable, we'll need a program header table. */
4478 if (abfd
->flags
& EXEC_P
)
4480 /* It all happens later. */
4482 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
4484 /* elf_build_phdrs() returns a (NULL-terminated) array of
4485 Elf_Internal_Phdrs. */
4486 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
4487 i_ehdrp
->e_phoff
= outbase
;
4488 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
4493 i_ehdrp
->e_phentsize
= 0;
4495 i_ehdrp
->e_phoff
= 0;
4498 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4499 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4500 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4501 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4502 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4503 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4504 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4505 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4506 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4512 /* Assign file positions for all the reloc sections which are not part
4513 of the loadable file image. */
4516 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4519 unsigned int i
, num_sec
;
4520 Elf_Internal_Shdr
**shdrpp
;
4522 off
= elf_tdata (abfd
)->next_file_pos
;
4524 num_sec
= elf_numsections (abfd
);
4525 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4527 Elf_Internal_Shdr
*shdrp
;
4530 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4531 && shdrp
->sh_offset
== -1)
4532 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4535 elf_tdata (abfd
)->next_file_pos
= off
;
4539 _bfd_elf_write_object_contents (bfd
*abfd
)
4541 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4542 Elf_Internal_Ehdr
*i_ehdrp
;
4543 Elf_Internal_Shdr
**i_shdrp
;
4545 unsigned int count
, num_sec
;
4547 if (! abfd
->output_has_begun
4548 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4551 i_shdrp
= elf_elfsections (abfd
);
4552 i_ehdrp
= elf_elfheader (abfd
);
4555 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4559 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4561 /* After writing the headers, we need to write the sections too... */
4562 num_sec
= elf_numsections (abfd
);
4563 for (count
= 1; count
< num_sec
; count
++)
4565 if (bed
->elf_backend_section_processing
)
4566 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4567 if (i_shdrp
[count
]->contents
)
4569 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4571 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4572 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4575 if (count
== SHN_LORESERVE
- 1)
4576 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4579 /* Write out the section header names. */
4580 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4581 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
)))
4584 if (bed
->elf_backend_final_write_processing
)
4585 (*bed
->elf_backend_final_write_processing
) (abfd
,
4586 elf_tdata (abfd
)->linker
);
4588 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4592 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4594 /* Hopefully this can be done just like an object file. */
4595 return _bfd_elf_write_object_contents (abfd
);
4598 /* Given a section, search the header to find them. */
4601 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4603 const struct elf_backend_data
*bed
;
4606 if (elf_section_data (asect
) != NULL
4607 && elf_section_data (asect
)->this_idx
!= 0)
4608 return elf_section_data (asect
)->this_idx
;
4610 if (bfd_is_abs_section (asect
))
4612 else if (bfd_is_com_section (asect
))
4614 else if (bfd_is_und_section (asect
))
4618 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
4619 int maxindex
= elf_numsections (abfd
);
4621 for (index
= 1; index
< maxindex
; index
++)
4623 Elf_Internal_Shdr
*hdr
= i_shdrp
[index
];
4625 if (hdr
!= NULL
&& hdr
->bfd_section
== asect
)
4631 bed
= get_elf_backend_data (abfd
);
4632 if (bed
->elf_backend_section_from_bfd_section
)
4636 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4641 bfd_set_error (bfd_error_nonrepresentable_section
);
4646 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4650 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
4652 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4654 flagword flags
= asym_ptr
->flags
;
4656 /* When gas creates relocations against local labels, it creates its
4657 own symbol for the section, but does put the symbol into the
4658 symbol chain, so udata is 0. When the linker is generating
4659 relocatable output, this section symbol may be for one of the
4660 input sections rather than the output section. */
4661 if (asym_ptr
->udata
.i
== 0
4662 && (flags
& BSF_SECTION_SYM
)
4663 && asym_ptr
->section
)
4667 if (asym_ptr
->section
->output_section
!= NULL
)
4668 indx
= asym_ptr
->section
->output_section
->index
;
4670 indx
= asym_ptr
->section
->index
;
4671 if (indx
< elf_num_section_syms (abfd
)
4672 && elf_section_syms (abfd
)[indx
] != NULL
)
4673 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4676 idx
= asym_ptr
->udata
.i
;
4680 /* This case can occur when using --strip-symbol on a symbol
4681 which is used in a relocation entry. */
4682 (*_bfd_error_handler
)
4683 (_("%s: symbol `%s' required but not present"),
4684 bfd_archive_filename (abfd
), bfd_asymbol_name (asym_ptr
));
4685 bfd_set_error (bfd_error_no_symbols
);
4692 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4693 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4694 elf_symbol_flags (flags
));
4702 /* Copy private BFD data. This copies any program header information. */
4705 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4707 Elf_Internal_Ehdr
*iehdr
;
4708 struct elf_segment_map
*map
;
4709 struct elf_segment_map
*map_first
;
4710 struct elf_segment_map
**pointer_to_map
;
4711 Elf_Internal_Phdr
*segment
;
4714 unsigned int num_segments
;
4715 bfd_boolean phdr_included
= FALSE
;
4716 bfd_vma maxpagesize
;
4717 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
4718 unsigned int phdr_adjust_num
= 0;
4719 const struct elf_backend_data
*bed
;
4721 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4722 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4725 if (elf_tdata (ibfd
)->phdr
== NULL
)
4728 bed
= get_elf_backend_data (ibfd
);
4729 iehdr
= elf_elfheader (ibfd
);
4732 pointer_to_map
= &map_first
;
4734 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
4735 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
4737 /* Returns the end address of the segment + 1. */
4738 #define SEGMENT_END(segment, start) \
4739 (start + (segment->p_memsz > segment->p_filesz \
4740 ? segment->p_memsz : segment->p_filesz))
4742 #define SECTION_SIZE(section, segment) \
4743 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4744 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
4745 ? section->size : 0)
4747 /* Returns TRUE if the given section is contained within
4748 the given segment. VMA addresses are compared. */
4749 #define IS_CONTAINED_BY_VMA(section, segment) \
4750 (section->vma >= segment->p_vaddr \
4751 && (section->vma + SECTION_SIZE (section, segment) \
4752 <= (SEGMENT_END (segment, segment->p_vaddr))))
4754 /* Returns TRUE if the given section is contained within
4755 the given segment. LMA addresses are compared. */
4756 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4757 (section->lma >= base \
4758 && (section->lma + SECTION_SIZE (section, segment) \
4759 <= SEGMENT_END (segment, base)))
4761 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4762 #define IS_COREFILE_NOTE(p, s) \
4763 (p->p_type == PT_NOTE \
4764 && bfd_get_format (ibfd) == bfd_core \
4765 && s->vma == 0 && s->lma == 0 \
4766 && (bfd_vma) s->filepos >= p->p_offset \
4767 && ((bfd_vma) s->filepos + s->size \
4768 <= p->p_offset + p->p_filesz))
4770 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4771 linker, which generates a PT_INTERP section with p_vaddr and
4772 p_memsz set to 0. */
4773 #define IS_SOLARIS_PT_INTERP(p, s) \
4775 && p->p_paddr == 0 \
4776 && p->p_memsz == 0 \
4777 && p->p_filesz > 0 \
4778 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4780 && (bfd_vma) s->filepos >= p->p_offset \
4781 && ((bfd_vma) s->filepos + s->size \
4782 <= p->p_offset + p->p_filesz))
4784 /* Decide if the given section should be included in the given segment.
4785 A section will be included if:
4786 1. It is within the address space of the segment -- we use the LMA
4787 if that is set for the segment and the VMA otherwise,
4788 2. It is an allocated segment,
4789 3. There is an output section associated with it,
4790 4. The section has not already been allocated to a previous segment.
4791 5. PT_GNU_STACK segments do not include any sections.
4792 6. PT_TLS segment includes only SHF_TLS sections.
4793 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
4794 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4795 ((((segment->p_paddr \
4796 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4797 : IS_CONTAINED_BY_VMA (section, segment)) \
4798 && (section->flags & SEC_ALLOC) != 0) \
4799 || IS_COREFILE_NOTE (segment, section)) \
4800 && section->output_section != NULL \
4801 && segment->p_type != PT_GNU_STACK \
4802 && (segment->p_type != PT_TLS \
4803 || (section->flags & SEC_THREAD_LOCAL)) \
4804 && (segment->p_type == PT_LOAD \
4805 || segment->p_type == PT_TLS \
4806 || (section->flags & SEC_THREAD_LOCAL) == 0) \
4807 && ! section->segment_mark)
4809 /* Returns TRUE iff seg1 starts after the end of seg2. */
4810 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
4811 (seg1->field >= SEGMENT_END (seg2, seg2->field))
4813 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4814 their VMA address ranges and their LMA address ranges overlap.
4815 It is possible to have overlapping VMA ranges without overlapping LMA
4816 ranges. RedBoot images for example can have both .data and .bss mapped
4817 to the same VMA range, but with the .data section mapped to a different
4819 #define SEGMENT_OVERLAPS(seg1, seg2) \
4820 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
4821 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
4822 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
4823 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
4825 /* Initialise the segment mark field. */
4826 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
4827 section
->segment_mark
= FALSE
;
4829 /* Scan through the segments specified in the program header
4830 of the input BFD. For this first scan we look for overlaps
4831 in the loadable segments. These can be created by weird
4832 parameters to objcopy. Also, fix some solaris weirdness. */
4833 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4838 Elf_Internal_Phdr
*segment2
;
4840 if (segment
->p_type
== PT_INTERP
)
4841 for (section
= ibfd
->sections
; section
; section
= section
->next
)
4842 if (IS_SOLARIS_PT_INTERP (segment
, section
))
4844 /* Mininal change so that the normal section to segment
4845 assignment code will work. */
4846 segment
->p_vaddr
= section
->vma
;
4850 if (segment
->p_type
!= PT_LOAD
)
4853 /* Determine if this segment overlaps any previous segments. */
4854 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
4856 bfd_signed_vma extra_length
;
4858 if (segment2
->p_type
!= PT_LOAD
4859 || ! SEGMENT_OVERLAPS (segment
, segment2
))
4862 /* Merge the two segments together. */
4863 if (segment2
->p_vaddr
< segment
->p_vaddr
)
4865 /* Extend SEGMENT2 to include SEGMENT and then delete
4868 SEGMENT_END (segment
, segment
->p_vaddr
)
4869 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
4871 if (extra_length
> 0)
4873 segment2
->p_memsz
+= extra_length
;
4874 segment2
->p_filesz
+= extra_length
;
4877 segment
->p_type
= PT_NULL
;
4879 /* Since we have deleted P we must restart the outer loop. */
4881 segment
= elf_tdata (ibfd
)->phdr
;
4886 /* Extend SEGMENT to include SEGMENT2 and then delete
4889 SEGMENT_END (segment2
, segment2
->p_vaddr
)
4890 - SEGMENT_END (segment
, segment
->p_vaddr
);
4892 if (extra_length
> 0)
4894 segment
->p_memsz
+= extra_length
;
4895 segment
->p_filesz
+= extra_length
;
4898 segment2
->p_type
= PT_NULL
;
4903 /* The second scan attempts to assign sections to segments. */
4904 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
4908 unsigned int section_count
;
4909 asection
** sections
;
4910 asection
* output_section
;
4912 bfd_vma matching_lma
;
4913 bfd_vma suggested_lma
;
4917 if (segment
->p_type
== PT_NULL
)
4920 /* Compute how many sections might be placed into this segment. */
4921 for (section
= ibfd
->sections
, section_count
= 0;
4923 section
= section
->next
)
4924 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
4927 /* Allocate a segment map big enough to contain
4928 all of the sections we have selected. */
4929 amt
= sizeof (struct elf_segment_map
);
4930 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
4931 map
= bfd_alloc (obfd
, amt
);
4935 /* Initialise the fields of the segment map. Default to
4936 using the physical address of the segment in the input BFD. */
4938 map
->p_type
= segment
->p_type
;
4939 map
->p_flags
= segment
->p_flags
;
4940 map
->p_flags_valid
= 1;
4941 map
->p_paddr
= segment
->p_paddr
;
4942 map
->p_paddr_valid
= 1;
4944 /* Determine if this segment contains the ELF file header
4945 and if it contains the program headers themselves. */
4946 map
->includes_filehdr
= (segment
->p_offset
== 0
4947 && segment
->p_filesz
>= iehdr
->e_ehsize
);
4949 map
->includes_phdrs
= 0;
4951 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
4953 map
->includes_phdrs
=
4954 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
4955 && (segment
->p_offset
+ segment
->p_filesz
4956 >= ((bfd_vma
) iehdr
->e_phoff
4957 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
4959 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
4960 phdr_included
= TRUE
;
4963 if (section_count
== 0)
4965 /* Special segments, such as the PT_PHDR segment, may contain
4966 no sections, but ordinary, loadable segments should contain
4967 something. They are allowed by the ELF spec however, so only
4968 a warning is produced. */
4969 if (segment
->p_type
== PT_LOAD
)
4970 (*_bfd_error_handler
)
4971 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4972 bfd_archive_filename (ibfd
));
4975 *pointer_to_map
= map
;
4976 pointer_to_map
= &map
->next
;
4981 /* Now scan the sections in the input BFD again and attempt
4982 to add their corresponding output sections to the segment map.
4983 The problem here is how to handle an output section which has
4984 been moved (ie had its LMA changed). There are four possibilities:
4986 1. None of the sections have been moved.
4987 In this case we can continue to use the segment LMA from the
4990 2. All of the sections have been moved by the same amount.
4991 In this case we can change the segment's LMA to match the LMA
4992 of the first section.
4994 3. Some of the sections have been moved, others have not.
4995 In this case those sections which have not been moved can be
4996 placed in the current segment which will have to have its size,
4997 and possibly its LMA changed, and a new segment or segments will
4998 have to be created to contain the other sections.
5000 4. The sections have been moved, but not by the same amount.
5001 In this case we can change the segment's LMA to match the LMA
5002 of the first section and we will have to create a new segment
5003 or segments to contain the other sections.
5005 In order to save time, we allocate an array to hold the section
5006 pointers that we are interested in. As these sections get assigned
5007 to a segment, they are removed from this array. */
5009 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5010 to work around this long long bug. */
5011 amt
= section_count
* sizeof (asection
*);
5012 sections
= bfd_malloc (amt
);
5013 if (sections
== NULL
)
5016 /* Step One: Scan for segment vs section LMA conflicts.
5017 Also add the sections to the section array allocated above.
5018 Also add the sections to the current segment. In the common
5019 case, where the sections have not been moved, this means that
5020 we have completely filled the segment, and there is nothing
5026 for (j
= 0, section
= ibfd
->sections
;
5028 section
= section
->next
)
5030 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5032 output_section
= section
->output_section
;
5034 sections
[j
++] = section
;
5036 /* The Solaris native linker always sets p_paddr to 0.
5037 We try to catch that case here, and set it to the
5038 correct value. Note - some backends require that
5039 p_paddr be left as zero. */
5040 if (segment
->p_paddr
== 0
5041 && segment
->p_vaddr
!= 0
5042 && (! bed
->want_p_paddr_set_to_zero
)
5044 && output_section
->lma
!= 0
5045 && (output_section
->vma
== (segment
->p_vaddr
5046 + (map
->includes_filehdr
5049 + (map
->includes_phdrs
5051 * iehdr
->e_phentsize
)
5053 map
->p_paddr
= segment
->p_vaddr
;
5055 /* Match up the physical address of the segment with the
5056 LMA address of the output section. */
5057 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5058 || IS_COREFILE_NOTE (segment
, section
)
5059 || (bed
->want_p_paddr_set_to_zero
&&
5060 IS_CONTAINED_BY_VMA (output_section
, segment
))
5063 if (matching_lma
== 0)
5064 matching_lma
= output_section
->lma
;
5066 /* We assume that if the section fits within the segment
5067 then it does not overlap any other section within that
5069 map
->sections
[isec
++] = output_section
;
5071 else if (suggested_lma
== 0)
5072 suggested_lma
= output_section
->lma
;
5076 BFD_ASSERT (j
== section_count
);
5078 /* Step Two: Adjust the physical address of the current segment,
5080 if (isec
== section_count
)
5082 /* All of the sections fitted within the segment as currently
5083 specified. This is the default case. Add the segment to
5084 the list of built segments and carry on to process the next
5085 program header in the input BFD. */
5086 map
->count
= section_count
;
5087 *pointer_to_map
= map
;
5088 pointer_to_map
= &map
->next
;
5095 if (matching_lma
!= 0)
5097 /* At least one section fits inside the current segment.
5098 Keep it, but modify its physical address to match the
5099 LMA of the first section that fitted. */
5100 map
->p_paddr
= matching_lma
;
5104 /* None of the sections fitted inside the current segment.
5105 Change the current segment's physical address to match
5106 the LMA of the first section. */
5107 map
->p_paddr
= suggested_lma
;
5110 /* Offset the segment physical address from the lma
5111 to allow for space taken up by elf headers. */
5112 if (map
->includes_filehdr
)
5113 map
->p_paddr
-= iehdr
->e_ehsize
;
5115 if (map
->includes_phdrs
)
5117 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5119 /* iehdr->e_phnum is just an estimate of the number
5120 of program headers that we will need. Make a note
5121 here of the number we used and the segment we chose
5122 to hold these headers, so that we can adjust the
5123 offset when we know the correct value. */
5124 phdr_adjust_num
= iehdr
->e_phnum
;
5125 phdr_adjust_seg
= map
;
5129 /* Step Three: Loop over the sections again, this time assigning
5130 those that fit to the current segment and removing them from the
5131 sections array; but making sure not to leave large gaps. Once all
5132 possible sections have been assigned to the current segment it is
5133 added to the list of built segments and if sections still remain
5134 to be assigned, a new segment is constructed before repeating
5142 /* Fill the current segment with sections that fit. */
5143 for (j
= 0; j
< section_count
; j
++)
5145 section
= sections
[j
];
5147 if (section
== NULL
)
5150 output_section
= section
->output_section
;
5152 BFD_ASSERT (output_section
!= NULL
);
5154 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5155 || IS_COREFILE_NOTE (segment
, section
))
5157 if (map
->count
== 0)
5159 /* If the first section in a segment does not start at
5160 the beginning of the segment, then something is
5162 if (output_section
->lma
!=
5164 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5165 + (map
->includes_phdrs
5166 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5172 asection
* prev_sec
;
5174 prev_sec
= map
->sections
[map
->count
- 1];
5176 /* If the gap between the end of the previous section
5177 and the start of this section is more than
5178 maxpagesize then we need to start a new segment. */
5179 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5181 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5182 || ((prev_sec
->lma
+ prev_sec
->size
)
5183 > output_section
->lma
))
5185 if (suggested_lma
== 0)
5186 suggested_lma
= output_section
->lma
;
5192 map
->sections
[map
->count
++] = output_section
;
5195 section
->segment_mark
= TRUE
;
5197 else if (suggested_lma
== 0)
5198 suggested_lma
= output_section
->lma
;
5201 BFD_ASSERT (map
->count
> 0);
5203 /* Add the current segment to the list of built segments. */
5204 *pointer_to_map
= map
;
5205 pointer_to_map
= &map
->next
;
5207 if (isec
< section_count
)
5209 /* We still have not allocated all of the sections to
5210 segments. Create a new segment here, initialise it
5211 and carry on looping. */
5212 amt
= sizeof (struct elf_segment_map
);
5213 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5214 map
= bfd_alloc (obfd
, amt
);
5221 /* Initialise the fields of the segment map. Set the physical
5222 physical address to the LMA of the first section that has
5223 not yet been assigned. */
5225 map
->p_type
= segment
->p_type
;
5226 map
->p_flags
= segment
->p_flags
;
5227 map
->p_flags_valid
= 1;
5228 map
->p_paddr
= suggested_lma
;
5229 map
->p_paddr_valid
= 1;
5230 map
->includes_filehdr
= 0;
5231 map
->includes_phdrs
= 0;
5234 while (isec
< section_count
);
5239 /* The Solaris linker creates program headers in which all the
5240 p_paddr fields are zero. When we try to objcopy or strip such a
5241 file, we get confused. Check for this case, and if we find it
5242 reset the p_paddr_valid fields. */
5243 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5244 if (map
->p_paddr
!= 0)
5247 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5248 map
->p_paddr_valid
= 0;
5250 elf_tdata (obfd
)->segment_map
= map_first
;
5252 /* If we had to estimate the number of program headers that were
5253 going to be needed, then check our estimate now and adjust
5254 the offset if necessary. */
5255 if (phdr_adjust_seg
!= NULL
)
5259 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5262 if (count
> phdr_adjust_num
)
5263 phdr_adjust_seg
->p_paddr
5264 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5268 /* Final Step: Sort the segments into ascending order of physical
5270 if (map_first
!= NULL
)
5272 struct elf_segment_map
*prev
;
5275 for (map
= map_first
->next
; map
!= NULL
; prev
= map
, map
= map
->next
)
5277 /* Yes I know - its a bubble sort.... */
5278 if (map
->next
!= NULL
&& (map
->next
->p_paddr
< map
->p_paddr
))
5280 /* Swap map and map->next. */
5281 prev
->next
= map
->next
;
5282 map
->next
= map
->next
->next
;
5283 prev
->next
->next
= map
;
5294 #undef IS_CONTAINED_BY_VMA
5295 #undef IS_CONTAINED_BY_LMA
5296 #undef IS_COREFILE_NOTE
5297 #undef IS_SOLARIS_PT_INTERP
5298 #undef INCLUDE_SECTION_IN_SEGMENT
5299 #undef SEGMENT_AFTER_SEGMENT
5300 #undef SEGMENT_OVERLAPS
5304 /* Copy private section information. This copies over the entsize
5305 field, and sometimes the info field. */
5308 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
5313 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5315 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5316 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5319 ihdr
= &elf_section_data (isec
)->this_hdr
;
5320 ohdr
= &elf_section_data (osec
)->this_hdr
;
5322 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
5324 if (ihdr
->sh_type
== SHT_SYMTAB
5325 || ihdr
->sh_type
== SHT_DYNSYM
5326 || ihdr
->sh_type
== SHT_GNU_verneed
5327 || ihdr
->sh_type
== SHT_GNU_verdef
)
5328 ohdr
->sh_info
= ihdr
->sh_info
;
5330 /* Set things up for objcopy. The output SHT_GROUP section will
5331 have its elf_next_in_group pointing back to the input group
5333 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5334 elf_group_name (osec
) = elf_group_name (isec
);
5336 osec
->use_rela_p
= isec
->use_rela_p
;
5341 /* Copy private header information. */
5344 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
5346 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5347 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5350 /* Copy over private BFD data if it has not already been copied.
5351 This must be done here, rather than in the copy_private_bfd_data
5352 entry point, because the latter is called after the section
5353 contents have been set, which means that the program headers have
5354 already been worked out. */
5355 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
5357 if (! copy_private_bfd_data (ibfd
, obfd
))
5364 /* Copy private symbol information. If this symbol is in a section
5365 which we did not map into a BFD section, try to map the section
5366 index correctly. We use special macro definitions for the mapped
5367 section indices; these definitions are interpreted by the
5368 swap_out_syms function. */
5370 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5371 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5372 #define MAP_STRTAB (SHN_HIOS + 3)
5373 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5374 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5377 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
5382 elf_symbol_type
*isym
, *osym
;
5384 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5385 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5388 isym
= elf_symbol_from (ibfd
, isymarg
);
5389 osym
= elf_symbol_from (obfd
, osymarg
);
5393 && bfd_is_abs_section (isym
->symbol
.section
))
5397 shndx
= isym
->internal_elf_sym
.st_shndx
;
5398 if (shndx
== elf_onesymtab (ibfd
))
5399 shndx
= MAP_ONESYMTAB
;
5400 else if (shndx
== elf_dynsymtab (ibfd
))
5401 shndx
= MAP_DYNSYMTAB
;
5402 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
5404 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
5405 shndx
= MAP_SHSTRTAB
;
5406 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
5407 shndx
= MAP_SYM_SHNDX
;
5408 osym
->internal_elf_sym
.st_shndx
= shndx
;
5414 /* Swap out the symbols. */
5417 swap_out_syms (bfd
*abfd
,
5418 struct bfd_strtab_hash
**sttp
,
5421 const struct elf_backend_data
*bed
;
5424 struct bfd_strtab_hash
*stt
;
5425 Elf_Internal_Shdr
*symtab_hdr
;
5426 Elf_Internal_Shdr
*symtab_shndx_hdr
;
5427 Elf_Internal_Shdr
*symstrtab_hdr
;
5428 char *outbound_syms
;
5429 char *outbound_shndx
;
5432 bfd_boolean name_local_sections
;
5434 if (!elf_map_symbols (abfd
))
5437 /* Dump out the symtabs. */
5438 stt
= _bfd_elf_stringtab_init ();
5442 bed
= get_elf_backend_data (abfd
);
5443 symcount
= bfd_get_symcount (abfd
);
5444 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5445 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5446 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
5447 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
5448 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
5449 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
5451 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5452 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5454 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
5455 outbound_syms
= bfd_alloc (abfd
, amt
);
5456 if (outbound_syms
== NULL
)
5458 _bfd_stringtab_free (stt
);
5461 symtab_hdr
->contents
= outbound_syms
;
5463 outbound_shndx
= NULL
;
5464 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
5465 if (symtab_shndx_hdr
->sh_name
!= 0)
5467 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
5468 outbound_shndx
= bfd_zalloc (abfd
, amt
);
5469 if (outbound_shndx
== NULL
)
5471 _bfd_stringtab_free (stt
);
5475 symtab_shndx_hdr
->contents
= outbound_shndx
;
5476 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
5477 symtab_shndx_hdr
->sh_size
= amt
;
5478 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
5479 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
5482 /* Now generate the data (for "contents"). */
5484 /* Fill in zeroth symbol and swap it out. */
5485 Elf_Internal_Sym sym
;
5491 sym
.st_shndx
= SHN_UNDEF
;
5492 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5493 outbound_syms
+= bed
->s
->sizeof_sym
;
5494 if (outbound_shndx
!= NULL
)
5495 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5499 = (bed
->elf_backend_name_local_section_symbols
5500 && bed
->elf_backend_name_local_section_symbols (abfd
));
5502 syms
= bfd_get_outsymbols (abfd
);
5503 for (idx
= 0; idx
< symcount
; idx
++)
5505 Elf_Internal_Sym sym
;
5506 bfd_vma value
= syms
[idx
]->value
;
5507 elf_symbol_type
*type_ptr
;
5508 flagword flags
= syms
[idx
]->flags
;
5511 if (!name_local_sections
5512 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
5514 /* Local section symbols have no name. */
5519 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
5522 if (sym
.st_name
== (unsigned long) -1)
5524 _bfd_stringtab_free (stt
);
5529 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
5531 if ((flags
& BSF_SECTION_SYM
) == 0
5532 && bfd_is_com_section (syms
[idx
]->section
))
5534 /* ELF common symbols put the alignment into the `value' field,
5535 and the size into the `size' field. This is backwards from
5536 how BFD handles it, so reverse it here. */
5537 sym
.st_size
= value
;
5538 if (type_ptr
== NULL
5539 || type_ptr
->internal_elf_sym
.st_value
== 0)
5540 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
5542 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
5543 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
5544 (abfd
, syms
[idx
]->section
);
5548 asection
*sec
= syms
[idx
]->section
;
5551 if (sec
->output_section
)
5553 value
+= sec
->output_offset
;
5554 sec
= sec
->output_section
;
5557 /* Don't add in the section vma for relocatable output. */
5558 if (! relocatable_p
)
5560 sym
.st_value
= value
;
5561 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
5563 if (bfd_is_abs_section (sec
)
5565 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
5567 /* This symbol is in a real ELF section which we did
5568 not create as a BFD section. Undo the mapping done
5569 by copy_private_symbol_data. */
5570 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
5574 shndx
= elf_onesymtab (abfd
);
5577 shndx
= elf_dynsymtab (abfd
);
5580 shndx
= elf_tdata (abfd
)->strtab_section
;
5583 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5586 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5594 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5600 /* Writing this would be a hell of a lot easier if
5601 we had some decent documentation on bfd, and
5602 knew what to expect of the library, and what to
5603 demand of applications. For example, it
5604 appears that `objcopy' might not set the
5605 section of a symbol to be a section that is
5606 actually in the output file. */
5607 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5610 _bfd_error_handler (_("\
5611 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5612 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
5614 bfd_set_error (bfd_error_invalid_operation
);
5615 _bfd_stringtab_free (stt
);
5619 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5620 BFD_ASSERT (shndx
!= -1);
5624 sym
.st_shndx
= shndx
;
5627 if ((flags
& BSF_THREAD_LOCAL
) != 0)
5629 else if ((flags
& BSF_FUNCTION
) != 0)
5631 else if ((flags
& BSF_OBJECT
) != 0)
5636 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
5639 /* Processor-specific types. */
5640 if (type_ptr
!= NULL
5641 && bed
->elf_backend_get_symbol_type
)
5642 type
= ((*bed
->elf_backend_get_symbol_type
)
5643 (&type_ptr
->internal_elf_sym
, type
));
5645 if (flags
& BSF_SECTION_SYM
)
5647 if (flags
& BSF_GLOBAL
)
5648 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5650 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5652 else if (bfd_is_com_section (syms
[idx
]->section
))
5653 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5654 else if (bfd_is_und_section (syms
[idx
]->section
))
5655 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
5659 else if (flags
& BSF_FILE
)
5660 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
5663 int bind
= STB_LOCAL
;
5665 if (flags
& BSF_LOCAL
)
5667 else if (flags
& BSF_WEAK
)
5669 else if (flags
& BSF_GLOBAL
)
5672 sym
.st_info
= ELF_ST_INFO (bind
, type
);
5675 if (type_ptr
!= NULL
)
5676 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
5680 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5681 outbound_syms
+= bed
->s
->sizeof_sym
;
5682 if (outbound_shndx
!= NULL
)
5683 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5687 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
5688 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5690 symstrtab_hdr
->sh_flags
= 0;
5691 symstrtab_hdr
->sh_addr
= 0;
5692 symstrtab_hdr
->sh_entsize
= 0;
5693 symstrtab_hdr
->sh_link
= 0;
5694 symstrtab_hdr
->sh_info
= 0;
5695 symstrtab_hdr
->sh_addralign
= 1;
5700 /* Return the number of bytes required to hold the symtab vector.
5702 Note that we base it on the count plus 1, since we will null terminate
5703 the vector allocated based on this size. However, the ELF symbol table
5704 always has a dummy entry as symbol #0, so it ends up even. */
5707 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
5711 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5713 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5714 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5716 symtab_size
-= sizeof (asymbol
*);
5722 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
5726 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
5728 if (elf_dynsymtab (abfd
) == 0)
5730 bfd_set_error (bfd_error_invalid_operation
);
5734 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
5735 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
5737 symtab_size
-= sizeof (asymbol
*);
5743 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
5746 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
5749 /* Canonicalize the relocs. */
5752 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
5759 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5761 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
5764 tblptr
= section
->relocation
;
5765 for (i
= 0; i
< section
->reloc_count
; i
++)
5766 *relptr
++ = tblptr
++;
5770 return section
->reloc_count
;
5774 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
5776 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5777 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
5780 bfd_get_symcount (abfd
) = symcount
;
5785 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
5786 asymbol
**allocation
)
5788 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5789 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
5792 bfd_get_dynamic_symcount (abfd
) = symcount
;
5796 /* Return the size required for the dynamic reloc entries. Any
5797 section that was actually installed in the BFD, and has type
5798 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5799 considered to be a dynamic reloc section. */
5802 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
5807 if (elf_dynsymtab (abfd
) == 0)
5809 bfd_set_error (bfd_error_invalid_operation
);
5813 ret
= sizeof (arelent
*);
5814 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5815 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5816 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5817 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5818 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
5819 * sizeof (arelent
*));
5824 /* Canonicalize the dynamic relocation entries. Note that we return
5825 the dynamic relocations as a single block, although they are
5826 actually associated with particular sections; the interface, which
5827 was designed for SunOS style shared libraries, expects that there
5828 is only one set of dynamic relocs. Any section that was actually
5829 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5830 the dynamic symbol table, is considered to be a dynamic reloc
5834 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
5838 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
5842 if (elf_dynsymtab (abfd
) == 0)
5844 bfd_set_error (bfd_error_invalid_operation
);
5848 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
5850 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5852 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
5853 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
5854 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
5859 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
5861 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
5863 for (i
= 0; i
< count
; i
++)
5874 /* Read in the version information. */
5877 _bfd_elf_slurp_version_tables (bfd
*abfd
)
5879 bfd_byte
*contents
= NULL
;
5882 if (elf_dynverdef (abfd
) != 0)
5884 Elf_Internal_Shdr
*hdr
;
5885 Elf_External_Verdef
*everdef
;
5886 Elf_Internal_Verdef
*iverdef
;
5887 Elf_Internal_Verdef
*iverdefarr
;
5888 Elf_Internal_Verdef iverdefmem
;
5890 unsigned int maxidx
;
5892 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
5894 contents
= bfd_malloc (hdr
->sh_size
);
5895 if (contents
== NULL
)
5897 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
5898 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
5901 /* We know the number of entries in the section but not the maximum
5902 index. Therefore we have to run through all entries and find
5904 everdef
= (Elf_External_Verdef
*) contents
;
5906 for (i
= 0; i
< hdr
->sh_info
; ++i
)
5908 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5910 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
5911 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
5913 everdef
= ((Elf_External_Verdef
*)
5914 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
5917 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
5918 elf_tdata (abfd
)->verdef
= bfd_zalloc (abfd
, amt
);
5919 if (elf_tdata (abfd
)->verdef
== NULL
)
5922 elf_tdata (abfd
)->cverdefs
= maxidx
;
5924 everdef
= (Elf_External_Verdef
*) contents
;
5925 iverdefarr
= elf_tdata (abfd
)->verdef
;
5926 for (i
= 0; i
< hdr
->sh_info
; i
++)
5928 Elf_External_Verdaux
*everdaux
;
5929 Elf_Internal_Verdaux
*iverdaux
;
5932 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
5934 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
5935 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
5937 iverdef
->vd_bfd
= abfd
;
5939 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
5940 iverdef
->vd_auxptr
= bfd_alloc (abfd
, amt
);
5941 if (iverdef
->vd_auxptr
== NULL
)
5944 everdaux
= ((Elf_External_Verdaux
*)
5945 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
5946 iverdaux
= iverdef
->vd_auxptr
;
5947 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
5949 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
5951 iverdaux
->vda_nodename
=
5952 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5953 iverdaux
->vda_name
);
5954 if (iverdaux
->vda_nodename
== NULL
)
5957 if (j
+ 1 < iverdef
->vd_cnt
)
5958 iverdaux
->vda_nextptr
= iverdaux
+ 1;
5960 iverdaux
->vda_nextptr
= NULL
;
5962 everdaux
= ((Elf_External_Verdaux
*)
5963 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
5966 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
5968 if (i
+ 1 < hdr
->sh_info
)
5969 iverdef
->vd_nextdef
= iverdef
+ 1;
5971 iverdef
->vd_nextdef
= NULL
;
5973 everdef
= ((Elf_External_Verdef
*)
5974 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
5981 if (elf_dynverref (abfd
) != 0)
5983 Elf_Internal_Shdr
*hdr
;
5984 Elf_External_Verneed
*everneed
;
5985 Elf_Internal_Verneed
*iverneed
;
5988 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
5990 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
5991 elf_tdata (abfd
)->verref
= bfd_zalloc (abfd
, amt
);
5992 if (elf_tdata (abfd
)->verref
== NULL
)
5995 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
5997 contents
= bfd_malloc (hdr
->sh_size
);
5998 if (contents
== NULL
)
6000 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6001 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6004 everneed
= (Elf_External_Verneed
*) contents
;
6005 iverneed
= elf_tdata (abfd
)->verref
;
6006 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6008 Elf_External_Vernaux
*evernaux
;
6009 Elf_Internal_Vernaux
*ivernaux
;
6012 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6014 iverneed
->vn_bfd
= abfd
;
6016 iverneed
->vn_filename
=
6017 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6019 if (iverneed
->vn_filename
== NULL
)
6022 amt
= iverneed
->vn_cnt
;
6023 amt
*= sizeof (Elf_Internal_Vernaux
);
6024 iverneed
->vn_auxptr
= bfd_alloc (abfd
, amt
);
6026 evernaux
= ((Elf_External_Vernaux
*)
6027 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6028 ivernaux
= iverneed
->vn_auxptr
;
6029 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6031 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6033 ivernaux
->vna_nodename
=
6034 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6035 ivernaux
->vna_name
);
6036 if (ivernaux
->vna_nodename
== NULL
)
6039 if (j
+ 1 < iverneed
->vn_cnt
)
6040 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6042 ivernaux
->vna_nextptr
= NULL
;
6044 evernaux
= ((Elf_External_Vernaux
*)
6045 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6048 if (i
+ 1 < hdr
->sh_info
)
6049 iverneed
->vn_nextref
= iverneed
+ 1;
6051 iverneed
->vn_nextref
= NULL
;
6053 everneed
= ((Elf_External_Verneed
*)
6054 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6064 if (contents
!= NULL
)
6070 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6072 elf_symbol_type
*newsym
;
6073 bfd_size_type amt
= sizeof (elf_symbol_type
);
6075 newsym
= bfd_zalloc (abfd
, amt
);
6080 newsym
->symbol
.the_bfd
= abfd
;
6081 return &newsym
->symbol
;
6086 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6090 bfd_symbol_info (symbol
, ret
);
6093 /* Return whether a symbol name implies a local symbol. Most targets
6094 use this function for the is_local_label_name entry point, but some
6098 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6101 /* Normal local symbols start with ``.L''. */
6102 if (name
[0] == '.' && name
[1] == 'L')
6105 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6106 DWARF debugging symbols starting with ``..''. */
6107 if (name
[0] == '.' && name
[1] == '.')
6110 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6111 emitting DWARF debugging output. I suspect this is actually a
6112 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6113 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6114 underscore to be emitted on some ELF targets). For ease of use,
6115 we treat such symbols as local. */
6116 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6123 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
6124 asymbol
*symbol ATTRIBUTE_UNUSED
)
6131 _bfd_elf_set_arch_mach (bfd
*abfd
,
6132 enum bfd_architecture arch
,
6133 unsigned long machine
)
6135 /* If this isn't the right architecture for this backend, and this
6136 isn't the generic backend, fail. */
6137 if (arch
!= get_elf_backend_data (abfd
)->arch
6138 && arch
!= bfd_arch_unknown
6139 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
6142 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
6145 /* Find the function to a particular section and offset,
6146 for error reporting. */
6149 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
6153 const char **filename_ptr
,
6154 const char **functionname_ptr
)
6156 const char *filename
;
6165 for (p
= symbols
; *p
!= NULL
; p
++)
6169 q
= (elf_symbol_type
*) *p
;
6171 if (bfd_get_section (&q
->symbol
) != section
)
6174 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
6179 filename
= bfd_asymbol_name (&q
->symbol
);
6183 if (q
->symbol
.section
== section
6184 && q
->symbol
.value
>= low_func
6185 && q
->symbol
.value
<= offset
)
6187 func
= (asymbol
*) q
;
6188 low_func
= q
->symbol
.value
;
6198 *filename_ptr
= filename
;
6199 if (functionname_ptr
)
6200 *functionname_ptr
= bfd_asymbol_name (func
);
6205 /* Find the nearest line to a particular section and offset,
6206 for error reporting. */
6209 _bfd_elf_find_nearest_line (bfd
*abfd
,
6213 const char **filename_ptr
,
6214 const char **functionname_ptr
,
6215 unsigned int *line_ptr
)
6219 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
6220 filename_ptr
, functionname_ptr
,
6223 if (!*functionname_ptr
)
6224 elf_find_function (abfd
, section
, symbols
, offset
,
6225 *filename_ptr
? NULL
: filename_ptr
,
6231 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
6232 filename_ptr
, functionname_ptr
,
6234 &elf_tdata (abfd
)->dwarf2_find_line_info
))
6236 if (!*functionname_ptr
)
6237 elf_find_function (abfd
, section
, symbols
, offset
,
6238 *filename_ptr
? NULL
: filename_ptr
,
6244 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
6245 &found
, filename_ptr
,
6246 functionname_ptr
, line_ptr
,
6247 &elf_tdata (abfd
)->line_info
))
6249 if (found
&& (*functionname_ptr
|| *line_ptr
))
6252 if (symbols
== NULL
)
6255 if (! elf_find_function (abfd
, section
, symbols
, offset
,
6256 filename_ptr
, functionname_ptr
))
6264 _bfd_elf_sizeof_headers (bfd
*abfd
, bfd_boolean reloc
)
6268 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
6270 ret
+= get_program_header_size (abfd
);
6275 _bfd_elf_set_section_contents (bfd
*abfd
,
6277 const void *location
,
6279 bfd_size_type count
)
6281 Elf_Internal_Shdr
*hdr
;
6284 if (! abfd
->output_has_begun
6285 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6288 hdr
= &elf_section_data (section
)->this_hdr
;
6289 pos
= hdr
->sh_offset
+ offset
;
6290 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6291 || bfd_bwrite (location
, count
, abfd
) != count
)
6298 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
6299 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
6300 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
6305 /* Try to convert a non-ELF reloc into an ELF one. */
6308 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
6310 /* Check whether we really have an ELF howto. */
6312 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
6314 bfd_reloc_code_real_type code
;
6315 reloc_howto_type
*howto
;
6317 /* Alien reloc: Try to determine its type to replace it with an
6318 equivalent ELF reloc. */
6320 if (areloc
->howto
->pc_relative
)
6322 switch (areloc
->howto
->bitsize
)
6325 code
= BFD_RELOC_8_PCREL
;
6328 code
= BFD_RELOC_12_PCREL
;
6331 code
= BFD_RELOC_16_PCREL
;
6334 code
= BFD_RELOC_24_PCREL
;
6337 code
= BFD_RELOC_32_PCREL
;
6340 code
= BFD_RELOC_64_PCREL
;
6346 howto
= bfd_reloc_type_lookup (abfd
, code
);
6348 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
6350 if (howto
->pcrel_offset
)
6351 areloc
->addend
+= areloc
->address
;
6353 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
6358 switch (areloc
->howto
->bitsize
)
6364 code
= BFD_RELOC_14
;
6367 code
= BFD_RELOC_16
;
6370 code
= BFD_RELOC_26
;
6373 code
= BFD_RELOC_32
;
6376 code
= BFD_RELOC_64
;
6382 howto
= bfd_reloc_type_lookup (abfd
, code
);
6386 areloc
->howto
= howto
;
6394 (*_bfd_error_handler
)
6395 (_("%s: unsupported relocation type %s"),
6396 bfd_archive_filename (abfd
), areloc
->howto
->name
);
6397 bfd_set_error (bfd_error_bad_value
);
6402 _bfd_elf_close_and_cleanup (bfd
*abfd
)
6404 if (bfd_get_format (abfd
) == bfd_object
)
6406 if (elf_shstrtab (abfd
) != NULL
)
6407 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
6410 return _bfd_generic_close_and_cleanup (abfd
);
6413 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6414 in the relocation's offset. Thus we cannot allow any sort of sanity
6415 range-checking to interfere. There is nothing else to do in processing
6418 bfd_reloc_status_type
6419 _bfd_elf_rel_vtable_reloc_fn
6420 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
6421 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
6422 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
6423 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
6425 return bfd_reloc_ok
;
6428 /* Elf core file support. Much of this only works on native
6429 toolchains, since we rely on knowing the
6430 machine-dependent procfs structure in order to pick
6431 out details about the corefile. */
6433 #ifdef HAVE_SYS_PROCFS_H
6434 # include <sys/procfs.h>
6437 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6440 elfcore_make_pid (bfd
*abfd
)
6442 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
6443 + (elf_tdata (abfd
)->core_pid
));
6446 /* If there isn't a section called NAME, make one, using
6447 data from SECT. Note, this function will generate a
6448 reference to NAME, so you shouldn't deallocate or
6452 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
6456 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
6459 sect2
= bfd_make_section (abfd
, name
);
6463 sect2
->size
= sect
->size
;
6464 sect2
->filepos
= sect
->filepos
;
6465 sect2
->flags
= sect
->flags
;
6466 sect2
->alignment_power
= sect
->alignment_power
;
6470 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6471 actually creates up to two pseudosections:
6472 - For the single-threaded case, a section named NAME, unless
6473 such a section already exists.
6474 - For the multi-threaded case, a section named "NAME/PID", where
6475 PID is elfcore_make_pid (abfd).
6476 Both pseudosections have identical contents. */
6478 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
6484 char *threaded_name
;
6488 /* Build the section name. */
6490 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
6491 len
= strlen (buf
) + 1;
6492 threaded_name
= bfd_alloc (abfd
, len
);
6493 if (threaded_name
== NULL
)
6495 memcpy (threaded_name
, buf
, len
);
6497 sect
= bfd_make_section_anyway (abfd
, threaded_name
);
6501 sect
->filepos
= filepos
;
6502 sect
->flags
= SEC_HAS_CONTENTS
;
6503 sect
->alignment_power
= 2;
6505 return elfcore_maybe_make_sect (abfd
, name
, sect
);
6508 /* prstatus_t exists on:
6510 linux 2.[01] + glibc
6514 #if defined (HAVE_PRSTATUS_T)
6517 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6522 if (note
->descsz
== sizeof (prstatus_t
))
6526 size
= sizeof (prstat
.pr_reg
);
6527 offset
= offsetof (prstatus_t
, pr_reg
);
6528 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6530 /* Do not overwrite the core signal if it
6531 has already been set by another thread. */
6532 if (elf_tdata (abfd
)->core_signal
== 0)
6533 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6534 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6536 /* pr_who exists on:
6539 pr_who doesn't exist on:
6542 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6543 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6546 #if defined (HAVE_PRSTATUS32_T)
6547 else if (note
->descsz
== sizeof (prstatus32_t
))
6549 /* 64-bit host, 32-bit corefile */
6550 prstatus32_t prstat
;
6552 size
= sizeof (prstat
.pr_reg
);
6553 offset
= offsetof (prstatus32_t
, pr_reg
);
6554 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6556 /* Do not overwrite the core signal if it
6557 has already been set by another thread. */
6558 if (elf_tdata (abfd
)->core_signal
== 0)
6559 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6560 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6562 /* pr_who exists on:
6565 pr_who doesn't exist on:
6568 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6569 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6572 #endif /* HAVE_PRSTATUS32_T */
6575 /* Fail - we don't know how to handle any other
6576 note size (ie. data object type). */
6580 /* Make a ".reg/999" section and a ".reg" section. */
6581 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
6582 size
, note
->descpos
+ offset
);
6584 #endif /* defined (HAVE_PRSTATUS_T) */
6586 /* Create a pseudosection containing the exact contents of NOTE. */
6588 elfcore_make_note_pseudosection (bfd
*abfd
,
6590 Elf_Internal_Note
*note
)
6592 return _bfd_elfcore_make_pseudosection (abfd
, name
,
6593 note
->descsz
, note
->descpos
);
6596 /* There isn't a consistent prfpregset_t across platforms,
6597 but it doesn't matter, because we don't have to pick this
6598 data structure apart. */
6601 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
6603 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
6606 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6607 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6611 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
6613 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
6616 #if defined (HAVE_PRPSINFO_T)
6617 typedef prpsinfo_t elfcore_psinfo_t
;
6618 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6619 typedef prpsinfo32_t elfcore_psinfo32_t
;
6623 #if defined (HAVE_PSINFO_T)
6624 typedef psinfo_t elfcore_psinfo_t
;
6625 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6626 typedef psinfo32_t elfcore_psinfo32_t
;
6630 /* return a malloc'ed copy of a string at START which is at
6631 most MAX bytes long, possibly without a terminating '\0'.
6632 the copy will always have a terminating '\0'. */
6635 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
6638 char *end
= memchr (start
, '\0', max
);
6646 dups
= bfd_alloc (abfd
, len
+ 1);
6650 memcpy (dups
, start
, len
);
6656 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6658 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6660 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
6662 elfcore_psinfo_t psinfo
;
6664 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6666 elf_tdata (abfd
)->core_program
6667 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6668 sizeof (psinfo
.pr_fname
));
6670 elf_tdata (abfd
)->core_command
6671 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6672 sizeof (psinfo
.pr_psargs
));
6674 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6675 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
6677 /* 64-bit host, 32-bit corefile */
6678 elfcore_psinfo32_t psinfo
;
6680 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
6682 elf_tdata (abfd
)->core_program
6683 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
6684 sizeof (psinfo
.pr_fname
));
6686 elf_tdata (abfd
)->core_command
6687 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
6688 sizeof (psinfo
.pr_psargs
));
6694 /* Fail - we don't know how to handle any other
6695 note size (ie. data object type). */
6699 /* Note that for some reason, a spurious space is tacked
6700 onto the end of the args in some (at least one anyway)
6701 implementations, so strip it off if it exists. */
6704 char *command
= elf_tdata (abfd
)->core_command
;
6705 int n
= strlen (command
);
6707 if (0 < n
&& command
[n
- 1] == ' ')
6708 command
[n
- 1] = '\0';
6713 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6715 #if defined (HAVE_PSTATUS_T)
6717 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6719 if (note
->descsz
== sizeof (pstatus_t
)
6720 #if defined (HAVE_PXSTATUS_T)
6721 || note
->descsz
== sizeof (pxstatus_t
)
6727 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6729 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6731 #if defined (HAVE_PSTATUS32_T)
6732 else if (note
->descsz
== sizeof (pstatus32_t
))
6734 /* 64-bit host, 32-bit corefile */
6737 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
6739 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
6742 /* Could grab some more details from the "representative"
6743 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6744 NT_LWPSTATUS note, presumably. */
6748 #endif /* defined (HAVE_PSTATUS_T) */
6750 #if defined (HAVE_LWPSTATUS_T)
6752 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6754 lwpstatus_t lwpstat
;
6760 if (note
->descsz
!= sizeof (lwpstat
)
6761 #if defined (HAVE_LWPXSTATUS_T)
6762 && note
->descsz
!= sizeof (lwpxstatus_t
)
6767 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
6769 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
6770 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
6772 /* Make a ".reg/999" section. */
6774 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
6775 len
= strlen (buf
) + 1;
6776 name
= bfd_alloc (abfd
, len
);
6779 memcpy (name
, buf
, len
);
6781 sect
= bfd_make_section_anyway (abfd
, name
);
6785 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6786 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
6787 sect
->filepos
= note
->descpos
6788 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
6791 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6792 sect
->size
= sizeof (lwpstat
.pr_reg
);
6793 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
6796 sect
->flags
= SEC_HAS_CONTENTS
;
6797 sect
->alignment_power
= 2;
6799 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6802 /* Make a ".reg2/999" section */
6804 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
6805 len
= strlen (buf
) + 1;
6806 name
= bfd_alloc (abfd
, len
);
6809 memcpy (name
, buf
, len
);
6811 sect
= bfd_make_section_anyway (abfd
, name
);
6815 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6816 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
6817 sect
->filepos
= note
->descpos
6818 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
6821 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6822 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
6823 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
6826 sect
->flags
= SEC_HAS_CONTENTS
;
6827 sect
->alignment_power
= 2;
6829 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
6831 #endif /* defined (HAVE_LWPSTATUS_T) */
6833 #if defined (HAVE_WIN32_PSTATUS_T)
6835 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6841 win32_pstatus_t pstatus
;
6843 if (note
->descsz
< sizeof (pstatus
))
6846 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
6848 switch (pstatus
.data_type
)
6850 case NOTE_INFO_PROCESS
:
6851 /* FIXME: need to add ->core_command. */
6852 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
6853 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
6856 case NOTE_INFO_THREAD
:
6857 /* Make a ".reg/999" section. */
6858 sprintf (buf
, ".reg/%d", pstatus
.data
.thread_info
.tid
);
6860 len
= strlen (buf
) + 1;
6861 name
= bfd_alloc (abfd
, len
);
6865 memcpy (name
, buf
, len
);
6867 sect
= bfd_make_section_anyway (abfd
, name
);
6871 sect
->size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
6872 sect
->filepos
= (note
->descpos
6873 + offsetof (struct win32_pstatus
,
6874 data
.thread_info
.thread_context
));
6875 sect
->flags
= SEC_HAS_CONTENTS
;
6876 sect
->alignment_power
= 2;
6878 if (pstatus
.data
.thread_info
.is_active_thread
)
6879 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
6883 case NOTE_INFO_MODULE
:
6884 /* Make a ".module/xxxxxxxx" section. */
6885 sprintf (buf
, ".module/%08x", pstatus
.data
.module_info
.base_address
);
6887 len
= strlen (buf
) + 1;
6888 name
= bfd_alloc (abfd
, len
);
6892 memcpy (name
, buf
, len
);
6894 sect
= bfd_make_section_anyway (abfd
, name
);
6899 sect
->size
= note
->descsz
;
6900 sect
->filepos
= note
->descpos
;
6901 sect
->flags
= SEC_HAS_CONTENTS
;
6902 sect
->alignment_power
= 2;
6911 #endif /* HAVE_WIN32_PSTATUS_T */
6914 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
6916 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6924 if (bed
->elf_backend_grok_prstatus
)
6925 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
6927 #if defined (HAVE_PRSTATUS_T)
6928 return elfcore_grok_prstatus (abfd
, note
);
6933 #if defined (HAVE_PSTATUS_T)
6935 return elfcore_grok_pstatus (abfd
, note
);
6938 #if defined (HAVE_LWPSTATUS_T)
6940 return elfcore_grok_lwpstatus (abfd
, note
);
6943 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
6944 return elfcore_grok_prfpreg (abfd
, note
);
6946 #if defined (HAVE_WIN32_PSTATUS_T)
6947 case NT_WIN32PSTATUS
:
6948 return elfcore_grok_win32pstatus (abfd
, note
);
6951 case NT_PRXFPREG
: /* Linux SSE extension */
6952 if (note
->namesz
== 6
6953 && strcmp (note
->namedata
, "LINUX") == 0)
6954 return elfcore_grok_prxfpreg (abfd
, note
);
6960 if (bed
->elf_backend_grok_psinfo
)
6961 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
6963 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6964 return elfcore_grok_psinfo (abfd
, note
);
6971 asection
*sect
= bfd_make_section_anyway (abfd
, ".auxv");
6975 sect
->size
= note
->descsz
;
6976 sect
->filepos
= note
->descpos
;
6977 sect
->flags
= SEC_HAS_CONTENTS
;
6978 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
6986 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
6990 cp
= strchr (note
->namedata
, '@');
6993 *lwpidp
= atoi(cp
+ 1);
7000 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7003 /* Signal number at offset 0x08. */
7004 elf_tdata (abfd
)->core_signal
7005 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
7007 /* Process ID at offset 0x50. */
7008 elf_tdata (abfd
)->core_pid
7009 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
7011 /* Command name at 0x7c (max 32 bytes, including nul). */
7012 elf_tdata (abfd
)->core_command
7013 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
7015 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
7020 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7024 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
7025 elf_tdata (abfd
)->core_lwpid
= lwp
;
7027 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
7029 /* NetBSD-specific core "procinfo". Note that we expect to
7030 find this note before any of the others, which is fine,
7031 since the kernel writes this note out first when it
7032 creates a core file. */
7034 return elfcore_grok_netbsd_procinfo (abfd
, note
);
7037 /* As of Jan 2002 there are no other machine-independent notes
7038 defined for NetBSD core files. If the note type is less
7039 than the start of the machine-dependent note types, we don't
7042 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
7046 switch (bfd_get_arch (abfd
))
7048 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7049 PT_GETFPREGS == mach+2. */
7051 case bfd_arch_alpha
:
7052 case bfd_arch_sparc
:
7055 case NT_NETBSDCORE_FIRSTMACH
+0:
7056 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7058 case NT_NETBSDCORE_FIRSTMACH
+2:
7059 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7065 /* On all other arch's, PT_GETREGS == mach+1 and
7066 PT_GETFPREGS == mach+3. */
7071 case NT_NETBSDCORE_FIRSTMACH
+1:
7072 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7074 case NT_NETBSDCORE_FIRSTMACH
+3:
7075 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7085 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t
*tid
)
7087 void *ddata
= note
->descdata
;
7094 /* nto_procfs_status 'pid' field is at offset 0. */
7095 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
7097 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7098 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
7100 /* nto_procfs_status 'flags' field is at offset 8. */
7101 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
7103 /* nto_procfs_status 'what' field is at offset 14. */
7104 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
7106 elf_tdata (abfd
)->core_signal
= sig
;
7107 elf_tdata (abfd
)->core_lwpid
= *tid
;
7110 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7111 do not come from signals so we make sure we set the current
7112 thread just in case. */
7113 if (flags
& 0x00000080)
7114 elf_tdata (abfd
)->core_lwpid
= *tid
;
7116 /* Make a ".qnx_core_status/%d" section. */
7117 sprintf (buf
, ".qnx_core_status/%d", *tid
);
7119 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7124 sect
= bfd_make_section_anyway (abfd
, name
);
7128 sect
->size
= note
->descsz
;
7129 sect
->filepos
= note
->descpos
;
7130 sect
->flags
= SEC_HAS_CONTENTS
;
7131 sect
->alignment_power
= 2;
7133 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
7137 elfcore_grok_nto_gregs (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t tid
)
7143 /* Make a ".reg/%d" section. */
7144 sprintf (buf
, ".reg/%d", tid
);
7146 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7151 sect
= bfd_make_section_anyway (abfd
, name
);
7155 sect
->size
= note
->descsz
;
7156 sect
->filepos
= note
->descpos
;
7157 sect
->flags
= SEC_HAS_CONTENTS
;
7158 sect
->alignment_power
= 2;
7160 /* This is the current thread. */
7161 if (elf_tdata (abfd
)->core_lwpid
== tid
)
7162 return elfcore_maybe_make_sect (abfd
, ".reg", sect
);
7167 #define BFD_QNT_CORE_INFO 7
7168 #define BFD_QNT_CORE_STATUS 8
7169 #define BFD_QNT_CORE_GREG 9
7170 #define BFD_QNT_CORE_FPREG 10
7173 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7175 /* Every GREG section has a STATUS section before it. Store the
7176 tid from the previous call to pass down to the next gregs
7178 static pid_t tid
= 1;
7182 case BFD_QNT_CORE_INFO
: return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
7183 case BFD_QNT_CORE_STATUS
: return elfcore_grok_nto_status (abfd
, note
, &tid
);
7184 case BFD_QNT_CORE_GREG
: return elfcore_grok_nto_gregs (abfd
, note
, tid
);
7185 case BFD_QNT_CORE_FPREG
: return elfcore_grok_prfpreg (abfd
, note
);
7186 default: return TRUE
;
7190 /* Function: elfcore_write_note
7197 size of data for note
7200 End of buffer containing note. */
7203 elfcore_write_note (bfd
*abfd
,
7211 Elf_External_Note
*xnp
;
7221 const struct elf_backend_data
*bed
;
7223 namesz
= strlen (name
) + 1;
7224 bed
= get_elf_backend_data (abfd
);
7225 pad
= -namesz
& ((1 << bed
->s
->log_file_align
) - 1);
7228 newspace
= 12 + namesz
+ pad
+ size
;
7230 p
= realloc (buf
, *bufsiz
+ newspace
);
7232 *bufsiz
+= newspace
;
7233 xnp
= (Elf_External_Note
*) dest
;
7234 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
7235 H_PUT_32 (abfd
, size
, xnp
->descsz
);
7236 H_PUT_32 (abfd
, type
, xnp
->type
);
7240 memcpy (dest
, name
, namesz
);
7248 memcpy (dest
, input
, size
);
7252 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7254 elfcore_write_prpsinfo (bfd
*abfd
,
7261 char *note_name
= "CORE";
7263 #if defined (HAVE_PSINFO_T)
7265 note_type
= NT_PSINFO
;
7268 note_type
= NT_PRPSINFO
;
7271 memset (&data
, 0, sizeof (data
));
7272 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
7273 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
7274 return elfcore_write_note (abfd
, buf
, bufsiz
,
7275 note_name
, note_type
, &data
, sizeof (data
));
7277 #endif /* PSINFO_T or PRPSINFO_T */
7279 #if defined (HAVE_PRSTATUS_T)
7281 elfcore_write_prstatus (bfd
*abfd
,
7289 char *note_name
= "CORE";
7291 memset (&prstat
, 0, sizeof (prstat
));
7292 prstat
.pr_pid
= pid
;
7293 prstat
.pr_cursig
= cursig
;
7294 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
7295 return elfcore_write_note (abfd
, buf
, bufsiz
,
7296 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
7298 #endif /* HAVE_PRSTATUS_T */
7300 #if defined (HAVE_LWPSTATUS_T)
7302 elfcore_write_lwpstatus (bfd
*abfd
,
7309 lwpstatus_t lwpstat
;
7310 char *note_name
= "CORE";
7312 memset (&lwpstat
, 0, sizeof (lwpstat
));
7313 lwpstat
.pr_lwpid
= pid
>> 16;
7314 lwpstat
.pr_cursig
= cursig
;
7315 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7316 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
7317 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7319 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
7320 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
7322 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
7323 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
7326 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7327 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
7329 #endif /* HAVE_LWPSTATUS_T */
7331 #if defined (HAVE_PSTATUS_T)
7333 elfcore_write_pstatus (bfd
*abfd
,
7341 char *note_name
= "CORE";
7343 memset (&pstat
, 0, sizeof (pstat
));
7344 pstat
.pr_pid
= pid
& 0xffff;
7345 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7346 NT_PSTATUS
, &pstat
, sizeof (pstat
));
7349 #endif /* HAVE_PSTATUS_T */
7352 elfcore_write_prfpreg (bfd
*abfd
,
7358 char *note_name
= "CORE";
7359 return elfcore_write_note (abfd
, buf
, bufsiz
,
7360 note_name
, NT_FPREGSET
, fpregs
, size
);
7364 elfcore_write_prxfpreg (bfd
*abfd
,
7367 const void *xfpregs
,
7370 char *note_name
= "LINUX";
7371 return elfcore_write_note (abfd
, buf
, bufsiz
,
7372 note_name
, NT_PRXFPREG
, xfpregs
, size
);
7376 elfcore_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
7384 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
7387 buf
= bfd_malloc (size
);
7391 if (bfd_bread (buf
, size
, abfd
) != size
)
7399 while (p
< buf
+ size
)
7401 /* FIXME: bad alignment assumption. */
7402 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
7403 Elf_Internal_Note in
;
7405 in
.type
= H_GET_32 (abfd
, xnp
->type
);
7407 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
7408 in
.namedata
= xnp
->name
;
7410 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
7411 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
7412 in
.descpos
= offset
+ (in
.descdata
- buf
);
7414 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
7416 if (! elfcore_grok_netbsd_note (abfd
, &in
))
7419 else if (strncmp (in
.namedata
, "QNX", 3) == 0)
7421 if (! elfcore_grok_nto_note (abfd
, &in
))
7426 if (! elfcore_grok_note (abfd
, &in
))
7430 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
7437 /* Providing external access to the ELF program header table. */
7439 /* Return an upper bound on the number of bytes required to store a
7440 copy of ABFD's program header table entries. Return -1 if an error
7441 occurs; bfd_get_error will return an appropriate code. */
7444 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
7446 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7448 bfd_set_error (bfd_error_wrong_format
);
7452 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
7455 /* Copy ABFD's program header table entries to *PHDRS. The entries
7456 will be stored as an array of Elf_Internal_Phdr structures, as
7457 defined in include/elf/internal.h. To find out how large the
7458 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7460 Return the number of program header table entries read, or -1 if an
7461 error occurs; bfd_get_error will return an appropriate code. */
7464 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
7468 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7470 bfd_set_error (bfd_error_wrong_format
);
7474 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
7475 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
7476 num_phdrs
* sizeof (Elf_Internal_Phdr
));
7482 _bfd_elf_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
7485 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7487 i_ehdrp
= elf_elfheader (abfd
);
7488 if (i_ehdrp
== NULL
)
7489 sprintf_vma (buf
, value
);
7492 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7494 #if BFD_HOST_64BIT_LONG
7495 sprintf (buf
, "%016lx", value
);
7497 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
7498 _bfd_int64_low (value
));
7502 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
7505 sprintf_vma (buf
, value
);
7510 _bfd_elf_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
7513 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7515 i_ehdrp
= elf_elfheader (abfd
);
7516 if (i_ehdrp
== NULL
)
7517 fprintf_vma ((FILE *) stream
, value
);
7520 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7522 #if BFD_HOST_64BIT_LONG
7523 fprintf ((FILE *) stream
, "%016lx", value
);
7525 fprintf ((FILE *) stream
, "%08lx%08lx",
7526 _bfd_int64_high (value
), _bfd_int64_low (value
));
7530 fprintf ((FILE *) stream
, "%08lx",
7531 (unsigned long) (value
& 0xffffffff));
7534 fprintf_vma ((FILE *) stream
, value
);
7538 enum elf_reloc_type_class
7539 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
7541 return reloc_class_normal
;
7544 /* For RELA architectures, return the relocation value for a
7545 relocation against a local symbol. */
7548 _bfd_elf_rela_local_sym (bfd
*abfd
,
7549 Elf_Internal_Sym
*sym
,
7551 Elf_Internal_Rela
*rel
)
7553 asection
*sec
= *psec
;
7556 relocation
= (sec
->output_section
->vma
7557 + sec
->output_offset
7559 if ((sec
->flags
& SEC_MERGE
)
7560 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
7561 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
7564 _bfd_merged_section_offset (abfd
, psec
,
7565 elf_section_data (sec
)->sec_info
,
7566 sym
->st_value
+ rel
->r_addend
);
7569 /* If we have changed the section, and our original section is
7570 marked with SEC_EXCLUDE, it means that the original
7571 SEC_MERGE section has been completely subsumed in some
7572 other SEC_MERGE section. In this case, we need to leave
7573 some info around for --emit-relocs. */
7574 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
7575 sec
->kept_section
= *psec
;
7578 rel
->r_addend
-= relocation
;
7579 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
7585 _bfd_elf_rel_local_sym (bfd
*abfd
,
7586 Elf_Internal_Sym
*sym
,
7590 asection
*sec
= *psec
;
7592 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
7593 return sym
->st_value
+ addend
;
7595 return _bfd_merged_section_offset (abfd
, psec
,
7596 elf_section_data (sec
)->sec_info
,
7597 sym
->st_value
+ addend
);
7601 _bfd_elf_section_offset (bfd
*abfd
,
7602 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
7606 switch (sec
->sec_info_type
)
7608 case ELF_INFO_TYPE_STABS
:
7609 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
7611 case ELF_INFO_TYPE_EH_FRAME
:
7612 return _bfd_elf_eh_frame_section_offset (abfd
, sec
, offset
);
7618 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
7619 reconstruct an ELF file by reading the segments out of remote memory
7620 based on the ELF file header at EHDR_VMA and the ELF program headers it
7621 points to. If not null, *LOADBASEP is filled in with the difference
7622 between the VMAs from which the segments were read, and the VMAs the
7623 file headers (and hence BFD's idea of each section's VMA) put them at.
7625 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7626 remote memory at target address VMA into the local buffer at MYADDR; it
7627 should return zero on success or an `errno' code on failure. TEMPL must
7628 be a BFD for an ELF target with the word size and byte order found in
7629 the remote memory. */
7632 bfd_elf_bfd_from_remote_memory
7636 int (*target_read_memory
) (bfd_vma
, char *, int))
7638 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
7639 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
7643 _bfd_elf_get_synthetic_symtab (bfd
*abfd
, asymbol
**dynsyms
, asymbol
**ret
)
7645 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7648 const char *relplt_name
;
7649 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
7653 Elf_Internal_Shdr
*hdr
;
7658 if (!bed
->plt_sym_val
)
7661 relplt_name
= bed
->relplt_name
;
7662 if (relplt_name
== NULL
)
7663 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
7664 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
7668 hdr
= &elf_section_data (relplt
)->this_hdr
;
7669 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
7670 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
7673 plt
= bfd_get_section_by_name (abfd
, ".plt");
7677 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
7678 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
7681 count
= relplt
->size
/ hdr
->sh_entsize
;
7682 size
= count
* sizeof (asymbol
);
7683 p
= relplt
->relocation
;
7684 for (i
= 0; i
< count
; i
++, s
++, p
++)
7685 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
7687 s
= *ret
= bfd_malloc (size
);
7691 names
= (char *) (s
+ count
);
7692 p
= relplt
->relocation
;
7694 for (i
= 0; i
< count
; i
++, s
++, p
++)
7699 addr
= bed
->plt_sym_val (i
, plt
, p
);
7700 if (addr
== (bfd_vma
) -1)
7703 *s
= **p
->sym_ptr_ptr
;
7705 s
->value
= addr
- plt
->vma
;
7707 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
7708 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
7710 memcpy (names
, "@plt", sizeof ("@plt"));
7711 names
+= sizeof ("@plt");