1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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 bfd_byte
*shstrtab
= NULL
;
258 bfd_size_type shstrtabsize
;
260 i_shdrp
= elf_elfsections (abfd
);
261 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
264 shstrtab
= 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
;
273 return (char *) 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 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
295 (*_bfd_error_handler
)
296 (_("%B: invalid string offset %u >= %lu for section `%s'"),
297 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
298 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
300 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, 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_sym_name (bfd
*abfd
,
409 Elf_Internal_Shdr
*symtab_hdr
,
410 Elf_Internal_Sym
*isym
,
414 unsigned int iname
= isym
->st_name
;
415 unsigned int shindex
= symtab_hdr
->sh_link
;
417 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
418 /* Check for a bogus st_shndx to avoid crashing. */
419 && isym
->st_shndx
< elf_numsections (abfd
)
420 && !(isym
->st_shndx
>= SHN_LORESERVE
&& isym
->st_shndx
<= SHN_HIRESERVE
))
422 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
423 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
426 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
429 else if (sym_sec
&& *name
== '\0')
430 name
= bfd_section_name (abfd
, sym_sec
);
435 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
436 sections. The first element is the flags, the rest are section
439 typedef union elf_internal_group
{
440 Elf_Internal_Shdr
*shdr
;
442 } Elf_Internal_Group
;
444 /* Return the name of the group signature symbol. Why isn't the
445 signature just a string? */
448 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
450 Elf_Internal_Shdr
*hdr
;
451 unsigned char esym
[sizeof (Elf64_External_Sym
)];
452 Elf_External_Sym_Shndx eshndx
;
453 Elf_Internal_Sym isym
;
455 /* First we need to ensure the symbol table is available. Make sure
456 that it is a symbol table section. */
457 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
458 if (hdr
->sh_type
!= SHT_SYMTAB
459 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
462 /* Go read the symbol. */
463 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
464 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
465 &isym
, esym
, &eshndx
) == NULL
)
468 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
471 /* Set next_in_group list pointer, and group name for NEWSECT. */
474 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
476 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
478 /* If num_group is zero, read in all SHT_GROUP sections. The count
479 is set to -1 if there are no SHT_GROUP sections. */
482 unsigned int i
, shnum
;
484 /* First count the number of groups. If we have a SHT_GROUP
485 section with just a flag word (ie. sh_size is 4), ignore it. */
486 shnum
= elf_numsections (abfd
);
488 for (i
= 0; i
< shnum
; i
++)
490 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
491 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
497 num_group
= (unsigned) -1;
498 elf_tdata (abfd
)->num_group
= num_group
;
502 /* We keep a list of elf section headers for group sections,
503 so we can find them quickly. */
506 elf_tdata (abfd
)->num_group
= num_group
;
507 amt
= num_group
* sizeof (Elf_Internal_Shdr
*);
508 elf_tdata (abfd
)->group_sect_ptr
= bfd_alloc (abfd
, amt
);
509 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
513 for (i
= 0; i
< shnum
; i
++)
515 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
516 if (shdr
->sh_type
== SHT_GROUP
&& shdr
->sh_size
>= 8)
519 Elf_Internal_Group
*dest
;
521 /* Add to list of sections. */
522 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
525 /* Read the raw contents. */
526 BFD_ASSERT (sizeof (*dest
) >= 4);
527 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
528 shdr
->contents
= bfd_alloc (abfd
, amt
);
529 if (shdr
->contents
== NULL
530 || bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
531 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
535 /* Translate raw contents, a flag word followed by an
536 array of elf section indices all in target byte order,
537 to the flag word followed by an array of elf section
539 src
= shdr
->contents
+ shdr
->sh_size
;
540 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
547 idx
= H_GET_32 (abfd
, src
);
548 if (src
== shdr
->contents
)
551 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
552 shdr
->bfd_section
->flags
553 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
558 ((*_bfd_error_handler
)
559 (_("%B: invalid SHT_GROUP entry"), abfd
));
562 dest
->shdr
= elf_elfsections (abfd
)[idx
];
569 if (num_group
!= (unsigned) -1)
573 for (i
= 0; i
< num_group
; i
++)
575 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
576 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
577 unsigned int n_elt
= shdr
->sh_size
/ 4;
579 /* Look through this group's sections to see if current
580 section is a member. */
582 if ((++idx
)->shdr
== hdr
)
586 /* We are a member of this group. Go looking through
587 other members to see if any others are linked via
589 idx
= (Elf_Internal_Group
*) shdr
->contents
;
590 n_elt
= shdr
->sh_size
/ 4;
592 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
593 && elf_next_in_group (s
) != NULL
)
597 /* Snarf the group name from other member, and
598 insert current section in circular list. */
599 elf_group_name (newsect
) = elf_group_name (s
);
600 elf_next_in_group (newsect
) = elf_next_in_group (s
);
601 elf_next_in_group (s
) = newsect
;
607 gname
= group_signature (abfd
, shdr
);
610 elf_group_name (newsect
) = gname
;
612 /* Start a circular list with one element. */
613 elf_next_in_group (newsect
) = newsect
;
616 /* If the group section has been created, point to the
618 if (shdr
->bfd_section
!= NULL
)
619 elf_next_in_group (shdr
->bfd_section
) = newsect
;
627 if (elf_group_name (newsect
) == NULL
)
629 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
636 _bfd_elf_setup_group_pointers (bfd
*abfd
)
639 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
640 bfd_boolean result
= TRUE
;
642 if (num_group
== (unsigned) -1)
645 for (i
= 0; i
< num_group
; i
++)
647 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
648 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
649 unsigned int n_elt
= shdr
->sh_size
/ 4;
652 if ((++idx
)->shdr
->bfd_section
)
653 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
654 else if (idx
->shdr
->sh_type
== SHT_RELA
655 || idx
->shdr
->sh_type
== SHT_REL
)
656 /* We won't include relocation sections in section groups in
657 output object files. We adjust the group section size here
658 so that relocatable link will work correctly when
659 relocation sections are in section group in input object
661 shdr
->bfd_section
->size
-= 4;
664 /* There are some unknown sections in the group. */
665 (*_bfd_error_handler
)
666 (_("%B: unknown [%d] section `%s' in group [%s]"),
668 (unsigned int) idx
->shdr
->sh_type
,
669 bfd_elf_string_from_elf_section (abfd
,
670 (elf_elfheader (abfd
)
673 shdr
->bfd_section
->name
);
681 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
683 return elf_next_in_group (sec
) != NULL
;
686 /* Make a BFD section from an ELF section. We store a pointer to the
687 BFD section in the bfd_section field of the header. */
690 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
691 Elf_Internal_Shdr
*hdr
,
697 const struct elf_backend_data
*bed
;
699 if (hdr
->bfd_section
!= NULL
)
701 BFD_ASSERT (strcmp (name
,
702 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
706 newsect
= bfd_make_section_anyway (abfd
, name
);
710 hdr
->bfd_section
= newsect
;
711 elf_section_data (newsect
)->this_hdr
= *hdr
;
712 elf_section_data (newsect
)->this_idx
= shindex
;
714 /* Always use the real type/flags. */
715 elf_section_type (newsect
) = hdr
->sh_type
;
716 elf_section_flags (newsect
) = hdr
->sh_flags
;
718 newsect
->filepos
= hdr
->sh_offset
;
720 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
721 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
722 || ! bfd_set_section_alignment (abfd
, newsect
,
723 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
726 flags
= SEC_NO_FLAGS
;
727 if (hdr
->sh_type
!= SHT_NOBITS
)
728 flags
|= SEC_HAS_CONTENTS
;
729 if (hdr
->sh_type
== SHT_GROUP
)
730 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
731 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
734 if (hdr
->sh_type
!= SHT_NOBITS
)
737 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
738 flags
|= SEC_READONLY
;
739 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
741 else if ((flags
& SEC_LOAD
) != 0)
743 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
746 newsect
->entsize
= hdr
->sh_entsize
;
747 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
748 flags
|= SEC_STRINGS
;
750 if (hdr
->sh_flags
& SHF_GROUP
)
751 if (!setup_group (abfd
, hdr
, newsect
))
753 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
754 flags
|= SEC_THREAD_LOCAL
;
756 if ((flags
& SEC_ALLOC
) == 0)
758 /* The debugging sections appear to be recognized only by name,
759 not any sort of flag. Their SEC_ALLOC bits are cleared. */
764 } debug_sections
[] =
766 { "debug", 5 }, /* 'd' */
767 { NULL
, 0 }, /* 'e' */
768 { NULL
, 0 }, /* 'f' */
769 { "gnu.linkonce.wi.", 17 }, /* 'g' */
770 { NULL
, 0 }, /* 'h' */
771 { NULL
, 0 }, /* 'i' */
772 { NULL
, 0 }, /* 'j' */
773 { NULL
, 0 }, /* 'k' */
774 { "line", 4 }, /* 'l' */
775 { NULL
, 0 }, /* 'm' */
776 { NULL
, 0 }, /* 'n' */
777 { NULL
, 0 }, /* 'o' */
778 { NULL
, 0 }, /* 'p' */
779 { NULL
, 0 }, /* 'q' */
780 { NULL
, 0 }, /* 'r' */
781 { "stab", 4 } /* 's' */
786 int i
= name
[1] - 'd';
788 && i
< (int) ARRAY_SIZE (debug_sections
)
789 && debug_sections
[i
].name
!= NULL
790 && strncmp (&name
[1], debug_sections
[i
].name
,
791 debug_sections
[i
].len
) == 0)
792 flags
|= SEC_DEBUGGING
;
796 /* As a GNU extension, if the name begins with .gnu.linkonce, we
797 only link a single copy of the section. This is used to support
798 g++. g++ will emit each template expansion in its own section.
799 The symbols will be defined as weak, so that multiple definitions
800 are permitted. The GNU linker extension is to actually discard
801 all but one of the sections. */
802 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
803 && elf_next_in_group (newsect
) == NULL
)
804 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
806 bed
= get_elf_backend_data (abfd
);
807 if (bed
->elf_backend_section_flags
)
808 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
811 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
814 if ((flags
& SEC_ALLOC
) != 0)
816 Elf_Internal_Phdr
*phdr
;
819 /* Look through the phdrs to see if we need to adjust the lma.
820 If all the p_paddr fields are zero, we ignore them, since
821 some ELF linkers produce such output. */
822 phdr
= elf_tdata (abfd
)->phdr
;
823 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
825 if (phdr
->p_paddr
!= 0)
828 if (i
< elf_elfheader (abfd
)->e_phnum
)
830 phdr
= elf_tdata (abfd
)->phdr
;
831 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
833 /* This section is part of this segment if its file
834 offset plus size lies within the segment's memory
835 span and, if the section is loaded, the extent of the
836 loaded data lies within the extent of the segment.
838 Note - we used to check the p_paddr field as well, and
839 refuse to set the LMA if it was 0. This is wrong
840 though, as a perfectly valid initialised segment can
841 have a p_paddr of zero. Some architectures, eg ARM,
842 place special significance on the address 0 and
843 executables need to be able to have a segment which
844 covers this address. */
845 if (phdr
->p_type
== PT_LOAD
846 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
847 && (hdr
->sh_offset
+ hdr
->sh_size
848 <= phdr
->p_offset
+ phdr
->p_memsz
)
849 && ((flags
& SEC_LOAD
) == 0
850 || (hdr
->sh_offset
+ hdr
->sh_size
851 <= phdr
->p_offset
+ phdr
->p_filesz
)))
853 if ((flags
& SEC_LOAD
) == 0)
854 newsect
->lma
= (phdr
->p_paddr
855 + hdr
->sh_addr
- phdr
->p_vaddr
);
857 /* We used to use the same adjustment for SEC_LOAD
858 sections, but that doesn't work if the segment
859 is packed with code from multiple VMAs.
860 Instead we calculate the section LMA based on
861 the segment LMA. It is assumed that the
862 segment will contain sections with contiguous
863 LMAs, even if the VMAs are not. */
864 newsect
->lma
= (phdr
->p_paddr
865 + hdr
->sh_offset
- phdr
->p_offset
);
867 /* With contiguous segments, we can't tell from file
868 offsets whether a section with zero size should
869 be placed at the end of one segment or the
870 beginning of the next. Decide based on vaddr. */
871 if (hdr
->sh_addr
>= phdr
->p_vaddr
872 && (hdr
->sh_addr
+ hdr
->sh_size
873 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
888 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
891 Helper functions for GDB to locate the string tables.
892 Since BFD hides string tables from callers, GDB needs to use an
893 internal hook to find them. Sun's .stabstr, in particular,
894 isn't even pointed to by the .stab section, so ordinary
895 mechanisms wouldn't work to find it, even if we had some.
898 struct elf_internal_shdr
*
899 bfd_elf_find_section (bfd
*abfd
, char *name
)
901 Elf_Internal_Shdr
**i_shdrp
;
906 i_shdrp
= elf_elfsections (abfd
);
909 shstrtab
= bfd_elf_get_str_section (abfd
,
910 elf_elfheader (abfd
)->e_shstrndx
);
911 if (shstrtab
!= NULL
)
913 max
= elf_numsections (abfd
);
914 for (i
= 1; i
< max
; i
++)
915 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
922 const char *const bfd_elf_section_type_names
[] = {
923 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
924 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
925 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
928 /* ELF relocs are against symbols. If we are producing relocatable
929 output, and the reloc is against an external symbol, and nothing
930 has given us any additional addend, the resulting reloc will also
931 be against the same symbol. In such a case, we don't want to
932 change anything about the way the reloc is handled, since it will
933 all be done at final link time. Rather than put special case code
934 into bfd_perform_relocation, all the reloc types use this howto
935 function. It just short circuits the reloc if producing
936 relocatable output against an external symbol. */
938 bfd_reloc_status_type
939 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
940 arelent
*reloc_entry
,
942 void *data ATTRIBUTE_UNUSED
,
943 asection
*input_section
,
945 char **error_message ATTRIBUTE_UNUSED
)
947 if (output_bfd
!= NULL
948 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
949 && (! reloc_entry
->howto
->partial_inplace
950 || reloc_entry
->addend
== 0))
952 reloc_entry
->address
+= input_section
->output_offset
;
956 return bfd_reloc_continue
;
959 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
962 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
965 BFD_ASSERT (sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
966 sec
->sec_info_type
= ELF_INFO_TYPE_NONE
;
969 /* Finish SHF_MERGE section merging. */
972 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
977 if (!is_elf_hash_table (info
->hash
))
980 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
981 if ((ibfd
->flags
& DYNAMIC
) == 0)
982 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
983 if ((sec
->flags
& SEC_MERGE
) != 0
984 && !bfd_is_abs_section (sec
->output_section
))
986 struct bfd_elf_section_data
*secdata
;
988 secdata
= elf_section_data (sec
);
989 if (! _bfd_add_merge_section (abfd
,
990 &elf_hash_table (info
)->merge_info
,
991 sec
, &secdata
->sec_info
))
993 else if (secdata
->sec_info
)
994 sec
->sec_info_type
= ELF_INFO_TYPE_MERGE
;
997 if (elf_hash_table (info
)->merge_info
!= NULL
)
998 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
999 merge_sections_remove_hook
);
1004 _bfd_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
1006 sec
->output_section
= bfd_abs_section_ptr
;
1007 sec
->output_offset
= sec
->vma
;
1008 if (!is_elf_hash_table (info
->hash
))
1011 sec
->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
1014 /* Copy the program header and other data from one object module to
1018 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1020 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1021 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1024 BFD_ASSERT (!elf_flags_init (obfd
)
1025 || (elf_elfheader (obfd
)->e_flags
1026 == elf_elfheader (ibfd
)->e_flags
));
1028 elf_gp (obfd
) = elf_gp (ibfd
);
1029 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1030 elf_flags_init (obfd
) = TRUE
;
1034 /* Print out the program headers. */
1037 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1040 Elf_Internal_Phdr
*p
;
1042 bfd_byte
*dynbuf
= NULL
;
1044 p
= elf_tdata (abfd
)->phdr
;
1049 fprintf (f
, _("\nProgram Header:\n"));
1050 c
= elf_elfheader (abfd
)->e_phnum
;
1051 for (i
= 0; i
< c
; i
++, p
++)
1058 case PT_NULL
: pt
= "NULL"; break;
1059 case PT_LOAD
: pt
= "LOAD"; break;
1060 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1061 case PT_INTERP
: pt
= "INTERP"; break;
1062 case PT_NOTE
: pt
= "NOTE"; break;
1063 case PT_SHLIB
: pt
= "SHLIB"; break;
1064 case PT_PHDR
: pt
= "PHDR"; break;
1065 case PT_TLS
: pt
= "TLS"; break;
1066 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1067 case PT_GNU_STACK
: pt
= "STACK"; break;
1068 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1069 default: sprintf (buf
, "0x%lx", p
->p_type
); pt
= buf
; break;
1071 fprintf (f
, "%8s off 0x", pt
);
1072 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1073 fprintf (f
, " vaddr 0x");
1074 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1075 fprintf (f
, " paddr 0x");
1076 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1077 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1078 fprintf (f
, " filesz 0x");
1079 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1080 fprintf (f
, " memsz 0x");
1081 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1082 fprintf (f
, " flags %c%c%c",
1083 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1084 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1085 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1086 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1087 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1092 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1096 unsigned long shlink
;
1097 bfd_byte
*extdyn
, *extdynend
;
1099 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1101 fprintf (f
, _("\nDynamic Section:\n"));
1103 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1106 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1109 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1111 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1112 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1115 extdynend
= extdyn
+ s
->size
;
1116 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1118 Elf_Internal_Dyn dyn
;
1121 bfd_boolean stringp
;
1123 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1125 if (dyn
.d_tag
== DT_NULL
)
1132 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1136 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1137 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1138 case DT_PLTGOT
: name
= "PLTGOT"; break;
1139 case DT_HASH
: name
= "HASH"; break;
1140 case DT_STRTAB
: name
= "STRTAB"; break;
1141 case DT_SYMTAB
: name
= "SYMTAB"; break;
1142 case DT_RELA
: name
= "RELA"; break;
1143 case DT_RELASZ
: name
= "RELASZ"; break;
1144 case DT_RELAENT
: name
= "RELAENT"; break;
1145 case DT_STRSZ
: name
= "STRSZ"; break;
1146 case DT_SYMENT
: name
= "SYMENT"; break;
1147 case DT_INIT
: name
= "INIT"; break;
1148 case DT_FINI
: name
= "FINI"; break;
1149 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1150 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1151 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1152 case DT_REL
: name
= "REL"; break;
1153 case DT_RELSZ
: name
= "RELSZ"; break;
1154 case DT_RELENT
: name
= "RELENT"; break;
1155 case DT_PLTREL
: name
= "PLTREL"; break;
1156 case DT_DEBUG
: name
= "DEBUG"; break;
1157 case DT_TEXTREL
: name
= "TEXTREL"; break;
1158 case DT_JMPREL
: name
= "JMPREL"; break;
1159 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1160 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1161 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1162 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1163 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1164 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1165 case DT_FLAGS
: name
= "FLAGS"; break;
1166 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1167 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1168 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1169 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1170 case DT_MOVEENT
: name
= "MOVEENT"; break;
1171 case DT_MOVESZ
: name
= "MOVESZ"; break;
1172 case DT_FEATURE
: name
= "FEATURE"; break;
1173 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1174 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1175 case DT_SYMINENT
: name
= "SYMINENT"; break;
1176 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1177 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1178 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1179 case DT_PLTPAD
: name
= "PLTPAD"; break;
1180 case DT_MOVETAB
: name
= "MOVETAB"; break;
1181 case DT_SYMINFO
: name
= "SYMINFO"; break;
1182 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1183 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1184 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1185 case DT_VERSYM
: name
= "VERSYM"; break;
1186 case DT_VERDEF
: name
= "VERDEF"; break;
1187 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1188 case DT_VERNEED
: name
= "VERNEED"; break;
1189 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1190 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1191 case DT_USED
: name
= "USED"; break;
1192 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1195 fprintf (f
, " %-11s ", name
);
1197 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1201 unsigned int tagv
= dyn
.d_un
.d_val
;
1203 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1206 fprintf (f
, "%s", string
);
1215 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1216 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1218 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1222 if (elf_dynverdef (abfd
) != 0)
1224 Elf_Internal_Verdef
*t
;
1226 fprintf (f
, _("\nVersion definitions:\n"));
1227 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1229 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1230 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
1231 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
1233 Elf_Internal_Verdaux
*a
;
1236 for (a
= t
->vd_auxptr
->vda_nextptr
;
1239 fprintf (f
, "%s ", a
->vda_nodename
);
1245 if (elf_dynverref (abfd
) != 0)
1247 Elf_Internal_Verneed
*t
;
1249 fprintf (f
, _("\nVersion References:\n"));
1250 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1252 Elf_Internal_Vernaux
*a
;
1254 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
1255 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1256 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1257 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
1269 /* Display ELF-specific fields of a symbol. */
1272 bfd_elf_print_symbol (bfd
*abfd
,
1275 bfd_print_symbol_type how
)
1280 case bfd_print_symbol_name
:
1281 fprintf (file
, "%s", symbol
->name
);
1283 case bfd_print_symbol_more
:
1284 fprintf (file
, "elf ");
1285 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1286 fprintf (file
, " %lx", (long) symbol
->flags
);
1288 case bfd_print_symbol_all
:
1290 const char *section_name
;
1291 const char *name
= NULL
;
1292 const struct elf_backend_data
*bed
;
1293 unsigned char st_other
;
1296 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1298 bed
= get_elf_backend_data (abfd
);
1299 if (bed
->elf_backend_print_symbol_all
)
1300 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1304 name
= symbol
->name
;
1305 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1308 fprintf (file
, " %s\t", section_name
);
1309 /* Print the "other" value for a symbol. For common symbols,
1310 we've already printed the size; now print the alignment.
1311 For other symbols, we have no specified alignment, and
1312 we've printed the address; now print the size. */
1313 if (bfd_is_com_section (symbol
->section
))
1314 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1316 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1317 bfd_fprintf_vma (abfd
, file
, val
);
1319 /* If we have version information, print it. */
1320 if (elf_tdata (abfd
)->dynversym_section
!= 0
1321 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1322 || elf_tdata (abfd
)->dynverref_section
!= 0))
1324 unsigned int vernum
;
1325 const char *version_string
;
1327 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1330 version_string
= "";
1331 else if (vernum
== 1)
1332 version_string
= "Base";
1333 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1335 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1338 Elf_Internal_Verneed
*t
;
1340 version_string
= "";
1341 for (t
= elf_tdata (abfd
)->verref
;
1345 Elf_Internal_Vernaux
*a
;
1347 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1349 if (a
->vna_other
== vernum
)
1351 version_string
= a
->vna_nodename
;
1358 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1359 fprintf (file
, " %-11s", version_string
);
1364 fprintf (file
, " (%s)", version_string
);
1365 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1370 /* If the st_other field is not zero, print it. */
1371 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1376 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1377 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1378 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1380 /* Some other non-defined flags are also present, so print
1382 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1385 fprintf (file
, " %s", name
);
1391 /* Create an entry in an ELF linker hash table. */
1393 struct bfd_hash_entry
*
1394 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1395 struct bfd_hash_table
*table
,
1398 /* Allocate the structure if it has not already been allocated by a
1402 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1407 /* Call the allocation method of the superclass. */
1408 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1411 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1412 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1414 /* Set local fields. */
1417 ret
->got
= htab
->init_got_refcount
;
1418 ret
->plt
= htab
->init_plt_refcount
;
1419 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
1420 - offsetof (struct elf_link_hash_entry
, size
)));
1421 /* Assume that we have been called by a non-ELF symbol reader.
1422 This flag is then reset by the code which reads an ELF input
1423 file. This ensures that a symbol created by a non-ELF symbol
1424 reader will have the flag set correctly. */
1431 /* Copy data from an indirect symbol to its direct symbol, hiding the
1432 old indirect symbol. Also used for copying flags to a weakdef. */
1435 _bfd_elf_link_hash_copy_indirect (const struct elf_backend_data
*bed
,
1436 struct elf_link_hash_entry
*dir
,
1437 struct elf_link_hash_entry
*ind
)
1440 bfd_signed_vma lowest_valid
= bed
->can_refcount
;
1442 /* Copy down any references that we may have already seen to the
1443 symbol which just became indirect. */
1445 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1446 dir
->ref_regular
|= ind
->ref_regular
;
1447 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1448 dir
->non_got_ref
|= ind
->non_got_ref
;
1449 dir
->needs_plt
|= ind
->needs_plt
;
1450 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1452 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1455 /* Copy over the global and procedure linkage table refcount entries.
1456 These may have been already set up by a check_relocs routine. */
1457 tmp
= dir
->got
.refcount
;
1458 if (tmp
< lowest_valid
)
1460 dir
->got
.refcount
= ind
->got
.refcount
;
1461 ind
->got
.refcount
= tmp
;
1464 BFD_ASSERT (ind
->got
.refcount
< lowest_valid
);
1466 tmp
= dir
->plt
.refcount
;
1467 if (tmp
< lowest_valid
)
1469 dir
->plt
.refcount
= ind
->plt
.refcount
;
1470 ind
->plt
.refcount
= tmp
;
1473 BFD_ASSERT (ind
->plt
.refcount
< lowest_valid
);
1475 if (dir
->dynindx
== -1)
1477 dir
->dynindx
= ind
->dynindx
;
1478 dir
->dynstr_index
= ind
->dynstr_index
;
1480 ind
->dynstr_index
= 0;
1483 BFD_ASSERT (ind
->dynindx
== -1);
1487 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
1488 struct elf_link_hash_entry
*h
,
1489 bfd_boolean force_local
)
1491 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
1495 h
->forced_local
= 1;
1496 if (h
->dynindx
!= -1)
1499 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1505 /* Initialize an ELF linker hash table. */
1508 _bfd_elf_link_hash_table_init
1509 (struct elf_link_hash_table
*table
,
1511 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
1512 struct bfd_hash_table
*,
1516 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
1518 table
->dynamic_sections_created
= FALSE
;
1519 table
->dynobj
= NULL
;
1520 table
->init_got_refcount
.refcount
= can_refcount
- 1;
1521 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
1522 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
1523 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
1524 /* The first dynamic symbol is a dummy. */
1525 table
->dynsymcount
= 1;
1526 table
->dynstr
= NULL
;
1527 table
->bucketcount
= 0;
1528 table
->needed
= NULL
;
1530 table
->merge_info
= NULL
;
1531 memset (&table
->stab_info
, 0, sizeof (table
->stab_info
));
1532 memset (&table
->eh_info
, 0, sizeof (table
->eh_info
));
1533 table
->dynlocal
= NULL
;
1534 table
->runpath
= NULL
;
1535 table
->tls_sec
= NULL
;
1536 table
->tls_size
= 0;
1537 table
->loaded
= NULL
;
1538 table
->is_relocatable_executable
= FALSE
;
1540 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
1541 table
->root
.type
= bfd_link_elf_hash_table
;
1546 /* Create an ELF linker hash table. */
1548 struct bfd_link_hash_table
*
1549 _bfd_elf_link_hash_table_create (bfd
*abfd
)
1551 struct elf_link_hash_table
*ret
;
1552 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1554 ret
= bfd_malloc (amt
);
1558 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
1567 /* This is a hook for the ELF emulation code in the generic linker to
1568 tell the backend linker what file name to use for the DT_NEEDED
1569 entry for a dynamic object. */
1572 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
1574 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1575 && bfd_get_format (abfd
) == bfd_object
)
1576 elf_dt_name (abfd
) = name
;
1580 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
1583 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1584 && bfd_get_format (abfd
) == bfd_object
)
1585 lib_class
= elf_dyn_lib_class (abfd
);
1592 bfd_elf_set_dyn_lib_class (bfd
*abfd
, int lib_class
)
1594 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1595 && bfd_get_format (abfd
) == bfd_object
)
1596 elf_dyn_lib_class (abfd
) = lib_class
;
1599 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1600 the linker ELF emulation code. */
1602 struct bfd_link_needed_list
*
1603 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1604 struct bfd_link_info
*info
)
1606 if (! is_elf_hash_table (info
->hash
))
1608 return elf_hash_table (info
)->needed
;
1611 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1612 hook for the linker ELF emulation code. */
1614 struct bfd_link_needed_list
*
1615 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1616 struct bfd_link_info
*info
)
1618 if (! is_elf_hash_table (info
->hash
))
1620 return elf_hash_table (info
)->runpath
;
1623 /* Get the name actually used for a dynamic object for a link. This
1624 is the SONAME entry if there is one. Otherwise, it is the string
1625 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1628 bfd_elf_get_dt_soname (bfd
*abfd
)
1630 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1631 && bfd_get_format (abfd
) == bfd_object
)
1632 return elf_dt_name (abfd
);
1636 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1637 the ELF linker emulation code. */
1640 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
1641 struct bfd_link_needed_list
**pneeded
)
1644 bfd_byte
*dynbuf
= NULL
;
1646 unsigned long shlink
;
1647 bfd_byte
*extdyn
, *extdynend
;
1649 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1653 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1654 || bfd_get_format (abfd
) != bfd_object
)
1657 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1658 if (s
== NULL
|| s
->size
== 0)
1661 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1664 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1668 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1670 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1671 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1674 extdynend
= extdyn
+ s
->size
;
1675 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1677 Elf_Internal_Dyn dyn
;
1679 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1681 if (dyn
.d_tag
== DT_NULL
)
1684 if (dyn
.d_tag
== DT_NEEDED
)
1687 struct bfd_link_needed_list
*l
;
1688 unsigned int tagv
= dyn
.d_un
.d_val
;
1691 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1696 l
= bfd_alloc (abfd
, amt
);
1717 /* Allocate an ELF string table--force the first byte to be zero. */
1719 struct bfd_strtab_hash
*
1720 _bfd_elf_stringtab_init (void)
1722 struct bfd_strtab_hash
*ret
;
1724 ret
= _bfd_stringtab_init ();
1729 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1730 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1731 if (loc
== (bfd_size_type
) -1)
1733 _bfd_stringtab_free (ret
);
1740 /* ELF .o/exec file reading */
1742 /* Create a new bfd section from an ELF section header. */
1745 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1747 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1748 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1749 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1752 name
= bfd_elf_string_from_elf_section (abfd
,
1753 elf_elfheader (abfd
)->e_shstrndx
,
1758 switch (hdr
->sh_type
)
1761 /* Inactive section. Throw it away. */
1764 case SHT_PROGBITS
: /* Normal section with contents. */
1765 case SHT_NOBITS
: /* .bss section. */
1766 case SHT_HASH
: /* .hash section. */
1767 case SHT_NOTE
: /* .note section. */
1768 case SHT_INIT_ARRAY
: /* .init_array section. */
1769 case SHT_FINI_ARRAY
: /* .fini_array section. */
1770 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1771 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1772 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1774 case SHT_DYNAMIC
: /* Dynamic linking information. */
1775 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1777 if (hdr
->sh_link
> elf_numsections (abfd
)
1778 || elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1780 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1782 Elf_Internal_Shdr
*dynsymhdr
;
1784 /* The shared libraries distributed with hpux11 have a bogus
1785 sh_link field for the ".dynamic" section. Find the
1786 string table for the ".dynsym" section instead. */
1787 if (elf_dynsymtab (abfd
) != 0)
1789 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1790 hdr
->sh_link
= dynsymhdr
->sh_link
;
1794 unsigned int i
, num_sec
;
1796 num_sec
= elf_numsections (abfd
);
1797 for (i
= 1; i
< num_sec
; i
++)
1799 dynsymhdr
= elf_elfsections (abfd
)[i
];
1800 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1802 hdr
->sh_link
= dynsymhdr
->sh_link
;
1810 case SHT_SYMTAB
: /* A symbol table */
1811 if (elf_onesymtab (abfd
) == shindex
)
1814 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1816 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1817 elf_onesymtab (abfd
) = shindex
;
1818 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1819 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1820 abfd
->flags
|= HAS_SYMS
;
1822 /* Sometimes a shared object will map in the symbol table. If
1823 SHF_ALLOC is set, and this is a shared object, then we also
1824 treat this section as a BFD section. We can not base the
1825 decision purely on SHF_ALLOC, because that flag is sometimes
1826 set in a relocatable object file, which would confuse the
1828 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1829 && (abfd
->flags
& DYNAMIC
) != 0
1830 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1834 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1835 can't read symbols without that section loaded as well. It
1836 is most likely specified by the next section header. */
1837 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1839 unsigned int i
, num_sec
;
1841 num_sec
= elf_numsections (abfd
);
1842 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1844 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1845 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1846 && hdr2
->sh_link
== shindex
)
1850 for (i
= 1; i
< shindex
; i
++)
1852 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1853 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1854 && hdr2
->sh_link
== shindex
)
1858 return bfd_section_from_shdr (abfd
, i
);
1862 case SHT_DYNSYM
: /* A dynamic symbol table */
1863 if (elf_dynsymtab (abfd
) == shindex
)
1866 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1868 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1869 elf_dynsymtab (abfd
) = shindex
;
1870 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1871 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1872 abfd
->flags
|= HAS_SYMS
;
1874 /* Besides being a symbol table, we also treat this as a regular
1875 section, so that objcopy can handle it. */
1876 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1878 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1879 if (elf_symtab_shndx (abfd
) == shindex
)
1882 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1883 elf_symtab_shndx (abfd
) = shindex
;
1884 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1885 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1888 case SHT_STRTAB
: /* A string table */
1889 if (hdr
->bfd_section
!= NULL
)
1891 if (ehdr
->e_shstrndx
== shindex
)
1893 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1894 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1897 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1900 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1901 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1904 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1907 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1908 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1909 elf_elfsections (abfd
)[shindex
] = hdr
;
1910 /* We also treat this as a regular section, so that objcopy
1912 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1916 /* If the string table isn't one of the above, then treat it as a
1917 regular section. We need to scan all the headers to be sure,
1918 just in case this strtab section appeared before the above. */
1919 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1921 unsigned int i
, num_sec
;
1923 num_sec
= elf_numsections (abfd
);
1924 for (i
= 1; i
< num_sec
; i
++)
1926 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1927 if (hdr2
->sh_link
== shindex
)
1929 /* Prevent endless recursion on broken objects. */
1932 if (! bfd_section_from_shdr (abfd
, i
))
1934 if (elf_onesymtab (abfd
) == i
)
1936 if (elf_dynsymtab (abfd
) == i
)
1937 goto dynsymtab_strtab
;
1941 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1945 /* *These* do a lot of work -- but build no sections! */
1947 asection
*target_sect
;
1948 Elf_Internal_Shdr
*hdr2
;
1949 unsigned int num_sec
= elf_numsections (abfd
);
1952 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1953 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1956 /* Check for a bogus link to avoid crashing. */
1957 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1958 || hdr
->sh_link
>= num_sec
)
1960 ((*_bfd_error_handler
)
1961 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1962 abfd
, hdr
->sh_link
, name
, shindex
));
1963 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1967 /* For some incomprehensible reason Oracle distributes
1968 libraries for Solaris in which some of the objects have
1969 bogus sh_link fields. It would be nice if we could just
1970 reject them, but, unfortunately, some people need to use
1971 them. We scan through the section headers; if we find only
1972 one suitable symbol table, we clobber the sh_link to point
1973 to it. I hope this doesn't break anything. */
1974 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1975 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1981 for (scan
= 1; scan
< num_sec
; scan
++)
1983 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1984 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1995 hdr
->sh_link
= found
;
1998 /* Get the symbol table. */
1999 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2000 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2001 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2004 /* If this reloc section does not use the main symbol table we
2005 don't treat it as a reloc section. BFD can't adequately
2006 represent such a section, so at least for now, we don't
2007 try. We just present it as a normal section. We also
2008 can't use it as a reloc section if it points to the null
2010 if (hdr
->sh_link
!= elf_onesymtab (abfd
) || hdr
->sh_info
== SHN_UNDEF
)
2011 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2014 /* Prevent endless recursion on broken objects. */
2015 if (elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2016 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2018 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2020 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2021 if (target_sect
== NULL
)
2024 if ((target_sect
->flags
& SEC_RELOC
) == 0
2025 || target_sect
->reloc_count
== 0)
2026 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
2030 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
2031 amt
= sizeof (*hdr2
);
2032 hdr2
= bfd_alloc (abfd
, amt
);
2033 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
2036 elf_elfsections (abfd
)[shindex
] = hdr2
;
2037 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2038 target_sect
->flags
|= SEC_RELOC
;
2039 target_sect
->relocation
= NULL
;
2040 target_sect
->rel_filepos
= hdr
->sh_offset
;
2041 /* In the section to which the relocations apply, mark whether
2042 its relocations are of the REL or RELA variety. */
2043 if (hdr
->sh_size
!= 0)
2044 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
2045 abfd
->flags
|= HAS_RELOC
;
2050 case SHT_GNU_verdef
:
2051 elf_dynverdef (abfd
) = shindex
;
2052 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2053 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2056 case SHT_GNU_versym
:
2057 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2059 elf_dynversym (abfd
) = shindex
;
2060 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2061 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2064 case SHT_GNU_verneed
:
2065 elf_dynverref (abfd
) = shindex
;
2066 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2067 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2074 /* We need a BFD section for objcopy and relocatable linking,
2075 and it's handy to have the signature available as the section
2077 if (hdr
->sh_entsize
!= GRP_ENTRY_SIZE
)
2079 name
= group_signature (abfd
, hdr
);
2082 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2084 if (hdr
->contents
!= NULL
)
2086 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2087 unsigned int n_elt
= hdr
->sh_size
/ 4;
2090 if (idx
->flags
& GRP_COMDAT
)
2091 hdr
->bfd_section
->flags
2092 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2094 /* We try to keep the same section order as it comes in. */
2096 while (--n_elt
!= 0)
2097 if ((s
= (--idx
)->shdr
->bfd_section
) != NULL
2098 && elf_next_in_group (s
) != NULL
)
2100 elf_next_in_group (hdr
->bfd_section
) = s
;
2107 /* Check for any processor-specific section types. */
2108 return bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
,
2115 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2116 Return SEC for sections that have no elf section, and NULL on error. */
2119 bfd_section_from_r_symndx (bfd
*abfd
,
2120 struct sym_sec_cache
*cache
,
2122 unsigned long r_symndx
)
2124 Elf_Internal_Shdr
*symtab_hdr
;
2125 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2126 Elf_External_Sym_Shndx eshndx
;
2127 Elf_Internal_Sym isym
;
2128 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2130 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
2131 return cache
->sec
[ent
];
2133 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2134 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2135 &isym
, esym
, &eshndx
) == NULL
)
2138 if (cache
->abfd
!= abfd
)
2140 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2143 cache
->indx
[ent
] = r_symndx
;
2144 cache
->sec
[ent
] = sec
;
2145 if ((isym
.st_shndx
!= SHN_UNDEF
&& isym
.st_shndx
< SHN_LORESERVE
)
2146 || isym
.st_shndx
> SHN_HIRESERVE
)
2149 s
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
2151 cache
->sec
[ent
] = s
;
2153 return cache
->sec
[ent
];
2156 /* Given an ELF section number, retrieve the corresponding BFD
2160 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
2162 if (index
>= elf_numsections (abfd
))
2164 return elf_elfsections (abfd
)[index
]->bfd_section
;
2167 static struct bfd_elf_special_section
const special_sections_b
[] =
2169 { ".bss", 4, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2170 { NULL
, 0, 0, 0, 0 }
2173 static struct bfd_elf_special_section
const special_sections_c
[] =
2175 { ".comment", 8, 0, SHT_PROGBITS
, 0 },
2176 { NULL
, 0, 0, 0, 0 }
2179 static struct bfd_elf_special_section
const special_sections_d
[] =
2181 { ".data", 5, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2182 { ".data1", 6, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2183 { ".debug", 6, 0, SHT_PROGBITS
, 0 },
2184 { ".debug_line", 11, 0, SHT_PROGBITS
, 0 },
2185 { ".debug_info", 11, 0, SHT_PROGBITS
, 0 },
2186 { ".debug_abbrev", 13, 0, SHT_PROGBITS
, 0 },
2187 { ".debug_aranges", 14, 0, SHT_PROGBITS
, 0 },
2188 { ".dynamic", 8, 0, SHT_DYNAMIC
, SHF_ALLOC
},
2189 { ".dynstr", 7, 0, SHT_STRTAB
, SHF_ALLOC
},
2190 { ".dynsym", 7, 0, SHT_DYNSYM
, SHF_ALLOC
},
2191 { NULL
, 0, 0, 0, 0 }
2194 static struct bfd_elf_special_section
const special_sections_f
[] =
2196 { ".fini", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2197 { ".fini_array", 11, 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2198 { NULL
, 0, 0, 0, 0 }
2201 static struct bfd_elf_special_section
const special_sections_g
[] =
2203 { ".gnu.linkonce.b",15, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2204 { ".got", 4, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2205 { ".gnu.version", 12, 0, SHT_GNU_versym
, 0 },
2206 { ".gnu.version_d", 14, 0, SHT_GNU_verdef
, 0 },
2207 { ".gnu.version_r", 14, 0, SHT_GNU_verneed
, 0 },
2208 { ".gnu.liblist", 12, 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2209 { ".gnu.conflict", 13, 0, SHT_RELA
, SHF_ALLOC
},
2210 { NULL
, 0, 0, 0, 0 }
2213 static struct bfd_elf_special_section
const special_sections_h
[] =
2215 { ".hash", 5, 0, SHT_HASH
, SHF_ALLOC
},
2216 { NULL
, 0, 0, 0, 0 }
2219 static struct bfd_elf_special_section
const special_sections_i
[] =
2221 { ".init", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2222 { ".init_array", 11, 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2223 { ".interp", 7, 0, SHT_PROGBITS
, 0 },
2224 { NULL
, 0, 0, 0, 0 }
2227 static struct bfd_elf_special_section
const special_sections_l
[] =
2229 { ".line", 5, 0, SHT_PROGBITS
, 0 },
2230 { NULL
, 0, 0, 0, 0 }
2233 static struct bfd_elf_special_section
const special_sections_n
[] =
2235 { ".note.GNU-stack",15, 0, SHT_PROGBITS
, 0 },
2236 { ".note", 5, -1, SHT_NOTE
, 0 },
2237 { NULL
, 0, 0, 0, 0 }
2240 static struct bfd_elf_special_section
const special_sections_p
[] =
2242 { ".preinit_array", 14, 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2243 { ".plt", 4, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2244 { NULL
, 0, 0, 0, 0 }
2247 static struct bfd_elf_special_section
const special_sections_r
[] =
2249 { ".rodata", 7, -2, SHT_PROGBITS
, SHF_ALLOC
},
2250 { ".rodata1", 8, 0, SHT_PROGBITS
, SHF_ALLOC
},
2251 { ".rela", 5, -1, SHT_RELA
, 0 },
2252 { ".rel", 4, -1, SHT_REL
, 0 },
2253 { NULL
, 0, 0, 0, 0 }
2256 static struct bfd_elf_special_section
const special_sections_s
[] =
2258 { ".shstrtab", 9, 0, SHT_STRTAB
, 0 },
2259 { ".strtab", 7, 0, SHT_STRTAB
, 0 },
2260 { ".symtab", 7, 0, SHT_SYMTAB
, 0 },
2261 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2262 { NULL
, 0, 0, 0, 0 }
2265 static struct bfd_elf_special_section
const special_sections_t
[] =
2267 { ".text", 5, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2268 { ".tbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2269 { ".tdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2270 { NULL
, 0, 0, 0, 0 }
2273 static struct bfd_elf_special_section
const *special_sections
[] =
2275 special_sections_b
, /* 'b' */
2276 special_sections_c
, /* 'b' */
2277 special_sections_d
, /* 'd' */
2279 special_sections_f
, /* 'f' */
2280 special_sections_g
, /* 'g' */
2281 special_sections_h
, /* 'h' */
2282 special_sections_i
, /* 'i' */
2285 special_sections_l
, /* 'l' */
2287 special_sections_n
, /* 'n' */
2289 special_sections_p
, /* 'p' */
2291 special_sections_r
, /* 'r' */
2292 special_sections_s
, /* 's' */
2293 special_sections_t
, /* 't' */
2296 const struct bfd_elf_special_section
*
2297 _bfd_elf_get_special_section (const char *name
,
2298 const struct bfd_elf_special_section
*spec
,
2304 len
= strlen (name
);
2306 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2309 int prefix_len
= spec
[i
].prefix_length
;
2311 if (len
< prefix_len
)
2313 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2316 suffix_len
= spec
[i
].suffix_length
;
2317 if (suffix_len
<= 0)
2319 if (name
[prefix_len
] != 0)
2321 if (suffix_len
== 0)
2323 if (name
[prefix_len
] != '.'
2324 && (suffix_len
== -2
2325 || (rela
&& spec
[i
].type
== SHT_REL
)))
2331 if (len
< prefix_len
+ suffix_len
)
2333 if (memcmp (name
+ len
- suffix_len
,
2334 spec
[i
].prefix
+ prefix_len
,
2344 const struct bfd_elf_special_section
*
2345 _bfd_elf_get_sec_type_attr (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
)
2348 const struct bfd_elf_special_section
*spec
;
2350 /* See if this is one of the special sections. */
2351 if (sec
->name
== NULL
)
2354 if (sec
->name
[0] != '.')
2357 i
= sec
->name
[1] - 'b';
2358 if (i
< 0 || i
> 't' - 'b')
2361 spec
= special_sections
[i
];
2366 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2370 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2372 struct bfd_elf_section_data
*sdata
;
2373 const struct elf_backend_data
*bed
;
2374 const struct bfd_elf_special_section
*ssect
;
2376 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2379 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2382 sec
->used_by_bfd
= sdata
;
2385 /* Indicate whether or not this section should use RELA relocations. */
2386 bed
= get_elf_backend_data (abfd
);
2387 sec
->use_rela_p
= bed
->default_use_rela_p
;
2389 /* When we read a file, we don't need section type and flags unless
2390 it is a linker created section. They will be overridden in
2391 _bfd_elf_make_section_from_shdr anyway. */
2392 if (abfd
->direction
!= read_direction
2393 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2395 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2398 elf_section_type (sec
) = ssect
->type
;
2399 elf_section_flags (sec
) = ssect
->attr
;
2406 /* Create a new bfd section from an ELF program header.
2408 Since program segments have no names, we generate a synthetic name
2409 of the form segment<NUM>, where NUM is generally the index in the
2410 program header table. For segments that are split (see below) we
2411 generate the names segment<NUM>a and segment<NUM>b.
2413 Note that some program segments may have a file size that is different than
2414 (less than) the memory size. All this means is that at execution the
2415 system must allocate the amount of memory specified by the memory size,
2416 but only initialize it with the first "file size" bytes read from the
2417 file. This would occur for example, with program segments consisting
2418 of combined data+bss.
2420 To handle the above situation, this routine generates TWO bfd sections
2421 for the single program segment. The first has the length specified by
2422 the file size of the segment, and the second has the length specified
2423 by the difference between the two sizes. In effect, the segment is split
2424 into it's initialized and uninitialized parts.
2429 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2430 Elf_Internal_Phdr
*hdr
,
2432 const char *typename
)
2440 split
= ((hdr
->p_memsz
> 0)
2441 && (hdr
->p_filesz
> 0)
2442 && (hdr
->p_memsz
> hdr
->p_filesz
));
2443 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2444 len
= strlen (namebuf
) + 1;
2445 name
= bfd_alloc (abfd
, len
);
2448 memcpy (name
, namebuf
, len
);
2449 newsect
= bfd_make_section (abfd
, name
);
2450 if (newsect
== NULL
)
2452 newsect
->vma
= hdr
->p_vaddr
;
2453 newsect
->lma
= hdr
->p_paddr
;
2454 newsect
->size
= hdr
->p_filesz
;
2455 newsect
->filepos
= hdr
->p_offset
;
2456 newsect
->flags
|= SEC_HAS_CONTENTS
;
2457 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2458 if (hdr
->p_type
== PT_LOAD
)
2460 newsect
->flags
|= SEC_ALLOC
;
2461 newsect
->flags
|= SEC_LOAD
;
2462 if (hdr
->p_flags
& PF_X
)
2464 /* FIXME: all we known is that it has execute PERMISSION,
2466 newsect
->flags
|= SEC_CODE
;
2469 if (!(hdr
->p_flags
& PF_W
))
2471 newsect
->flags
|= SEC_READONLY
;
2476 sprintf (namebuf
, "%s%db", typename
, index
);
2477 len
= strlen (namebuf
) + 1;
2478 name
= bfd_alloc (abfd
, len
);
2481 memcpy (name
, namebuf
, len
);
2482 newsect
= bfd_make_section (abfd
, name
);
2483 if (newsect
== NULL
)
2485 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2486 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2487 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2488 if (hdr
->p_type
== PT_LOAD
)
2490 newsect
->flags
|= SEC_ALLOC
;
2491 if (hdr
->p_flags
& PF_X
)
2492 newsect
->flags
|= SEC_CODE
;
2494 if (!(hdr
->p_flags
& PF_W
))
2495 newsect
->flags
|= SEC_READONLY
;
2502 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2504 const struct elf_backend_data
*bed
;
2506 switch (hdr
->p_type
)
2509 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2512 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2515 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2518 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2521 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2523 if (! elfcore_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2528 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2531 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2533 case PT_GNU_EH_FRAME
:
2534 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2538 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2541 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2544 /* Check for any processor-specific program segment types. */
2545 bed
= get_elf_backend_data (abfd
);
2546 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, index
, "proc");
2550 /* Initialize REL_HDR, the section-header for new section, containing
2551 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2552 relocations; otherwise, we use REL relocations. */
2555 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2556 Elf_Internal_Shdr
*rel_hdr
,
2558 bfd_boolean use_rela_p
)
2561 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2562 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2564 name
= bfd_alloc (abfd
, amt
);
2567 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2569 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2571 if (rel_hdr
->sh_name
== (unsigned int) -1)
2573 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2574 rel_hdr
->sh_entsize
= (use_rela_p
2575 ? bed
->s
->sizeof_rela
2576 : bed
->s
->sizeof_rel
);
2577 rel_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
2578 rel_hdr
->sh_flags
= 0;
2579 rel_hdr
->sh_addr
= 0;
2580 rel_hdr
->sh_size
= 0;
2581 rel_hdr
->sh_offset
= 0;
2586 /* Set up an ELF internal section header for a section. */
2589 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2591 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2592 bfd_boolean
*failedptr
= failedptrarg
;
2593 Elf_Internal_Shdr
*this_hdr
;
2597 /* We already failed; just get out of the bfd_map_over_sections
2602 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2604 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2605 asect
->name
, FALSE
);
2606 if (this_hdr
->sh_name
== (unsigned int) -1)
2612 this_hdr
->sh_flags
= 0;
2614 if ((asect
->flags
& SEC_ALLOC
) != 0
2615 || asect
->user_set_vma
)
2616 this_hdr
->sh_addr
= asect
->vma
;
2618 this_hdr
->sh_addr
= 0;
2620 this_hdr
->sh_offset
= 0;
2621 this_hdr
->sh_size
= asect
->size
;
2622 this_hdr
->sh_link
= 0;
2623 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2624 /* The sh_entsize and sh_info fields may have been set already by
2625 copy_private_section_data. */
2627 this_hdr
->bfd_section
= asect
;
2628 this_hdr
->contents
= NULL
;
2630 /* If the section type is unspecified, we set it based on
2632 if (this_hdr
->sh_type
== SHT_NULL
)
2634 if ((asect
->flags
& SEC_GROUP
) != 0)
2636 /* We also need to mark SHF_GROUP here for relocatable
2638 struct bfd_link_order
*l
;
2641 for (l
= asect
->map_head
.link_order
; l
!= NULL
; l
= l
->next
)
2642 if (l
->type
== bfd_indirect_link_order
2643 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2646 /* The name is not important. Anything will do. */
2647 elf_group_name (elt
->output_section
) = "G";
2648 elf_section_flags (elt
->output_section
) |= SHF_GROUP
;
2650 elt
= elf_next_in_group (elt
);
2651 /* During a relocatable link, the lists are
2654 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2656 this_hdr
->sh_type
= SHT_GROUP
;
2658 else if ((asect
->flags
& SEC_ALLOC
) != 0
2659 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2660 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2661 this_hdr
->sh_type
= SHT_NOBITS
;
2663 this_hdr
->sh_type
= SHT_PROGBITS
;
2666 switch (this_hdr
->sh_type
)
2672 case SHT_INIT_ARRAY
:
2673 case SHT_FINI_ARRAY
:
2674 case SHT_PREINIT_ARRAY
:
2681 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2685 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2689 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2693 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2694 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2698 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2699 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2702 case SHT_GNU_versym
:
2703 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2706 case SHT_GNU_verdef
:
2707 this_hdr
->sh_entsize
= 0;
2708 /* objcopy or strip will copy over sh_info, but may not set
2709 cverdefs. The linker will set cverdefs, but sh_info will be
2711 if (this_hdr
->sh_info
== 0)
2712 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2714 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2715 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2718 case SHT_GNU_verneed
:
2719 this_hdr
->sh_entsize
= 0;
2720 /* objcopy or strip will copy over sh_info, but may not set
2721 cverrefs. The linker will set cverrefs, but sh_info will be
2723 if (this_hdr
->sh_info
== 0)
2724 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2726 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2727 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2731 this_hdr
->sh_entsize
= 4;
2735 if ((asect
->flags
& SEC_ALLOC
) != 0)
2736 this_hdr
->sh_flags
|= SHF_ALLOC
;
2737 if ((asect
->flags
& SEC_READONLY
) == 0)
2738 this_hdr
->sh_flags
|= SHF_WRITE
;
2739 if ((asect
->flags
& SEC_CODE
) != 0)
2740 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2741 if ((asect
->flags
& SEC_MERGE
) != 0)
2743 this_hdr
->sh_flags
|= SHF_MERGE
;
2744 this_hdr
->sh_entsize
= asect
->entsize
;
2745 if ((asect
->flags
& SEC_STRINGS
) != 0)
2746 this_hdr
->sh_flags
|= SHF_STRINGS
;
2748 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2749 this_hdr
->sh_flags
|= SHF_GROUP
;
2750 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2752 this_hdr
->sh_flags
|= SHF_TLS
;
2753 if (asect
->size
== 0 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2755 struct bfd_link_order
*o
;
2757 this_hdr
->sh_size
= 0;
2758 for (o
= asect
->map_head
.link_order
; o
!= NULL
; o
= o
->next
)
2759 if (this_hdr
->sh_size
< o
->offset
+ o
->size
)
2760 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2761 if (this_hdr
->sh_size
)
2762 this_hdr
->sh_type
= SHT_NOBITS
;
2766 /* Check for processor-specific section types. */
2767 if (bed
->elf_backend_fake_sections
2768 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2771 /* If the section has relocs, set up a section header for the
2772 SHT_REL[A] section. If two relocation sections are required for
2773 this section, it is up to the processor-specific back-end to
2774 create the other. */
2775 if ((asect
->flags
& SEC_RELOC
) != 0
2776 && !_bfd_elf_init_reloc_shdr (abfd
,
2777 &elf_section_data (asect
)->rel_hdr
,
2783 /* Fill in the contents of a SHT_GROUP section. */
2786 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2788 bfd_boolean
*failedptr
= failedptrarg
;
2789 unsigned long symindx
;
2790 asection
*elt
, *first
;
2792 struct bfd_link_order
*l
;
2795 /* Ignore linker created group section. See elfNN_ia64_object_p in
2797 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2802 if (elf_group_id (sec
) != NULL
)
2803 symindx
= elf_group_id (sec
)->udata
.i
;
2807 /* If called from the assembler, swap_out_syms will have set up
2808 elf_section_syms; If called for "ld -r", use target_index. */
2809 if (elf_section_syms (abfd
) != NULL
)
2810 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2812 symindx
= sec
->target_index
;
2814 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2816 /* The contents won't be allocated for "ld -r" or objcopy. */
2818 if (sec
->contents
== NULL
)
2821 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2823 /* Arrange for the section to be written out. */
2824 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2825 if (sec
->contents
== NULL
)
2832 loc
= sec
->contents
+ sec
->size
;
2834 /* Get the pointer to the first section in the group that gas
2835 squirreled away here. objcopy arranges for this to be set to the
2836 start of the input section group. */
2837 first
= elt
= elf_next_in_group (sec
);
2839 /* First element is a flag word. Rest of section is elf section
2840 indices for all the sections of the group. Write them backwards
2841 just to keep the group in the same order as given in .section
2842 directives, not that it matters. */
2851 s
= s
->output_section
;
2854 idx
= elf_section_data (s
)->this_idx
;
2855 H_PUT_32 (abfd
, idx
, loc
);
2856 elt
= elf_next_in_group (elt
);
2861 /* If this is a relocatable link, then the above did nothing because
2862 SEC is the output section. Look through the input sections
2864 for (l
= sec
->map_head
.link_order
; l
!= NULL
; l
= l
->next
)
2865 if (l
->type
== bfd_indirect_link_order
2866 && (elt
= elf_next_in_group (l
->u
.indirect
.section
)) != NULL
)
2871 elf_section_data (elt
->output_section
)->this_idx
, loc
);
2872 elt
= elf_next_in_group (elt
);
2873 /* During a relocatable link, the lists are circular. */
2875 while (elt
!= elf_next_in_group (l
->u
.indirect
.section
));
2877 if ((loc
-= 4) != sec
->contents
)
2880 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2883 /* Assign all ELF section numbers. The dummy first section is handled here
2884 too. The link/info pointers for the standard section types are filled
2885 in here too, while we're at it. */
2888 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2890 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2892 unsigned int section_number
, secn
;
2893 Elf_Internal_Shdr
**i_shdrp
;
2895 struct bfd_elf_section_data
*d
;
2899 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2901 /* SHT_GROUP sections are in relocatable files only. */
2902 if (link_info
== NULL
|| link_info
->relocatable
)
2904 /* Put SHT_GROUP sections first. */
2905 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2907 d
= elf_section_data (sec
);
2909 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2911 if (sec
->flags
& SEC_LINKER_CREATED
)
2913 /* Remove the linker created SHT_GROUP sections. */
2914 bfd_section_list_remove (abfd
, sec
);
2915 abfd
->section_count
--;
2919 if (section_number
== SHN_LORESERVE
)
2920 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2921 d
->this_idx
= section_number
++;
2927 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2929 d
= elf_section_data (sec
);
2931 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2933 if (section_number
== SHN_LORESERVE
)
2934 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2935 d
->this_idx
= section_number
++;
2937 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2938 if ((sec
->flags
& SEC_RELOC
) == 0)
2942 if (section_number
== SHN_LORESERVE
)
2943 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2944 d
->rel_idx
= section_number
++;
2945 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2950 if (section_number
== SHN_LORESERVE
)
2951 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2952 d
->rel_idx2
= section_number
++;
2953 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2959 if (section_number
== SHN_LORESERVE
)
2960 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2961 t
->shstrtab_section
= section_number
++;
2962 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2963 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2965 if (bfd_get_symcount (abfd
) > 0)
2967 if (section_number
== SHN_LORESERVE
)
2968 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2969 t
->symtab_section
= section_number
++;
2970 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2971 if (section_number
> SHN_LORESERVE
- 2)
2973 if (section_number
== SHN_LORESERVE
)
2974 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2975 t
->symtab_shndx_section
= section_number
++;
2976 t
->symtab_shndx_hdr
.sh_name
2977 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2978 ".symtab_shndx", FALSE
);
2979 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2982 if (section_number
== SHN_LORESERVE
)
2983 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2984 t
->strtab_section
= section_number
++;
2985 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2988 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2989 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2991 elf_numsections (abfd
) = section_number
;
2992 elf_elfheader (abfd
)->e_shnum
= section_number
;
2993 if (section_number
> SHN_LORESERVE
)
2994 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2996 /* Set up the list of section header pointers, in agreement with the
2998 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
2999 i_shdrp
= bfd_zalloc (abfd
, amt
);
3000 if (i_shdrp
== NULL
)
3003 amt
= sizeof (Elf_Internal_Shdr
);
3004 i_shdrp
[0] = bfd_zalloc (abfd
, amt
);
3005 if (i_shdrp
[0] == NULL
)
3007 bfd_release (abfd
, i_shdrp
);
3011 elf_elfsections (abfd
) = i_shdrp
;
3013 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
3014 if (bfd_get_symcount (abfd
) > 0)
3016 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
3017 if (elf_numsections (abfd
) > SHN_LORESERVE
)
3019 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
3020 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
3022 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
3023 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
3026 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3028 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
3032 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3033 if (d
->rel_idx
!= 0)
3034 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
3035 if (d
->rel_idx2
!= 0)
3036 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
3038 /* Fill in the sh_link and sh_info fields while we're at it. */
3040 /* sh_link of a reloc section is the section index of the symbol
3041 table. sh_info is the section index of the section to which
3042 the relocation entries apply. */
3043 if (d
->rel_idx
!= 0)
3045 d
->rel_hdr
.sh_link
= t
->symtab_section
;
3046 d
->rel_hdr
.sh_info
= d
->this_idx
;
3048 if (d
->rel_idx2
!= 0)
3050 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
3051 d
->rel_hdr2
->sh_info
= d
->this_idx
;
3054 /* We need to set up sh_link for SHF_LINK_ORDER. */
3055 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3057 s
= elf_linked_to_section (sec
);
3059 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3062 struct bfd_link_order
*p
;
3064 /* Find out what the corresponding section in output
3066 for (p
= sec
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
3068 s
= p
->u
.indirect
.section
;
3069 if (p
->type
== bfd_indirect_link_order
3070 && (bfd_get_flavour (s
->owner
)
3071 == bfd_target_elf_flavour
))
3073 Elf_Internal_Shdr
** const elf_shdrp
3074 = elf_elfsections (s
->owner
);
3076 = _bfd_elf_section_from_bfd_section (s
->owner
, s
);
3077 elfsec
= elf_shdrp
[elfsec
]->sh_link
;
3079 The Intel C compiler generates SHT_IA_64_UNWIND with
3080 SHF_LINK_ORDER. But it doesn't set the sh_link or
3081 sh_info fields. Hence we could get the situation
3082 where elfsec is 0. */
3085 const struct elf_backend_data
*bed
3086 = get_elf_backend_data (abfd
);
3087 if (bed
->link_order_error_handler
)
3088 bed
->link_order_error_handler
3089 (_("%B: warning: sh_link not set for section `%A'"),
3094 s
= elf_shdrp
[elfsec
]->bfd_section
;
3095 if (elf_discarded_section (s
))
3098 (*_bfd_error_handler
)
3099 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3100 abfd
, d
->this_hdr
.bfd_section
,
3102 /* Point to the kept section if it has
3103 the same size as the discarded
3105 kept
= _bfd_elf_check_kept_section (s
);
3108 bfd_set_error (bfd_error_bad_value
);
3113 s
= s
->output_section
;
3114 BFD_ASSERT (s
!= NULL
);
3115 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3123 switch (d
->this_hdr
.sh_type
)
3127 /* A reloc section which we are treating as a normal BFD
3128 section. sh_link is the section index of the symbol
3129 table. sh_info is the section index of the section to
3130 which the relocation entries apply. We assume that an
3131 allocated reloc section uses the dynamic symbol table.
3132 FIXME: How can we be sure? */
3133 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3135 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3137 /* We look up the section the relocs apply to by name. */
3139 if (d
->this_hdr
.sh_type
== SHT_REL
)
3143 s
= bfd_get_section_by_name (abfd
, name
);
3145 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3149 /* We assume that a section named .stab*str is a stabs
3150 string section. We look for a section with the same name
3151 but without the trailing ``str'', and set its sh_link
3152 field to point to this section. */
3153 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
3154 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3159 len
= strlen (sec
->name
);
3160 alc
= bfd_malloc (len
- 2);
3163 memcpy (alc
, sec
->name
, len
- 3);
3164 alc
[len
- 3] = '\0';
3165 s
= bfd_get_section_by_name (abfd
, alc
);
3169 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3171 /* This is a .stab section. */
3172 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3173 elf_section_data (s
)->this_hdr
.sh_entsize
3174 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3181 case SHT_GNU_verneed
:
3182 case SHT_GNU_verdef
:
3183 /* sh_link is the section header index of the string table
3184 used for the dynamic entries, or the symbol table, or the
3186 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3188 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3191 case SHT_GNU_LIBLIST
:
3192 /* sh_link is the section header index of the prelink library
3194 used for the dynamic entries, or the symbol table, or the
3196 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3197 ? ".dynstr" : ".gnu.libstr");
3199 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3203 case SHT_GNU_versym
:
3204 /* sh_link is the section header index of the symbol table
3205 this hash table or version table is for. */
3206 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3208 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3212 d
->this_hdr
.sh_link
= t
->symtab_section
;
3216 for (secn
= 1; secn
< section_number
; ++secn
)
3217 if (i_shdrp
[secn
] == NULL
)
3218 i_shdrp
[secn
] = i_shdrp
[0];
3220 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3221 i_shdrp
[secn
]->sh_name
);
3225 /* Map symbol from it's internal number to the external number, moving
3226 all local symbols to be at the head of the list. */
3229 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3231 /* If the backend has a special mapping, use it. */
3232 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3233 if (bed
->elf_backend_sym_is_global
)
3234 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3236 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
3237 || bfd_is_und_section (bfd_get_section (sym
))
3238 || bfd_is_com_section (bfd_get_section (sym
)));
3242 elf_map_symbols (bfd
*abfd
)
3244 unsigned int symcount
= bfd_get_symcount (abfd
);
3245 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3246 asymbol
**sect_syms
;
3247 unsigned int num_locals
= 0;
3248 unsigned int num_globals
= 0;
3249 unsigned int num_locals2
= 0;
3250 unsigned int num_globals2
= 0;
3258 fprintf (stderr
, "elf_map_symbols\n");
3262 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3264 if (max_index
< asect
->index
)
3265 max_index
= asect
->index
;
3269 amt
= max_index
* sizeof (asymbol
*);
3270 sect_syms
= bfd_zalloc (abfd
, amt
);
3271 if (sect_syms
== NULL
)
3273 elf_section_syms (abfd
) = sect_syms
;
3274 elf_num_section_syms (abfd
) = max_index
;
3276 /* Init sect_syms entries for any section symbols we have already
3277 decided to output. */
3278 for (idx
= 0; idx
< symcount
; idx
++)
3280 asymbol
*sym
= syms
[idx
];
3282 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3289 if (sec
->owner
!= NULL
)
3291 if (sec
->owner
!= abfd
)
3293 if (sec
->output_offset
!= 0)
3296 sec
= sec
->output_section
;
3298 /* Empty sections in the input files may have had a
3299 section symbol created for them. (See the comment
3300 near the end of _bfd_generic_link_output_symbols in
3301 linker.c). If the linker script discards such
3302 sections then we will reach this point. Since we know
3303 that we cannot avoid this case, we detect it and skip
3304 the abort and the assignment to the sect_syms array.
3305 To reproduce this particular case try running the
3306 linker testsuite test ld-scripts/weak.exp for an ELF
3307 port that uses the generic linker. */
3308 if (sec
->owner
== NULL
)
3311 BFD_ASSERT (sec
->owner
== abfd
);
3313 sect_syms
[sec
->index
] = syms
[idx
];
3318 /* Classify all of the symbols. */
3319 for (idx
= 0; idx
< symcount
; idx
++)
3321 if (!sym_is_global (abfd
, syms
[idx
]))
3327 /* We will be adding a section symbol for each BFD section. Most normal
3328 sections will already have a section symbol in outsymbols, but
3329 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3330 at least in that case. */
3331 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3333 if (sect_syms
[asect
->index
] == NULL
)
3335 if (!sym_is_global (abfd
, asect
->symbol
))
3342 /* Now sort the symbols so the local symbols are first. */
3343 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
3344 new_syms
= bfd_alloc (abfd
, amt
);
3346 if (new_syms
== NULL
)
3349 for (idx
= 0; idx
< symcount
; idx
++)
3351 asymbol
*sym
= syms
[idx
];
3354 if (!sym_is_global (abfd
, sym
))
3357 i
= num_locals
+ num_globals2
++;
3359 sym
->udata
.i
= i
+ 1;
3361 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3363 if (sect_syms
[asect
->index
] == NULL
)
3365 asymbol
*sym
= asect
->symbol
;
3368 sect_syms
[asect
->index
] = sym
;
3369 if (!sym_is_global (abfd
, sym
))
3372 i
= num_locals
+ num_globals2
++;
3374 sym
->udata
.i
= i
+ 1;
3378 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3380 elf_num_locals (abfd
) = num_locals
;
3381 elf_num_globals (abfd
) = num_globals
;
3385 /* Align to the maximum file alignment that could be required for any
3386 ELF data structure. */
3388 static inline file_ptr
3389 align_file_position (file_ptr off
, int align
)
3391 return (off
+ align
- 1) & ~(align
- 1);
3394 /* Assign a file position to a section, optionally aligning to the
3395 required section alignment. */
3398 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3406 al
= i_shdrp
->sh_addralign
;
3408 offset
= BFD_ALIGN (offset
, al
);
3410 i_shdrp
->sh_offset
= offset
;
3411 if (i_shdrp
->bfd_section
!= NULL
)
3412 i_shdrp
->bfd_section
->filepos
= offset
;
3413 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3414 offset
+= i_shdrp
->sh_size
;
3418 /* Compute the file positions we are going to put the sections at, and
3419 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3420 is not NULL, this is being called by the ELF backend linker. */
3423 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3424 struct bfd_link_info
*link_info
)
3426 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3428 struct bfd_strtab_hash
*strtab
= NULL
;
3429 Elf_Internal_Shdr
*shstrtab_hdr
;
3431 if (abfd
->output_has_begun
)
3434 /* Do any elf backend specific processing first. */
3435 if (bed
->elf_backend_begin_write_processing
)
3436 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3438 if (! prep_headers (abfd
))
3441 /* Post process the headers if necessary. */
3442 if (bed
->elf_backend_post_process_headers
)
3443 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3446 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3450 if (!assign_section_numbers (abfd
, link_info
))
3453 /* The backend linker builds symbol table information itself. */
3454 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3456 /* Non-zero if doing a relocatable link. */
3457 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3459 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3463 if (link_info
== NULL
)
3465 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3470 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3471 /* sh_name was set in prep_headers. */
3472 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3473 shstrtab_hdr
->sh_flags
= 0;
3474 shstrtab_hdr
->sh_addr
= 0;
3475 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3476 shstrtab_hdr
->sh_entsize
= 0;
3477 shstrtab_hdr
->sh_link
= 0;
3478 shstrtab_hdr
->sh_info
= 0;
3479 /* sh_offset is set in assign_file_positions_except_relocs. */
3480 shstrtab_hdr
->sh_addralign
= 1;
3482 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3485 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3488 Elf_Internal_Shdr
*hdr
;
3490 off
= elf_tdata (abfd
)->next_file_pos
;
3492 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3493 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3495 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3496 if (hdr
->sh_size
!= 0)
3497 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3499 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3500 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3502 elf_tdata (abfd
)->next_file_pos
= off
;
3504 /* Now that we know where the .strtab section goes, write it
3506 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3507 || ! _bfd_stringtab_emit (abfd
, strtab
))
3509 _bfd_stringtab_free (strtab
);
3512 abfd
->output_has_begun
= TRUE
;
3517 /* Create a mapping from a set of sections to a program segment. */
3519 static struct elf_segment_map
*
3520 make_mapping (bfd
*abfd
,
3521 asection
**sections
,
3526 struct elf_segment_map
*m
;
3531 amt
= sizeof (struct elf_segment_map
);
3532 amt
+= (to
- from
- 1) * sizeof (asection
*);
3533 m
= bfd_zalloc (abfd
, amt
);
3537 m
->p_type
= PT_LOAD
;
3538 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3539 m
->sections
[i
- from
] = *hdrpp
;
3540 m
->count
= to
- from
;
3542 if (from
== 0 && phdr
)
3544 /* Include the headers in the first PT_LOAD segment. */
3545 m
->includes_filehdr
= 1;
3546 m
->includes_phdrs
= 1;
3552 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3555 struct elf_segment_map
*
3556 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3558 struct elf_segment_map
*m
;
3560 m
= bfd_zalloc (abfd
, sizeof (struct elf_segment_map
));
3564 m
->p_type
= PT_DYNAMIC
;
3566 m
->sections
[0] = dynsec
;
3571 /* Set up a mapping from BFD sections to program segments. */
3574 map_sections_to_segments (bfd
*abfd
)
3576 asection
**sections
= NULL
;
3580 struct elf_segment_map
*mfirst
;
3581 struct elf_segment_map
**pm
;
3582 struct elf_segment_map
*m
;
3585 unsigned int phdr_index
;
3586 bfd_vma maxpagesize
;
3588 bfd_boolean phdr_in_segment
= TRUE
;
3589 bfd_boolean writable
;
3591 asection
*first_tls
= NULL
;
3592 asection
*dynsec
, *eh_frame_hdr
;
3595 if (elf_tdata (abfd
)->segment_map
!= NULL
)
3598 if (bfd_count_sections (abfd
) == 0)
3601 /* Select the allocated sections, and sort them. */
3603 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
3604 sections
= bfd_malloc (amt
);
3605 if (sections
== NULL
)
3609 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3611 if ((s
->flags
& SEC_ALLOC
) != 0)
3617 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3620 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3622 /* Build the mapping. */
3627 /* If we have a .interp section, then create a PT_PHDR segment for
3628 the program headers and a PT_INTERP segment for the .interp
3630 s
= bfd_get_section_by_name (abfd
, ".interp");
3631 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3633 amt
= sizeof (struct elf_segment_map
);
3634 m
= bfd_zalloc (abfd
, amt
);
3638 m
->p_type
= PT_PHDR
;
3639 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3640 m
->p_flags
= PF_R
| PF_X
;
3641 m
->p_flags_valid
= 1;
3642 m
->includes_phdrs
= 1;
3647 amt
= sizeof (struct elf_segment_map
);
3648 m
= bfd_zalloc (abfd
, amt
);
3652 m
->p_type
= PT_INTERP
;
3660 /* Look through the sections. We put sections in the same program
3661 segment when the start of the second section can be placed within
3662 a few bytes of the end of the first section. */
3666 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
3668 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3670 && (dynsec
->flags
& SEC_LOAD
) == 0)
3673 /* Deal with -Ttext or something similar such that the first section
3674 is not adjacent to the program headers. This is an
3675 approximation, since at this point we don't know exactly how many
3676 program headers we will need. */
3679 bfd_size_type phdr_size
;
3681 phdr_size
= elf_tdata (abfd
)->program_header_size
;
3683 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
3684 if ((abfd
->flags
& D_PAGED
) == 0
3685 || sections
[0]->lma
< phdr_size
3686 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3687 phdr_in_segment
= FALSE
;
3690 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3693 bfd_boolean new_segment
;
3697 /* See if this section and the last one will fit in the same
3700 if (last_hdr
== NULL
)
3702 /* If we don't have a segment yet, then we don't need a new
3703 one (we build the last one after this loop). */
3704 new_segment
= FALSE
;
3706 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3708 /* If this section has a different relation between the
3709 virtual address and the load address, then we need a new
3713 else if (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
3714 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3716 /* If putting this section in this segment would force us to
3717 skip a page in the segment, then we need a new segment. */
3720 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3721 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3723 /* We don't want to put a loadable section after a
3724 nonloadable section in the same segment.
3725 Consider .tbss sections as loadable for this purpose. */
3728 else if ((abfd
->flags
& D_PAGED
) == 0)
3730 /* If the file is not demand paged, which means that we
3731 don't require the sections to be correctly aligned in the
3732 file, then there is no other reason for a new segment. */
3733 new_segment
= FALSE
;
3736 && (hdr
->flags
& SEC_READONLY
) == 0
3737 && (((last_hdr
->lma
+ last_size
- 1)
3738 & ~(maxpagesize
- 1))
3739 != (hdr
->lma
& ~(maxpagesize
- 1))))
3741 /* We don't want to put a writable section in a read only
3742 segment, unless they are on the same page in memory
3743 anyhow. We already know that the last section does not
3744 bring us past the current section on the page, so the
3745 only case in which the new section is not on the same
3746 page as the previous section is when the previous section
3747 ends precisely on a page boundary. */
3752 /* Otherwise, we can use the same segment. */
3753 new_segment
= FALSE
;
3758 if ((hdr
->flags
& SEC_READONLY
) == 0)
3761 /* .tbss sections effectively have zero size. */
3762 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3763 last_size
= hdr
->size
;
3769 /* We need a new program segment. We must create a new program
3770 header holding all the sections from phdr_index until hdr. */
3772 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3779 if ((hdr
->flags
& SEC_READONLY
) == 0)
3785 /* .tbss sections effectively have zero size. */
3786 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3787 last_size
= hdr
->size
;
3791 phdr_in_segment
= FALSE
;
3794 /* Create a final PT_LOAD program segment. */
3795 if (last_hdr
!= NULL
)
3797 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3805 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3808 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3815 /* For each loadable .note section, add a PT_NOTE segment. We don't
3816 use bfd_get_section_by_name, because if we link together
3817 nonloadable .note sections and loadable .note sections, we will
3818 generate two .note sections in the output file. FIXME: Using
3819 names for section types is bogus anyhow. */
3820 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3822 if ((s
->flags
& SEC_LOAD
) != 0
3823 && strncmp (s
->name
, ".note", 5) == 0)
3825 amt
= sizeof (struct elf_segment_map
);
3826 m
= bfd_zalloc (abfd
, amt
);
3830 m
->p_type
= PT_NOTE
;
3837 if (s
->flags
& SEC_THREAD_LOCAL
)
3845 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3850 amt
= sizeof (struct elf_segment_map
);
3851 amt
+= (tls_count
- 1) * sizeof (asection
*);
3852 m
= bfd_zalloc (abfd
, amt
);
3857 m
->count
= tls_count
;
3858 /* Mandated PF_R. */
3860 m
->p_flags_valid
= 1;
3861 for (i
= 0; i
< tls_count
; ++i
)
3863 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3864 m
->sections
[i
] = first_tls
;
3865 first_tls
= first_tls
->next
;
3872 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3874 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3875 if (eh_frame_hdr
!= NULL
3876 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3878 amt
= sizeof (struct elf_segment_map
);
3879 m
= bfd_zalloc (abfd
, amt
);
3883 m
->p_type
= PT_GNU_EH_FRAME
;
3885 m
->sections
[0] = eh_frame_hdr
->output_section
;
3891 if (elf_tdata (abfd
)->stack_flags
)
3893 amt
= sizeof (struct elf_segment_map
);
3894 m
= bfd_zalloc (abfd
, amt
);
3898 m
->p_type
= PT_GNU_STACK
;
3899 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3900 m
->p_flags_valid
= 1;
3906 if (elf_tdata (abfd
)->relro
)
3908 amt
= sizeof (struct elf_segment_map
);
3909 m
= bfd_zalloc (abfd
, amt
);
3913 m
->p_type
= PT_GNU_RELRO
;
3915 m
->p_flags_valid
= 1;
3924 elf_tdata (abfd
)->segment_map
= mfirst
;
3928 if (sections
!= NULL
)
3933 /* Sort sections by address. */
3936 elf_sort_sections (const void *arg1
, const void *arg2
)
3938 const asection
*sec1
= *(const asection
**) arg1
;
3939 const asection
*sec2
= *(const asection
**) arg2
;
3940 bfd_size_type size1
, size2
;
3942 /* Sort by LMA first, since this is the address used to
3943 place the section into a segment. */
3944 if (sec1
->lma
< sec2
->lma
)
3946 else if (sec1
->lma
> sec2
->lma
)
3949 /* Then sort by VMA. Normally the LMA and the VMA will be
3950 the same, and this will do nothing. */
3951 if (sec1
->vma
< sec2
->vma
)
3953 else if (sec1
->vma
> sec2
->vma
)
3956 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3958 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3964 /* If the indicies are the same, do not return 0
3965 here, but continue to try the next comparison. */
3966 if (sec1
->target_index
- sec2
->target_index
!= 0)
3967 return sec1
->target_index
- sec2
->target_index
;
3972 else if (TOEND (sec2
))
3977 /* Sort by size, to put zero sized sections
3978 before others at the same address. */
3980 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
3981 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
3988 return sec1
->target_index
- sec2
->target_index
;
3991 /* Ian Lance Taylor writes:
3993 We shouldn't be using % with a negative signed number. That's just
3994 not good. We have to make sure either that the number is not
3995 negative, or that the number has an unsigned type. When the types
3996 are all the same size they wind up as unsigned. When file_ptr is a
3997 larger signed type, the arithmetic winds up as signed long long,
4000 What we're trying to say here is something like ``increase OFF by
4001 the least amount that will cause it to be equal to the VMA modulo
4003 /* In other words, something like:
4005 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4006 off_offset = off % bed->maxpagesize;
4007 if (vma_offset < off_offset)
4008 adjustment = vma_offset + bed->maxpagesize - off_offset;
4010 adjustment = vma_offset - off_offset;
4012 which can can be collapsed into the expression below. */
4015 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4017 return ((vma
- off
) % maxpagesize
);
4020 /* Assign file positions to the sections based on the mapping from
4021 sections to segments. This function also sets up some fields in
4022 the file header, and writes out the program headers. */
4025 assign_file_positions_for_segments (bfd
*abfd
, struct bfd_link_info
*link_info
)
4027 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4029 struct elf_segment_map
*m
;
4031 Elf_Internal_Phdr
*phdrs
;
4033 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4034 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4035 Elf_Internal_Phdr
*p
;
4038 if (elf_tdata (abfd
)->segment_map
== NULL
)
4040 if (! map_sections_to_segments (abfd
))
4045 /* The placement algorithm assumes that non allocated sections are
4046 not in PT_LOAD segments. We ensure this here by removing such
4047 sections from the segment map. We also remove excluded
4049 for (m
= elf_tdata (abfd
)->segment_map
;
4053 unsigned int new_count
;
4057 for (i
= 0; i
< m
->count
; i
++)
4059 if ((m
->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4060 && ((m
->sections
[i
]->flags
& SEC_ALLOC
) != 0
4061 || m
->p_type
!= PT_LOAD
))
4064 m
->sections
[new_count
] = m
->sections
[i
];
4070 if (new_count
!= m
->count
)
4071 m
->count
= new_count
;
4075 if (bed
->elf_backend_modify_segment_map
)
4077 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
, link_info
))
4082 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4085 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4086 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4087 elf_elfheader (abfd
)->e_phnum
= count
;
4091 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4095 /* If we already counted the number of program segments, make sure
4096 that we allocated enough space. This happens when SIZEOF_HEADERS
4097 is used in a linker script. */
4098 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
4099 if (alloc
!= 0 && count
> alloc
)
4101 ((*_bfd_error_handler
)
4102 (_("%B: Not enough room for program headers (allocated %u, need %u)"),
4103 abfd
, alloc
, count
));
4104 bfd_set_error (bfd_error_bad_value
);
4111 amt
= alloc
* sizeof (Elf_Internal_Phdr
);
4112 phdrs
= bfd_alloc (abfd
, amt
);
4116 off
= bed
->s
->sizeof_ehdr
;
4117 off
+= alloc
* bed
->s
->sizeof_phdr
;
4124 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4131 /* If elf_segment_map is not from map_sections_to_segments, the
4132 sections may not be correctly ordered. NOTE: sorting should
4133 not be done to the PT_NOTE section of a corefile, which may
4134 contain several pseudo-sections artificially created by bfd.
4135 Sorting these pseudo-sections breaks things badly. */
4137 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4138 && m
->p_type
== PT_NOTE
))
4139 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4142 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4143 number of sections with contents contributing to both p_filesz
4144 and p_memsz, followed by a number of sections with no contents
4145 that just contribute to p_memsz. In this loop, OFF tracks next
4146 available file offset for PT_LOAD and PT_NOTE segments. VOFF is
4147 an adjustment we use for segments that have no file contents
4148 but need zero filled memory allocation. */
4150 p
->p_type
= m
->p_type
;
4151 p
->p_flags
= m
->p_flags
;
4153 if (p
->p_type
== PT_LOAD
4156 bfd_size_type align
;
4158 unsigned int align_power
= 0;
4160 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4162 unsigned int secalign
;
4164 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4165 if (secalign
> align_power
)
4166 align_power
= secalign
;
4168 align
= (bfd_size_type
) 1 << align_power
;
4170 if ((abfd
->flags
& D_PAGED
) != 0 && bed
->maxpagesize
> align
)
4171 align
= bed
->maxpagesize
;
4173 adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4176 && !m
->includes_filehdr
4177 && !m
->includes_phdrs
4178 && (ufile_ptr
) off
>= align
)
4180 /* If the first section isn't loadable, the same holds for
4181 any other sections. Since the segment won't need file
4182 space, we can make p_offset overlap some prior segment.
4183 However, .tbss is special. If a segment starts with
4184 .tbss, we need to look at the next section to decide
4185 whether the segment has any loadable sections. */
4187 while ((m
->sections
[i
]->flags
& SEC_LOAD
) == 0)
4189 if ((m
->sections
[i
]->flags
& SEC_THREAD_LOCAL
) == 0
4193 voff
= adjust
- align
;
4199 /* Make sure the .dynamic section is the first section in the
4200 PT_DYNAMIC segment. */
4201 else if (p
->p_type
== PT_DYNAMIC
4203 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4206 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4208 bfd_set_error (bfd_error_bad_value
);
4215 p
->p_vaddr
= m
->sections
[0]->vma
;
4217 if (m
->p_paddr_valid
)
4218 p
->p_paddr
= m
->p_paddr
;
4219 else if (m
->count
== 0)
4222 p
->p_paddr
= m
->sections
[0]->lma
;
4224 if (p
->p_type
== PT_LOAD
4225 && (abfd
->flags
& D_PAGED
) != 0)
4226 p
->p_align
= bed
->maxpagesize
;
4227 else if (m
->count
== 0)
4228 p
->p_align
= 1 << bed
->s
->log_file_align
;
4236 if (m
->includes_filehdr
)
4238 if (! m
->p_flags_valid
)
4241 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4242 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4245 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4247 if (p
->p_vaddr
< (bfd_vma
) off
)
4249 (*_bfd_error_handler
)
4250 (_("%B: Not enough room for program headers, try linking with -N"),
4252 bfd_set_error (bfd_error_bad_value
);
4257 if (! m
->p_paddr_valid
)
4260 if (p
->p_type
== PT_LOAD
)
4262 filehdr_vaddr
= p
->p_vaddr
;
4263 filehdr_paddr
= p
->p_paddr
;
4267 if (m
->includes_phdrs
)
4269 if (! m
->p_flags_valid
)
4272 if (m
->includes_filehdr
)
4274 if (p
->p_type
== PT_LOAD
)
4276 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
4277 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
4282 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4286 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4287 p
->p_vaddr
-= off
- p
->p_offset
;
4288 if (! m
->p_paddr_valid
)
4289 p
->p_paddr
-= off
- p
->p_offset
;
4292 if (p
->p_type
== PT_LOAD
)
4294 phdrs_vaddr
= p
->p_vaddr
;
4295 phdrs_paddr
= p
->p_paddr
;
4298 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4301 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4302 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4305 if (p
->p_type
== PT_LOAD
4306 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4308 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
4309 p
->p_offset
= off
+ voff
;
4314 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4315 p
->p_filesz
+= adjust
;
4316 p
->p_memsz
+= adjust
;
4320 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4324 bfd_size_type align
;
4328 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
4330 if (p
->p_type
== PT_LOAD
4331 || p
->p_type
== PT_TLS
)
4333 bfd_signed_vma adjust
;
4335 if ((flags
& SEC_LOAD
) != 0)
4337 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_filesz
);
4340 (*_bfd_error_handler
)
4341 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4342 abfd
, sec
, (unsigned long) sec
->lma
);
4346 p
->p_filesz
+= adjust
;
4347 p
->p_memsz
+= adjust
;
4349 /* .tbss is special. It doesn't contribute to p_memsz of
4351 else if ((flags
& SEC_THREAD_LOCAL
) == 0
4352 || p
->p_type
== PT_TLS
)
4354 /* The section VMA must equal the file position
4355 modulo the page size. */
4356 bfd_size_type page
= align
;
4357 if ((abfd
->flags
& D_PAGED
) != 0 && bed
->maxpagesize
> page
)
4358 page
= bed
->maxpagesize
;
4359 adjust
= vma_page_aligned_bias (sec
->vma
,
4360 p
->p_vaddr
+ p
->p_memsz
,
4362 p
->p_memsz
+= adjust
;
4366 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4368 /* The section at i == 0 is the one that actually contains
4374 p
->p_filesz
= sec
->size
;
4380 /* The rest are fake sections that shouldn't be written. */
4389 if (p
->p_type
== PT_LOAD
)
4392 /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4393 1997, and the exact reason for it isn't clear. One
4394 plausible explanation is that it is to work around
4395 a problem we have with linker scripts using data
4396 statements in NOLOAD sections. I don't think it
4397 makes a great deal of sense to have such a section
4398 assigned to a PT_LOAD segment, but apparently
4399 people do this. The data statement results in a
4400 bfd_data_link_order being built, and these need
4401 section contents to write into. Eventually, we get
4402 to _bfd_elf_write_object_contents which writes any
4403 section with contents to the output. Make room
4404 here for the write, so that following segments are
4406 if ((flags
& SEC_LOAD
) != 0
4407 || (flags
& SEC_HAS_CONTENTS
) != 0)
4411 if ((flags
& SEC_LOAD
) != 0)
4413 p
->p_filesz
+= sec
->size
;
4414 p
->p_memsz
+= sec
->size
;
4416 /* PR ld/594: Sections in note segments which are not loaded
4417 contribute to the file size but not the in-memory size. */
4418 else if (p
->p_type
== PT_NOTE
4419 && (flags
& SEC_HAS_CONTENTS
) != 0)
4420 p
->p_filesz
+= sec
->size
;
4422 /* .tbss is special. It doesn't contribute to p_memsz of
4424 else if ((flags
& SEC_THREAD_LOCAL
) == 0
4425 || p
->p_type
== PT_TLS
)
4426 p
->p_memsz
+= sec
->size
;
4428 if (p
->p_type
== PT_TLS
4430 && (sec
->flags
& SEC_HAS_CONTENTS
) == 0)
4432 struct bfd_link_order
*o
;
4433 bfd_vma tbss_size
= 0;
4435 for (o
= sec
->map_head
.link_order
; o
!= NULL
; o
= o
->next
)
4436 if (tbss_size
< o
->offset
+ o
->size
)
4437 tbss_size
= o
->offset
+ o
->size
;
4439 p
->p_memsz
+= tbss_size
;
4442 if (align
> p
->p_align
4443 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
4447 if (! m
->p_flags_valid
)
4450 if ((flags
& SEC_CODE
) != 0)
4452 if ((flags
& SEC_READONLY
) == 0)
4458 /* Now that we have set the section file positions, we can set up
4459 the file positions for the non PT_LOAD segments. */
4460 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4464 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
4466 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
4467 /* If the section has not yet been assigned a file position,
4468 do so now. The ARM BPABI requires that .dynamic section
4469 not be marked SEC_ALLOC because it is not part of any
4470 PT_LOAD segment, so it will not be processed above. */
4471 if (p
->p_type
== PT_DYNAMIC
&& m
->sections
[0]->filepos
== 0)
4474 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4477 while (i_shdrpp
[i
]->bfd_section
!= m
->sections
[0])
4479 off
= (_bfd_elf_assign_file_position_for_section
4480 (i_shdrpp
[i
], off
, TRUE
));
4481 p
->p_filesz
= m
->sections
[0]->size
;
4483 p
->p_offset
= m
->sections
[0]->filepos
;
4487 if (m
->includes_filehdr
)
4489 p
->p_vaddr
= filehdr_vaddr
;
4490 if (! m
->p_paddr_valid
)
4491 p
->p_paddr
= filehdr_paddr
;
4493 else if (m
->includes_phdrs
)
4495 p
->p_vaddr
= phdrs_vaddr
;
4496 if (! m
->p_paddr_valid
)
4497 p
->p_paddr
= phdrs_paddr
;
4499 else if (p
->p_type
== PT_GNU_RELRO
)
4501 Elf_Internal_Phdr
*lp
;
4503 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4505 if (lp
->p_type
== PT_LOAD
4506 && lp
->p_vaddr
<= link_info
->relro_end
4507 && lp
->p_vaddr
>= link_info
->relro_start
4508 && lp
->p_vaddr
+ lp
->p_filesz
4509 >= link_info
->relro_end
)
4513 if (lp
< phdrs
+ count
4514 && link_info
->relro_end
> lp
->p_vaddr
)
4516 p
->p_vaddr
= lp
->p_vaddr
;
4517 p
->p_paddr
= lp
->p_paddr
;
4518 p
->p_offset
= lp
->p_offset
;
4519 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4520 p
->p_memsz
= p
->p_filesz
;
4522 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4526 memset (p
, 0, sizeof *p
);
4527 p
->p_type
= PT_NULL
;
4533 /* Clear out any program headers we allocated but did not use. */
4534 for (; count
< alloc
; count
++, p
++)
4536 memset (p
, 0, sizeof *p
);
4537 p
->p_type
= PT_NULL
;
4540 elf_tdata (abfd
)->phdr
= phdrs
;
4542 elf_tdata (abfd
)->next_file_pos
= off
;
4544 /* Write out the program headers. */
4545 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4546 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
4552 /* Get the size of the program header.
4554 If this is called by the linker before any of the section VMA's are set, it
4555 can't calculate the correct value for a strange memory layout. This only
4556 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4557 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4558 data segment (exclusive of .interp and .dynamic).
4560 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4561 will be two segments. */
4563 static bfd_size_type
4564 get_program_header_size (bfd
*abfd
)
4568 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4570 /* We can't return a different result each time we're called. */
4571 if (elf_tdata (abfd
)->program_header_size
!= 0)
4572 return elf_tdata (abfd
)->program_header_size
;
4574 if (elf_tdata (abfd
)->segment_map
!= NULL
)
4576 struct elf_segment_map
*m
;
4579 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4581 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4582 return elf_tdata (abfd
)->program_header_size
;
4585 /* Assume we will need exactly two PT_LOAD segments: one for text
4586 and one for data. */
4589 s
= bfd_get_section_by_name (abfd
, ".interp");
4590 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4592 /* If we have a loadable interpreter section, we need a
4593 PT_INTERP segment. In this case, assume we also need a
4594 PT_PHDR segment, although that may not be true for all
4599 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4601 /* We need a PT_DYNAMIC segment. */
4605 if (elf_tdata (abfd
)->eh_frame_hdr
)
4607 /* We need a PT_GNU_EH_FRAME segment. */
4611 if (elf_tdata (abfd
)->stack_flags
)
4613 /* We need a PT_GNU_STACK segment. */
4617 if (elf_tdata (abfd
)->relro
)
4619 /* We need a PT_GNU_RELRO segment. */
4623 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4625 if ((s
->flags
& SEC_LOAD
) != 0
4626 && strncmp (s
->name
, ".note", 5) == 0)
4628 /* We need a PT_NOTE segment. */
4633 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4635 if (s
->flags
& SEC_THREAD_LOCAL
)
4637 /* We need a PT_TLS segment. */
4643 /* Let the backend count up any program headers it might need. */
4644 if (bed
->elf_backend_additional_program_headers
)
4648 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
4654 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
4655 return elf_tdata (abfd
)->program_header_size
;
4658 /* Work out the file positions of all the sections. This is called by
4659 _bfd_elf_compute_section_file_positions. All the section sizes and
4660 VMAs must be known before this is called.
4662 Reloc sections come in two flavours: Those processed specially as
4663 "side-channel" data attached to a section to which they apply, and
4664 those that bfd doesn't process as relocations. The latter sort are
4665 stored in a normal bfd section by bfd_section_from_shdr. We don't
4666 consider the former sort here, unless they form part of the loadable
4667 image. Reloc sections not assigned here will be handled later by
4668 assign_file_positions_for_relocs.
4670 We also don't set the positions of the .symtab and .strtab here. */
4673 assign_file_positions_except_relocs (bfd
*abfd
,
4674 struct bfd_link_info
*link_info
)
4676 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
4677 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
4678 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4679 unsigned int num_sec
= elf_numsections (abfd
);
4681 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4683 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4684 && bfd_get_format (abfd
) != bfd_core
)
4686 Elf_Internal_Shdr
**hdrpp
;
4689 /* Start after the ELF header. */
4690 off
= i_ehdrp
->e_ehsize
;
4692 /* We are not creating an executable, which means that we are
4693 not creating a program header, and that the actual order of
4694 the sections in the file is unimportant. */
4695 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4697 Elf_Internal_Shdr
*hdr
;
4700 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4701 && hdr
->bfd_section
== NULL
)
4702 || i
== tdata
->symtab_section
4703 || i
== tdata
->symtab_shndx_section
4704 || i
== tdata
->strtab_section
)
4706 hdr
->sh_offset
= -1;
4709 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4711 if (i
== SHN_LORESERVE
- 1)
4713 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4714 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4721 Elf_Internal_Shdr
**hdrpp
;
4723 /* Assign file positions for the loaded sections based on the
4724 assignment of sections to segments. */
4725 if (! assign_file_positions_for_segments (abfd
, link_info
))
4728 /* Assign file positions for the other sections. */
4730 off
= elf_tdata (abfd
)->next_file_pos
;
4731 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4733 Elf_Internal_Shdr
*hdr
;
4736 if (hdr
->bfd_section
!= NULL
4737 && hdr
->bfd_section
->filepos
!= 0)
4738 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
4739 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4741 ((*_bfd_error_handler
)
4742 (_("%B: warning: allocated section `%s' not in segment"),
4744 (hdr
->bfd_section
== NULL
4746 : hdr
->bfd_section
->name
)));
4747 if ((abfd
->flags
& D_PAGED
) != 0)
4748 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4751 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4753 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4756 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4757 && hdr
->bfd_section
== NULL
)
4758 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4759 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4760 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4761 hdr
->sh_offset
= -1;
4763 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4765 if (i
== SHN_LORESERVE
- 1)
4767 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4768 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4773 /* Place the section headers. */
4774 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4775 i_ehdrp
->e_shoff
= off
;
4776 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4778 elf_tdata (abfd
)->next_file_pos
= off
;
4784 prep_headers (bfd
*abfd
)
4786 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4787 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4788 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4789 struct elf_strtab_hash
*shstrtab
;
4790 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4792 i_ehdrp
= elf_elfheader (abfd
);
4793 i_shdrp
= elf_elfsections (abfd
);
4795 shstrtab
= _bfd_elf_strtab_init ();
4796 if (shstrtab
== NULL
)
4799 elf_shstrtab (abfd
) = shstrtab
;
4801 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4802 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4803 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4804 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4806 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4807 i_ehdrp
->e_ident
[EI_DATA
] =
4808 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4809 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4811 if ((abfd
->flags
& DYNAMIC
) != 0)
4812 i_ehdrp
->e_type
= ET_DYN
;
4813 else if ((abfd
->flags
& EXEC_P
) != 0)
4814 i_ehdrp
->e_type
= ET_EXEC
;
4815 else if (bfd_get_format (abfd
) == bfd_core
)
4816 i_ehdrp
->e_type
= ET_CORE
;
4818 i_ehdrp
->e_type
= ET_REL
;
4820 switch (bfd_get_arch (abfd
))
4822 case bfd_arch_unknown
:
4823 i_ehdrp
->e_machine
= EM_NONE
;
4826 /* There used to be a long list of cases here, each one setting
4827 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4828 in the corresponding bfd definition. To avoid duplication,
4829 the switch was removed. Machines that need special handling
4830 can generally do it in elf_backend_final_write_processing(),
4831 unless they need the information earlier than the final write.
4832 Such need can generally be supplied by replacing the tests for
4833 e_machine with the conditions used to determine it. */
4835 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4838 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4839 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4841 /* No program header, for now. */
4842 i_ehdrp
->e_phoff
= 0;
4843 i_ehdrp
->e_phentsize
= 0;
4844 i_ehdrp
->e_phnum
= 0;
4846 /* Each bfd section is section header entry. */
4847 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4848 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4850 /* If we're building an executable, we'll need a program header table. */
4851 if (abfd
->flags
& EXEC_P
)
4852 /* It all happens later. */
4856 i_ehdrp
->e_phentsize
= 0;
4858 i_ehdrp
->e_phoff
= 0;
4861 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4862 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4863 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4864 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4865 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4866 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4867 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4868 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4869 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4875 /* Assign file positions for all the reloc sections which are not part
4876 of the loadable file image. */
4879 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4882 unsigned int i
, num_sec
;
4883 Elf_Internal_Shdr
**shdrpp
;
4885 off
= elf_tdata (abfd
)->next_file_pos
;
4887 num_sec
= elf_numsections (abfd
);
4888 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4890 Elf_Internal_Shdr
*shdrp
;
4893 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4894 && shdrp
->sh_offset
== -1)
4895 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4898 elf_tdata (abfd
)->next_file_pos
= off
;
4902 _bfd_elf_write_object_contents (bfd
*abfd
)
4904 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4905 Elf_Internal_Ehdr
*i_ehdrp
;
4906 Elf_Internal_Shdr
**i_shdrp
;
4908 unsigned int count
, num_sec
;
4910 if (! abfd
->output_has_begun
4911 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4914 i_shdrp
= elf_elfsections (abfd
);
4915 i_ehdrp
= elf_elfheader (abfd
);
4918 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4922 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4924 /* After writing the headers, we need to write the sections too... */
4925 num_sec
= elf_numsections (abfd
);
4926 for (count
= 1; count
< num_sec
; count
++)
4928 if (bed
->elf_backend_section_processing
)
4929 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4930 if (i_shdrp
[count
]->contents
)
4932 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4934 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4935 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4938 if (count
== SHN_LORESERVE
- 1)
4939 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4942 /* Write out the section header names. */
4943 if (elf_shstrtab (abfd
) != NULL
4944 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4945 || ! _bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
4948 if (bed
->elf_backend_final_write_processing
)
4949 (*bed
->elf_backend_final_write_processing
) (abfd
,
4950 elf_tdata (abfd
)->linker
);
4952 return bed
->s
->write_shdrs_and_ehdr (abfd
);
4956 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4958 /* Hopefully this can be done just like an object file. */
4959 return _bfd_elf_write_object_contents (abfd
);
4962 /* Given a section, search the header to find them. */
4965 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4967 const struct elf_backend_data
*bed
;
4970 if (elf_section_data (asect
) != NULL
4971 && elf_section_data (asect
)->this_idx
!= 0)
4972 return elf_section_data (asect
)->this_idx
;
4974 if (bfd_is_abs_section (asect
))
4976 else if (bfd_is_com_section (asect
))
4978 else if (bfd_is_und_section (asect
))
4983 bed
= get_elf_backend_data (abfd
);
4984 if (bed
->elf_backend_section_from_bfd_section
)
4988 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4993 bfd_set_error (bfd_error_nonrepresentable_section
);
4998 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5002 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5004 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5006 flagword flags
= asym_ptr
->flags
;
5008 /* When gas creates relocations against local labels, it creates its
5009 own symbol for the section, but does put the symbol into the
5010 symbol chain, so udata is 0. When the linker is generating
5011 relocatable output, this section symbol may be for one of the
5012 input sections rather than the output section. */
5013 if (asym_ptr
->udata
.i
== 0
5014 && (flags
& BSF_SECTION_SYM
)
5015 && asym_ptr
->section
)
5019 if (asym_ptr
->section
->output_section
!= NULL
)
5020 indx
= asym_ptr
->section
->output_section
->index
;
5022 indx
= asym_ptr
->section
->index
;
5023 if (indx
< elf_num_section_syms (abfd
)
5024 && elf_section_syms (abfd
)[indx
] != NULL
)
5025 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5028 idx
= asym_ptr
->udata
.i
;
5032 /* This case can occur when using --strip-symbol on a symbol
5033 which is used in a relocation entry. */
5034 (*_bfd_error_handler
)
5035 (_("%B: symbol `%s' required but not present"),
5036 abfd
, bfd_asymbol_name (asym_ptr
));
5037 bfd_set_error (bfd_error_no_symbols
);
5044 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5045 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
5046 elf_symbol_flags (flags
));
5054 /* Copy private BFD data. This copies any program header information. */
5057 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5059 Elf_Internal_Ehdr
*iehdr
;
5060 struct elf_segment_map
*map
;
5061 struct elf_segment_map
*map_first
;
5062 struct elf_segment_map
**pointer_to_map
;
5063 Elf_Internal_Phdr
*segment
;
5066 unsigned int num_segments
;
5067 bfd_boolean phdr_included
= FALSE
;
5068 bfd_vma maxpagesize
;
5069 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5070 unsigned int phdr_adjust_num
= 0;
5071 const struct elf_backend_data
*bed
;
5073 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5074 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5077 if (elf_tdata (ibfd
)->phdr
== NULL
)
5080 bed
= get_elf_backend_data (ibfd
);
5081 iehdr
= elf_elfheader (ibfd
);
5084 pointer_to_map
= &map_first
;
5086 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5087 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5089 /* Returns the end address of the segment + 1. */
5090 #define SEGMENT_END(segment, start) \
5091 (start + (segment->p_memsz > segment->p_filesz \
5092 ? segment->p_memsz : segment->p_filesz))
5094 #define SECTION_SIZE(section, segment) \
5095 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5096 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5097 ? section->size : 0)
5099 /* Returns TRUE if the given section is contained within
5100 the given segment. VMA addresses are compared. */
5101 #define IS_CONTAINED_BY_VMA(section, segment) \
5102 (section->vma >= segment->p_vaddr \
5103 && (section->vma + SECTION_SIZE (section, segment) \
5104 <= (SEGMENT_END (segment, segment->p_vaddr))))
5106 /* Returns TRUE if the given section is contained within
5107 the given segment. LMA addresses are compared. */
5108 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5109 (section->lma >= base \
5110 && (section->lma + SECTION_SIZE (section, segment) \
5111 <= SEGMENT_END (segment, base)))
5113 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5114 #define IS_COREFILE_NOTE(p, s) \
5115 (p->p_type == PT_NOTE \
5116 && bfd_get_format (ibfd) == bfd_core \
5117 && s->vma == 0 && s->lma == 0 \
5118 && (bfd_vma) s->filepos >= p->p_offset \
5119 && ((bfd_vma) s->filepos + s->size \
5120 <= p->p_offset + p->p_filesz))
5122 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5123 linker, which generates a PT_INTERP section with p_vaddr and
5124 p_memsz set to 0. */
5125 #define IS_SOLARIS_PT_INTERP(p, s) \
5127 && p->p_paddr == 0 \
5128 && p->p_memsz == 0 \
5129 && p->p_filesz > 0 \
5130 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5132 && (bfd_vma) s->filepos >= p->p_offset \
5133 && ((bfd_vma) s->filepos + s->size \
5134 <= p->p_offset + p->p_filesz))
5136 /* Decide if the given section should be included in the given segment.
5137 A section will be included if:
5138 1. It is within the address space of the segment -- we use the LMA
5139 if that is set for the segment and the VMA otherwise,
5140 2. It is an allocated segment,
5141 3. There is an output section associated with it,
5142 4. The section has not already been allocated to a previous segment.
5143 5. PT_GNU_STACK segments do not include any sections.
5144 6. PT_TLS segment includes only SHF_TLS sections.
5145 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5146 8. PT_DYNAMIC should not contain empty sections at the beginning
5147 (with the possible exception of .dynamic). */
5148 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5149 ((((segment->p_paddr \
5150 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5151 : IS_CONTAINED_BY_VMA (section, segment)) \
5152 && (section->flags & SEC_ALLOC) != 0) \
5153 || IS_COREFILE_NOTE (segment, section)) \
5154 && section->output_section != NULL \
5155 && segment->p_type != PT_GNU_STACK \
5156 && (segment->p_type != PT_TLS \
5157 || (section->flags & SEC_THREAD_LOCAL)) \
5158 && (segment->p_type == PT_LOAD \
5159 || segment->p_type == PT_TLS \
5160 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5161 && (segment->p_type != PT_DYNAMIC \
5162 || SECTION_SIZE (section, segment) > 0 \
5163 || (segment->p_paddr \
5164 ? segment->p_paddr != section->lma \
5165 : segment->p_vaddr != section->vma) \
5166 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5168 && ! section->segment_mark)
5170 /* Returns TRUE iff seg1 starts after the end of seg2. */
5171 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5172 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5174 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5175 their VMA address ranges and their LMA address ranges overlap.
5176 It is possible to have overlapping VMA ranges without overlapping LMA
5177 ranges. RedBoot images for example can have both .data and .bss mapped
5178 to the same VMA range, but with the .data section mapped to a different
5180 #define SEGMENT_OVERLAPS(seg1, seg2) \
5181 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5182 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5183 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5184 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5186 /* Initialise the segment mark field. */
5187 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5188 section
->segment_mark
= FALSE
;
5190 /* Scan through the segments specified in the program header
5191 of the input BFD. For this first scan we look for overlaps
5192 in the loadable segments. These can be created by weird
5193 parameters to objcopy. Also, fix some solaris weirdness. */
5194 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5199 Elf_Internal_Phdr
*segment2
;
5201 if (segment
->p_type
== PT_INTERP
)
5202 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5203 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5205 /* Mininal change so that the normal section to segment
5206 assignment code will work. */
5207 segment
->p_vaddr
= section
->vma
;
5211 if (segment
->p_type
!= PT_LOAD
)
5214 /* Determine if this segment overlaps any previous segments. */
5215 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5217 bfd_signed_vma extra_length
;
5219 if (segment2
->p_type
!= PT_LOAD
5220 || ! SEGMENT_OVERLAPS (segment
, segment2
))
5223 /* Merge the two segments together. */
5224 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5226 /* Extend SEGMENT2 to include SEGMENT and then delete
5229 SEGMENT_END (segment
, segment
->p_vaddr
)
5230 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
5232 if (extra_length
> 0)
5234 segment2
->p_memsz
+= extra_length
;
5235 segment2
->p_filesz
+= extra_length
;
5238 segment
->p_type
= PT_NULL
;
5240 /* Since we have deleted P we must restart the outer loop. */
5242 segment
= elf_tdata (ibfd
)->phdr
;
5247 /* Extend SEGMENT to include SEGMENT2 and then delete
5250 SEGMENT_END (segment2
, segment2
->p_vaddr
)
5251 - SEGMENT_END (segment
, segment
->p_vaddr
);
5253 if (extra_length
> 0)
5255 segment
->p_memsz
+= extra_length
;
5256 segment
->p_filesz
+= extra_length
;
5259 segment2
->p_type
= PT_NULL
;
5264 /* The second scan attempts to assign sections to segments. */
5265 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5269 unsigned int section_count
;
5270 asection
** sections
;
5271 asection
* output_section
;
5273 bfd_vma matching_lma
;
5274 bfd_vma suggested_lma
;
5278 if (segment
->p_type
== PT_NULL
)
5281 /* Compute how many sections might be placed into this segment. */
5282 for (section
= ibfd
->sections
, section_count
= 0;
5284 section
= section
->next
)
5285 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5288 /* Allocate a segment map big enough to contain
5289 all of the sections we have selected. */
5290 amt
= sizeof (struct elf_segment_map
);
5291 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5292 map
= bfd_alloc (obfd
, amt
);
5296 /* Initialise the fields of the segment map. Default to
5297 using the physical address of the segment in the input BFD. */
5299 map
->p_type
= segment
->p_type
;
5300 map
->p_flags
= segment
->p_flags
;
5301 map
->p_flags_valid
= 1;
5302 map
->p_paddr
= segment
->p_paddr
;
5303 map
->p_paddr_valid
= 1;
5305 /* Determine if this segment contains the ELF file header
5306 and if it contains the program headers themselves. */
5307 map
->includes_filehdr
= (segment
->p_offset
== 0
5308 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5310 map
->includes_phdrs
= 0;
5312 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5314 map
->includes_phdrs
=
5315 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5316 && (segment
->p_offset
+ segment
->p_filesz
5317 >= ((bfd_vma
) iehdr
->e_phoff
5318 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5320 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5321 phdr_included
= TRUE
;
5324 if (section_count
== 0)
5326 /* Special segments, such as the PT_PHDR segment, may contain
5327 no sections, but ordinary, loadable segments should contain
5328 something. They are allowed by the ELF spec however, so only
5329 a warning is produced. */
5330 if (segment
->p_type
== PT_LOAD
)
5331 (*_bfd_error_handler
)
5332 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5336 *pointer_to_map
= map
;
5337 pointer_to_map
= &map
->next
;
5342 /* Now scan the sections in the input BFD again and attempt
5343 to add their corresponding output sections to the segment map.
5344 The problem here is how to handle an output section which has
5345 been moved (ie had its LMA changed). There are four possibilities:
5347 1. None of the sections have been moved.
5348 In this case we can continue to use the segment LMA from the
5351 2. All of the sections have been moved by the same amount.
5352 In this case we can change the segment's LMA to match the LMA
5353 of the first section.
5355 3. Some of the sections have been moved, others have not.
5356 In this case those sections which have not been moved can be
5357 placed in the current segment which will have to have its size,
5358 and possibly its LMA changed, and a new segment or segments will
5359 have to be created to contain the other sections.
5361 4. The sections have been moved, but not by the same amount.
5362 In this case we can change the segment's LMA to match the LMA
5363 of the first section and we will have to create a new segment
5364 or segments to contain the other sections.
5366 In order to save time, we allocate an array to hold the section
5367 pointers that we are interested in. As these sections get assigned
5368 to a segment, they are removed from this array. */
5370 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5371 to work around this long long bug. */
5372 amt
= section_count
* sizeof (asection
*);
5373 sections
= bfd_malloc (amt
);
5374 if (sections
== NULL
)
5377 /* Step One: Scan for segment vs section LMA conflicts.
5378 Also add the sections to the section array allocated above.
5379 Also add the sections to the current segment. In the common
5380 case, where the sections have not been moved, this means that
5381 we have completely filled the segment, and there is nothing
5387 for (j
= 0, section
= ibfd
->sections
;
5389 section
= section
->next
)
5391 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5393 output_section
= section
->output_section
;
5395 sections
[j
++] = section
;
5397 /* The Solaris native linker always sets p_paddr to 0.
5398 We try to catch that case here, and set it to the
5399 correct value. Note - some backends require that
5400 p_paddr be left as zero. */
5401 if (segment
->p_paddr
== 0
5402 && segment
->p_vaddr
!= 0
5403 && (! bed
->want_p_paddr_set_to_zero
)
5405 && output_section
->lma
!= 0
5406 && (output_section
->vma
== (segment
->p_vaddr
5407 + (map
->includes_filehdr
5410 + (map
->includes_phdrs
5412 * iehdr
->e_phentsize
)
5414 map
->p_paddr
= segment
->p_vaddr
;
5416 /* Match up the physical address of the segment with the
5417 LMA address of the output section. */
5418 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5419 || IS_COREFILE_NOTE (segment
, section
)
5420 || (bed
->want_p_paddr_set_to_zero
&&
5421 IS_CONTAINED_BY_VMA (output_section
, segment
))
5424 if (matching_lma
== 0)
5425 matching_lma
= output_section
->lma
;
5427 /* We assume that if the section fits within the segment
5428 then it does not overlap any other section within that
5430 map
->sections
[isec
++] = output_section
;
5432 else if (suggested_lma
== 0)
5433 suggested_lma
= output_section
->lma
;
5437 BFD_ASSERT (j
== section_count
);
5439 /* Step Two: Adjust the physical address of the current segment,
5441 if (isec
== section_count
)
5443 /* All of the sections fitted within the segment as currently
5444 specified. This is the default case. Add the segment to
5445 the list of built segments and carry on to process the next
5446 program header in the input BFD. */
5447 map
->count
= section_count
;
5448 *pointer_to_map
= map
;
5449 pointer_to_map
= &map
->next
;
5456 if (matching_lma
!= 0)
5458 /* At least one section fits inside the current segment.
5459 Keep it, but modify its physical address to match the
5460 LMA of the first section that fitted. */
5461 map
->p_paddr
= matching_lma
;
5465 /* None of the sections fitted inside the current segment.
5466 Change the current segment's physical address to match
5467 the LMA of the first section. */
5468 map
->p_paddr
= suggested_lma
;
5471 /* Offset the segment physical address from the lma
5472 to allow for space taken up by elf headers. */
5473 if (map
->includes_filehdr
)
5474 map
->p_paddr
-= iehdr
->e_ehsize
;
5476 if (map
->includes_phdrs
)
5478 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5480 /* iehdr->e_phnum is just an estimate of the number
5481 of program headers that we will need. Make a note
5482 here of the number we used and the segment we chose
5483 to hold these headers, so that we can adjust the
5484 offset when we know the correct value. */
5485 phdr_adjust_num
= iehdr
->e_phnum
;
5486 phdr_adjust_seg
= map
;
5490 /* Step Three: Loop over the sections again, this time assigning
5491 those that fit to the current segment and removing them from the
5492 sections array; but making sure not to leave large gaps. Once all
5493 possible sections have been assigned to the current segment it is
5494 added to the list of built segments and if sections still remain
5495 to be assigned, a new segment is constructed before repeating
5503 /* Fill the current segment with sections that fit. */
5504 for (j
= 0; j
< section_count
; j
++)
5506 section
= sections
[j
];
5508 if (section
== NULL
)
5511 output_section
= section
->output_section
;
5513 BFD_ASSERT (output_section
!= NULL
);
5515 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5516 || IS_COREFILE_NOTE (segment
, section
))
5518 if (map
->count
== 0)
5520 /* If the first section in a segment does not start at
5521 the beginning of the segment, then something is
5523 if (output_section
->lma
!=
5525 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5526 + (map
->includes_phdrs
5527 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5533 asection
* prev_sec
;
5535 prev_sec
= map
->sections
[map
->count
- 1];
5537 /* If the gap between the end of the previous section
5538 and the start of this section is more than
5539 maxpagesize then we need to start a new segment. */
5540 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5542 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5543 || ((prev_sec
->lma
+ prev_sec
->size
)
5544 > output_section
->lma
))
5546 if (suggested_lma
== 0)
5547 suggested_lma
= output_section
->lma
;
5553 map
->sections
[map
->count
++] = output_section
;
5556 section
->segment_mark
= TRUE
;
5558 else if (suggested_lma
== 0)
5559 suggested_lma
= output_section
->lma
;
5562 BFD_ASSERT (map
->count
> 0);
5564 /* Add the current segment to the list of built segments. */
5565 *pointer_to_map
= map
;
5566 pointer_to_map
= &map
->next
;
5568 if (isec
< section_count
)
5570 /* We still have not allocated all of the sections to
5571 segments. Create a new segment here, initialise it
5572 and carry on looping. */
5573 amt
= sizeof (struct elf_segment_map
);
5574 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5575 map
= bfd_alloc (obfd
, amt
);
5582 /* Initialise the fields of the segment map. Set the physical
5583 physical address to the LMA of the first section that has
5584 not yet been assigned. */
5586 map
->p_type
= segment
->p_type
;
5587 map
->p_flags
= segment
->p_flags
;
5588 map
->p_flags_valid
= 1;
5589 map
->p_paddr
= suggested_lma
;
5590 map
->p_paddr_valid
= 1;
5591 map
->includes_filehdr
= 0;
5592 map
->includes_phdrs
= 0;
5595 while (isec
< section_count
);
5600 /* The Solaris linker creates program headers in which all the
5601 p_paddr fields are zero. When we try to objcopy or strip such a
5602 file, we get confused. Check for this case, and if we find it
5603 reset the p_paddr_valid fields. */
5604 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5605 if (map
->p_paddr
!= 0)
5608 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5609 map
->p_paddr_valid
= 0;
5611 elf_tdata (obfd
)->segment_map
= map_first
;
5613 /* If we had to estimate the number of program headers that were
5614 going to be needed, then check our estimate now and adjust
5615 the offset if necessary. */
5616 if (phdr_adjust_seg
!= NULL
)
5620 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5623 if (count
> phdr_adjust_num
)
5624 phdr_adjust_seg
->p_paddr
5625 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5630 #undef IS_CONTAINED_BY_VMA
5631 #undef IS_CONTAINED_BY_LMA
5632 #undef IS_COREFILE_NOTE
5633 #undef IS_SOLARIS_PT_INTERP
5634 #undef INCLUDE_SECTION_IN_SEGMENT
5635 #undef SEGMENT_AFTER_SEGMENT
5636 #undef SEGMENT_OVERLAPS
5640 /* Copy private section information. This copies over the entsize
5641 field, and sometimes the info field. */
5644 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
5649 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5651 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5652 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5655 ihdr
= &elf_section_data (isec
)->this_hdr
;
5656 ohdr
= &elf_section_data (osec
)->this_hdr
;
5658 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
5660 if (ihdr
->sh_type
== SHT_SYMTAB
5661 || ihdr
->sh_type
== SHT_DYNSYM
5662 || ihdr
->sh_type
== SHT_GNU_verneed
5663 || ihdr
->sh_type
== SHT_GNU_verdef
)
5664 ohdr
->sh_info
= ihdr
->sh_info
;
5666 /* Set things up for objcopy. The output SHT_GROUP section will
5667 have its elf_next_in_group pointing back to the input group
5668 members. Ignore linker created group section. See
5669 elfNN_ia64_object_p in elfxx-ia64.c. */
5670 if (elf_sec_group (isec
) == NULL
5671 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
5673 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5674 elf_group_name (osec
) = elf_group_name (isec
);
5677 osec
->use_rela_p
= isec
->use_rela_p
;
5682 /* Copy private header information. */
5685 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
5687 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5688 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5691 /* Copy over private BFD data if it has not already been copied.
5692 This must be done here, rather than in the copy_private_bfd_data
5693 entry point, because the latter is called after the section
5694 contents have been set, which means that the program headers have
5695 already been worked out. */
5696 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
5698 if (! copy_private_bfd_data (ibfd
, obfd
))
5705 /* Copy private symbol information. If this symbol is in a section
5706 which we did not map into a BFD section, try to map the section
5707 index correctly. We use special macro definitions for the mapped
5708 section indices; these definitions are interpreted by the
5709 swap_out_syms function. */
5711 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5712 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5713 #define MAP_STRTAB (SHN_HIOS + 3)
5714 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5715 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5718 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
5723 elf_symbol_type
*isym
, *osym
;
5725 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5726 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5729 isym
= elf_symbol_from (ibfd
, isymarg
);
5730 osym
= elf_symbol_from (obfd
, osymarg
);
5734 && bfd_is_abs_section (isym
->symbol
.section
))
5738 shndx
= isym
->internal_elf_sym
.st_shndx
;
5739 if (shndx
== elf_onesymtab (ibfd
))
5740 shndx
= MAP_ONESYMTAB
;
5741 else if (shndx
== elf_dynsymtab (ibfd
))
5742 shndx
= MAP_DYNSYMTAB
;
5743 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
5745 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
5746 shndx
= MAP_SHSTRTAB
;
5747 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
5748 shndx
= MAP_SYM_SHNDX
;
5749 osym
->internal_elf_sym
.st_shndx
= shndx
;
5755 /* Swap out the symbols. */
5758 swap_out_syms (bfd
*abfd
,
5759 struct bfd_strtab_hash
**sttp
,
5762 const struct elf_backend_data
*bed
;
5765 struct bfd_strtab_hash
*stt
;
5766 Elf_Internal_Shdr
*symtab_hdr
;
5767 Elf_Internal_Shdr
*symtab_shndx_hdr
;
5768 Elf_Internal_Shdr
*symstrtab_hdr
;
5769 bfd_byte
*outbound_syms
;
5770 bfd_byte
*outbound_shndx
;
5773 bfd_boolean name_local_sections
;
5775 if (!elf_map_symbols (abfd
))
5778 /* Dump out the symtabs. */
5779 stt
= _bfd_elf_stringtab_init ();
5783 bed
= get_elf_backend_data (abfd
);
5784 symcount
= bfd_get_symcount (abfd
);
5785 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5786 symtab_hdr
->sh_type
= SHT_SYMTAB
;
5787 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
5788 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
5789 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
5790 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
5792 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
5793 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
5795 amt
= (bfd_size_type
) (1 + symcount
) * bed
->s
->sizeof_sym
;
5796 outbound_syms
= bfd_alloc (abfd
, amt
);
5797 if (outbound_syms
== NULL
)
5799 _bfd_stringtab_free (stt
);
5802 symtab_hdr
->contents
= outbound_syms
;
5804 outbound_shndx
= NULL
;
5805 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
5806 if (symtab_shndx_hdr
->sh_name
!= 0)
5808 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
5809 outbound_shndx
= bfd_zalloc (abfd
, amt
);
5810 if (outbound_shndx
== NULL
)
5812 _bfd_stringtab_free (stt
);
5816 symtab_shndx_hdr
->contents
= outbound_shndx
;
5817 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
5818 symtab_shndx_hdr
->sh_size
= amt
;
5819 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
5820 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
5823 /* Now generate the data (for "contents"). */
5825 /* Fill in zeroth symbol and swap it out. */
5826 Elf_Internal_Sym sym
;
5832 sym
.st_shndx
= SHN_UNDEF
;
5833 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
5834 outbound_syms
+= bed
->s
->sizeof_sym
;
5835 if (outbound_shndx
!= NULL
)
5836 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
5840 = (bed
->elf_backend_name_local_section_symbols
5841 && bed
->elf_backend_name_local_section_symbols (abfd
));
5843 syms
= bfd_get_outsymbols (abfd
);
5844 for (idx
= 0; idx
< symcount
; idx
++)
5846 Elf_Internal_Sym sym
;
5847 bfd_vma value
= syms
[idx
]->value
;
5848 elf_symbol_type
*type_ptr
;
5849 flagword flags
= syms
[idx
]->flags
;
5852 if (!name_local_sections
5853 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
5855 /* Local section symbols have no name. */
5860 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
5863 if (sym
.st_name
== (unsigned long) -1)
5865 _bfd_stringtab_free (stt
);
5870 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
5872 if ((flags
& BSF_SECTION_SYM
) == 0
5873 && bfd_is_com_section (syms
[idx
]->section
))
5875 /* ELF common symbols put the alignment into the `value' field,
5876 and the size into the `size' field. This is backwards from
5877 how BFD handles it, so reverse it here. */
5878 sym
.st_size
= value
;
5879 if (type_ptr
== NULL
5880 || type_ptr
->internal_elf_sym
.st_value
== 0)
5881 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
5883 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
5884 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
5885 (abfd
, syms
[idx
]->section
);
5889 asection
*sec
= syms
[idx
]->section
;
5892 if (sec
->output_section
)
5894 value
+= sec
->output_offset
;
5895 sec
= sec
->output_section
;
5898 /* Don't add in the section vma for relocatable output. */
5899 if (! relocatable_p
)
5901 sym
.st_value
= value
;
5902 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
5904 if (bfd_is_abs_section (sec
)
5906 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
5908 /* This symbol is in a real ELF section which we did
5909 not create as a BFD section. Undo the mapping done
5910 by copy_private_symbol_data. */
5911 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
5915 shndx
= elf_onesymtab (abfd
);
5918 shndx
= elf_dynsymtab (abfd
);
5921 shndx
= elf_tdata (abfd
)->strtab_section
;
5924 shndx
= elf_tdata (abfd
)->shstrtab_section
;
5927 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
5935 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
5941 /* Writing this would be a hell of a lot easier if
5942 we had some decent documentation on bfd, and
5943 knew what to expect of the library, and what to
5944 demand of applications. For example, it
5945 appears that `objcopy' might not set the
5946 section of a symbol to be a section that is
5947 actually in the output file. */
5948 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
5951 _bfd_error_handler (_("\
5952 Unable to find equivalent output section for symbol '%s' from section '%s'"),
5953 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
5955 bfd_set_error (bfd_error_invalid_operation
);
5956 _bfd_stringtab_free (stt
);
5960 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
5961 BFD_ASSERT (shndx
!= -1);
5965 sym
.st_shndx
= shndx
;
5968 if ((flags
& BSF_THREAD_LOCAL
) != 0)
5970 else if ((flags
& BSF_FUNCTION
) != 0)
5972 else if ((flags
& BSF_OBJECT
) != 0)
5977 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
5980 /* Processor-specific types. */
5981 if (type_ptr
!= NULL
5982 && bed
->elf_backend_get_symbol_type
)
5983 type
= ((*bed
->elf_backend_get_symbol_type
)
5984 (&type_ptr
->internal_elf_sym
, type
));
5986 if (flags
& BSF_SECTION_SYM
)
5988 if (flags
& BSF_GLOBAL
)
5989 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
5991 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
5993 else if (bfd_is_com_section (syms
[idx
]->section
))
5994 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
5995 else if (bfd_is_und_section (syms
[idx
]->section
))
5996 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6000 else if (flags
& BSF_FILE
)
6001 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6004 int bind
= STB_LOCAL
;
6006 if (flags
& BSF_LOCAL
)
6008 else if (flags
& BSF_WEAK
)
6010 else if (flags
& BSF_GLOBAL
)
6013 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6016 if (type_ptr
!= NULL
)
6017 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6021 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6022 outbound_syms
+= bed
->s
->sizeof_sym
;
6023 if (outbound_shndx
!= NULL
)
6024 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6028 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6029 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6031 symstrtab_hdr
->sh_flags
= 0;
6032 symstrtab_hdr
->sh_addr
= 0;
6033 symstrtab_hdr
->sh_entsize
= 0;
6034 symstrtab_hdr
->sh_link
= 0;
6035 symstrtab_hdr
->sh_info
= 0;
6036 symstrtab_hdr
->sh_addralign
= 1;
6041 /* Return the number of bytes required to hold the symtab vector.
6043 Note that we base it on the count plus 1, since we will null terminate
6044 the vector allocated based on this size. However, the ELF symbol table
6045 always has a dummy entry as symbol #0, so it ends up even. */
6048 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6052 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6054 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6055 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6057 symtab_size
-= sizeof (asymbol
*);
6063 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6067 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6069 if (elf_dynsymtab (abfd
) == 0)
6071 bfd_set_error (bfd_error_invalid_operation
);
6075 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6076 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6078 symtab_size
-= sizeof (asymbol
*);
6084 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6087 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6090 /* Canonicalize the relocs. */
6093 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6100 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6102 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6105 tblptr
= section
->relocation
;
6106 for (i
= 0; i
< section
->reloc_count
; i
++)
6107 *relptr
++ = tblptr
++;
6111 return section
->reloc_count
;
6115 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6117 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6118 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6121 bfd_get_symcount (abfd
) = symcount
;
6126 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6127 asymbol
**allocation
)
6129 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6130 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6133 bfd_get_dynamic_symcount (abfd
) = symcount
;
6137 /* Return the size required for the dynamic reloc entries. Any loadable
6138 section that was actually installed in the BFD, and has type SHT_REL
6139 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6140 dynamic reloc section. */
6143 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6148 if (elf_dynsymtab (abfd
) == 0)
6150 bfd_set_error (bfd_error_invalid_operation
);
6154 ret
= sizeof (arelent
*);
6155 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6156 if ((s
->flags
& SEC_LOAD
) != 0
6157 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6158 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6159 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6160 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6161 * sizeof (arelent
*));
6166 /* Canonicalize the dynamic relocation entries. Note that we return the
6167 dynamic relocations as a single block, although they are actually
6168 associated with particular sections; the interface, which was
6169 designed for SunOS style shared libraries, expects that there is only
6170 one set of dynamic relocs. Any loadable section that was actually
6171 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6172 dynamic symbol table, is considered to be a dynamic reloc section. */
6175 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6179 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6183 if (elf_dynsymtab (abfd
) == 0)
6185 bfd_set_error (bfd_error_invalid_operation
);
6189 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6191 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6193 if ((s
->flags
& SEC_LOAD
) != 0
6194 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6195 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6196 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6201 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6203 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6205 for (i
= 0; i
< count
; i
++)
6216 /* Read in the version information. */
6219 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6221 bfd_byte
*contents
= NULL
;
6223 unsigned int freeidx
= 0;
6225 if (elf_dynverref (abfd
) != 0)
6227 Elf_Internal_Shdr
*hdr
;
6228 Elf_External_Verneed
*everneed
;
6229 Elf_Internal_Verneed
*iverneed
;
6232 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6234 amt
= (bfd_size_type
) hdr
->sh_info
* sizeof (Elf_Internal_Verneed
);
6235 elf_tdata (abfd
)->verref
= bfd_zalloc (abfd
, amt
);
6236 if (elf_tdata (abfd
)->verref
== NULL
)
6239 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6241 contents
= bfd_malloc (hdr
->sh_size
);
6242 if (contents
== NULL
)
6244 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6245 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6248 everneed
= (Elf_External_Verneed
*) contents
;
6249 iverneed
= elf_tdata (abfd
)->verref
;
6250 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6252 Elf_External_Vernaux
*evernaux
;
6253 Elf_Internal_Vernaux
*ivernaux
;
6256 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6258 iverneed
->vn_bfd
= abfd
;
6260 iverneed
->vn_filename
=
6261 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6263 if (iverneed
->vn_filename
== NULL
)
6266 amt
= iverneed
->vn_cnt
;
6267 amt
*= sizeof (Elf_Internal_Vernaux
);
6268 iverneed
->vn_auxptr
= bfd_alloc (abfd
, amt
);
6270 evernaux
= ((Elf_External_Vernaux
*)
6271 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6272 ivernaux
= iverneed
->vn_auxptr
;
6273 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6275 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6277 ivernaux
->vna_nodename
=
6278 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6279 ivernaux
->vna_name
);
6280 if (ivernaux
->vna_nodename
== NULL
)
6283 if (j
+ 1 < iverneed
->vn_cnt
)
6284 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6286 ivernaux
->vna_nextptr
= NULL
;
6288 evernaux
= ((Elf_External_Vernaux
*)
6289 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6291 if (ivernaux
->vna_other
> freeidx
)
6292 freeidx
= ivernaux
->vna_other
;
6295 if (i
+ 1 < hdr
->sh_info
)
6296 iverneed
->vn_nextref
= iverneed
+ 1;
6298 iverneed
->vn_nextref
= NULL
;
6300 everneed
= ((Elf_External_Verneed
*)
6301 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6308 if (elf_dynverdef (abfd
) != 0)
6310 Elf_Internal_Shdr
*hdr
;
6311 Elf_External_Verdef
*everdef
;
6312 Elf_Internal_Verdef
*iverdef
;
6313 Elf_Internal_Verdef
*iverdefarr
;
6314 Elf_Internal_Verdef iverdefmem
;
6316 unsigned int maxidx
;
6318 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6320 contents
= bfd_malloc (hdr
->sh_size
);
6321 if (contents
== NULL
)
6323 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6324 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6327 /* We know the number of entries in the section but not the maximum
6328 index. Therefore we have to run through all entries and find
6330 everdef
= (Elf_External_Verdef
*) contents
;
6332 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6334 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6336 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6337 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6339 everdef
= ((Elf_External_Verdef
*)
6340 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6343 if (default_imported_symver
)
6345 if (freeidx
> maxidx
)
6350 amt
= (bfd_size_type
) maxidx
* sizeof (Elf_Internal_Verdef
);
6351 elf_tdata (abfd
)->verdef
= bfd_zalloc (abfd
, amt
);
6352 if (elf_tdata (abfd
)->verdef
== NULL
)
6355 elf_tdata (abfd
)->cverdefs
= maxidx
;
6357 everdef
= (Elf_External_Verdef
*) contents
;
6358 iverdefarr
= elf_tdata (abfd
)->verdef
;
6359 for (i
= 0; i
< hdr
->sh_info
; i
++)
6361 Elf_External_Verdaux
*everdaux
;
6362 Elf_Internal_Verdaux
*iverdaux
;
6365 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6367 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6368 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6370 iverdef
->vd_bfd
= abfd
;
6372 amt
= (bfd_size_type
) iverdef
->vd_cnt
* sizeof (Elf_Internal_Verdaux
);
6373 iverdef
->vd_auxptr
= bfd_alloc (abfd
, amt
);
6374 if (iverdef
->vd_auxptr
== NULL
)
6377 everdaux
= ((Elf_External_Verdaux
*)
6378 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6379 iverdaux
= iverdef
->vd_auxptr
;
6380 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
6382 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
6384 iverdaux
->vda_nodename
=
6385 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6386 iverdaux
->vda_name
);
6387 if (iverdaux
->vda_nodename
== NULL
)
6390 if (j
+ 1 < iverdef
->vd_cnt
)
6391 iverdaux
->vda_nextptr
= iverdaux
+ 1;
6393 iverdaux
->vda_nextptr
= NULL
;
6395 everdaux
= ((Elf_External_Verdaux
*)
6396 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
6399 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
6401 if (i
+ 1 < hdr
->sh_info
)
6402 iverdef
->vd_nextdef
= iverdef
+ 1;
6404 iverdef
->vd_nextdef
= NULL
;
6406 everdef
= ((Elf_External_Verdef
*)
6407 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
6413 else if (default_imported_symver
)
6420 amt
= (bfd_size_type
) freeidx
* sizeof (Elf_Internal_Verdef
);
6421 elf_tdata (abfd
)->verdef
= bfd_zalloc (abfd
, amt
);
6422 if (elf_tdata (abfd
)->verdef
== NULL
)
6425 elf_tdata (abfd
)->cverdefs
= freeidx
;
6428 /* Create a default version based on the soname. */
6429 if (default_imported_symver
)
6431 Elf_Internal_Verdef
*iverdef
;
6432 Elf_Internal_Verdaux
*iverdaux
;
6434 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
6436 iverdef
->vd_version
= VER_DEF_CURRENT
;
6437 iverdef
->vd_flags
= 0;
6438 iverdef
->vd_ndx
= freeidx
;
6439 iverdef
->vd_cnt
= 1;
6441 iverdef
->vd_bfd
= abfd
;
6443 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
6444 if (iverdef
->vd_nodename
== NULL
)
6446 iverdef
->vd_nextdef
= NULL
;
6447 amt
= (bfd_size_type
) sizeof (Elf_Internal_Verdaux
);
6448 iverdef
->vd_auxptr
= bfd_alloc (abfd
, amt
);
6450 iverdaux
= iverdef
->vd_auxptr
;
6451 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
6452 iverdaux
->vda_nextptr
= NULL
;
6458 if (contents
!= NULL
)
6464 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6466 elf_symbol_type
*newsym
;
6467 bfd_size_type amt
= sizeof (elf_symbol_type
);
6469 newsym
= bfd_zalloc (abfd
, amt
);
6474 newsym
->symbol
.the_bfd
= abfd
;
6475 return &newsym
->symbol
;
6480 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6484 bfd_symbol_info (symbol
, ret
);
6487 /* Return whether a symbol name implies a local symbol. Most targets
6488 use this function for the is_local_label_name entry point, but some
6492 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6495 /* Normal local symbols start with ``.L''. */
6496 if (name
[0] == '.' && name
[1] == 'L')
6499 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6500 DWARF debugging symbols starting with ``..''. */
6501 if (name
[0] == '.' && name
[1] == '.')
6504 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6505 emitting DWARF debugging output. I suspect this is actually a
6506 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6507 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6508 underscore to be emitted on some ELF targets). For ease of use,
6509 we treat such symbols as local. */
6510 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6517 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
6518 asymbol
*symbol ATTRIBUTE_UNUSED
)
6525 _bfd_elf_set_arch_mach (bfd
*abfd
,
6526 enum bfd_architecture arch
,
6527 unsigned long machine
)
6529 /* If this isn't the right architecture for this backend, and this
6530 isn't the generic backend, fail. */
6531 if (arch
!= get_elf_backend_data (abfd
)->arch
6532 && arch
!= bfd_arch_unknown
6533 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
6536 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
6539 /* Find the function to a particular section and offset,
6540 for error reporting. */
6543 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
6547 const char **filename_ptr
,
6548 const char **functionname_ptr
)
6550 const char *filename
;
6551 asymbol
*func
, *file
;
6554 /* ??? Given multiple file symbols, it is impossible to reliably
6555 choose the right file name for global symbols. File symbols are
6556 local symbols, and thus all file symbols must sort before any
6557 global symbols. The ELF spec may be interpreted to say that a
6558 file symbol must sort before other local symbols, but currently
6559 ld -r doesn't do this. So, for ld -r output, it is possible to
6560 make a better choice of file name for local symbols by ignoring
6561 file symbols appearing after a given local symbol. */
6562 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
6568 state
= nothing_seen
;
6570 for (p
= symbols
; *p
!= NULL
; p
++)
6574 q
= (elf_symbol_type
*) *p
;
6576 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
6582 if (state
== symbol_seen
)
6583 state
= file_after_symbol_seen
;
6589 if (bfd_get_section (&q
->symbol
) == section
6590 && q
->symbol
.value
>= low_func
6591 && q
->symbol
.value
<= offset
)
6593 func
= (asymbol
*) q
;
6594 low_func
= q
->symbol
.value
;
6597 else if (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) != STB_LOCAL
6598 && state
== file_after_symbol_seen
)
6601 filename
= bfd_asymbol_name (file
);
6605 if (state
== nothing_seen
)
6606 state
= symbol_seen
;
6613 *filename_ptr
= filename
;
6614 if (functionname_ptr
)
6615 *functionname_ptr
= bfd_asymbol_name (func
);
6620 /* Find the nearest line to a particular section and offset,
6621 for error reporting. */
6624 _bfd_elf_find_nearest_line (bfd
*abfd
,
6628 const char **filename_ptr
,
6629 const char **functionname_ptr
,
6630 unsigned int *line_ptr
)
6634 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
6635 filename_ptr
, functionname_ptr
,
6638 if (!*functionname_ptr
)
6639 elf_find_function (abfd
, section
, symbols
, offset
,
6640 *filename_ptr
? NULL
: filename_ptr
,
6646 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
6647 filename_ptr
, functionname_ptr
,
6649 &elf_tdata (abfd
)->dwarf2_find_line_info
))
6651 if (!*functionname_ptr
)
6652 elf_find_function (abfd
, section
, symbols
, offset
,
6653 *filename_ptr
? NULL
: filename_ptr
,
6659 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
6660 &found
, filename_ptr
,
6661 functionname_ptr
, line_ptr
,
6662 &elf_tdata (abfd
)->line_info
))
6664 if (found
&& (*functionname_ptr
|| *line_ptr
))
6667 if (symbols
== NULL
)
6670 if (! elf_find_function (abfd
, section
, symbols
, offset
,
6671 filename_ptr
, functionname_ptr
))
6678 /* Find the line for a symbol. */
6681 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
6682 const char **filename_ptr
, unsigned int *line_ptr
)
6684 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
6685 filename_ptr
, line_ptr
, 0,
6686 &elf_tdata (abfd
)->dwarf2_find_line_info
);
6689 /* After a call to bfd_find_nearest_line, successive calls to
6690 bfd_find_inliner_info can be used to get source information about
6691 each level of function inlining that terminated at the address
6692 passed to bfd_find_nearest_line. Currently this is only supported
6693 for DWARF2 with appropriate DWARF3 extensions. */
6696 _bfd_elf_find_inliner_info (bfd
*abfd
,
6697 const char **filename_ptr
,
6698 const char **functionname_ptr
,
6699 unsigned int *line_ptr
)
6702 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
6703 functionname_ptr
, line_ptr
,
6704 & elf_tdata (abfd
)->dwarf2_find_line_info
);
6709 _bfd_elf_sizeof_headers (bfd
*abfd
, bfd_boolean reloc
)
6713 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
6715 ret
+= get_program_header_size (abfd
);
6720 _bfd_elf_set_section_contents (bfd
*abfd
,
6722 const void *location
,
6724 bfd_size_type count
)
6726 Elf_Internal_Shdr
*hdr
;
6729 if (! abfd
->output_has_begun
6730 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6733 hdr
= &elf_section_data (section
)->this_hdr
;
6734 pos
= hdr
->sh_offset
+ offset
;
6735 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
6736 || bfd_bwrite (location
, count
, abfd
) != count
)
6743 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
6744 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
6745 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
6750 /* Try to convert a non-ELF reloc into an ELF one. */
6753 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
6755 /* Check whether we really have an ELF howto. */
6757 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
6759 bfd_reloc_code_real_type code
;
6760 reloc_howto_type
*howto
;
6762 /* Alien reloc: Try to determine its type to replace it with an
6763 equivalent ELF reloc. */
6765 if (areloc
->howto
->pc_relative
)
6767 switch (areloc
->howto
->bitsize
)
6770 code
= BFD_RELOC_8_PCREL
;
6773 code
= BFD_RELOC_12_PCREL
;
6776 code
= BFD_RELOC_16_PCREL
;
6779 code
= BFD_RELOC_24_PCREL
;
6782 code
= BFD_RELOC_32_PCREL
;
6785 code
= BFD_RELOC_64_PCREL
;
6791 howto
= bfd_reloc_type_lookup (abfd
, code
);
6793 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
6795 if (howto
->pcrel_offset
)
6796 areloc
->addend
+= areloc
->address
;
6798 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
6803 switch (areloc
->howto
->bitsize
)
6809 code
= BFD_RELOC_14
;
6812 code
= BFD_RELOC_16
;
6815 code
= BFD_RELOC_26
;
6818 code
= BFD_RELOC_32
;
6821 code
= BFD_RELOC_64
;
6827 howto
= bfd_reloc_type_lookup (abfd
, code
);
6831 areloc
->howto
= howto
;
6839 (*_bfd_error_handler
)
6840 (_("%B: unsupported relocation type %s"),
6841 abfd
, areloc
->howto
->name
);
6842 bfd_set_error (bfd_error_bad_value
);
6847 _bfd_elf_close_and_cleanup (bfd
*abfd
)
6849 if (bfd_get_format (abfd
) == bfd_object
)
6851 if (elf_shstrtab (abfd
) != NULL
)
6852 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
6853 _bfd_dwarf2_cleanup_debug_info (abfd
);
6856 return _bfd_generic_close_and_cleanup (abfd
);
6859 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6860 in the relocation's offset. Thus we cannot allow any sort of sanity
6861 range-checking to interfere. There is nothing else to do in processing
6864 bfd_reloc_status_type
6865 _bfd_elf_rel_vtable_reloc_fn
6866 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
6867 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
6868 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
6869 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
6871 return bfd_reloc_ok
;
6874 /* Elf core file support. Much of this only works on native
6875 toolchains, since we rely on knowing the
6876 machine-dependent procfs structure in order to pick
6877 out details about the corefile. */
6879 #ifdef HAVE_SYS_PROCFS_H
6880 # include <sys/procfs.h>
6883 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6886 elfcore_make_pid (bfd
*abfd
)
6888 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
6889 + (elf_tdata (abfd
)->core_pid
));
6892 /* If there isn't a section called NAME, make one, using
6893 data from SECT. Note, this function will generate a
6894 reference to NAME, so you shouldn't deallocate or
6898 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
6902 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
6905 sect2
= bfd_make_section (abfd
, name
);
6909 sect2
->size
= sect
->size
;
6910 sect2
->filepos
= sect
->filepos
;
6911 sect2
->flags
= sect
->flags
;
6912 sect2
->alignment_power
= sect
->alignment_power
;
6916 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6917 actually creates up to two pseudosections:
6918 - For the single-threaded case, a section named NAME, unless
6919 such a section already exists.
6920 - For the multi-threaded case, a section named "NAME/PID", where
6921 PID is elfcore_make_pid (abfd).
6922 Both pseudosections have identical contents. */
6924 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
6930 char *threaded_name
;
6934 /* Build the section name. */
6936 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
6937 len
= strlen (buf
) + 1;
6938 threaded_name
= bfd_alloc (abfd
, len
);
6939 if (threaded_name
== NULL
)
6941 memcpy (threaded_name
, buf
, len
);
6943 sect
= bfd_make_section_anyway (abfd
, threaded_name
);
6947 sect
->filepos
= filepos
;
6948 sect
->flags
= SEC_HAS_CONTENTS
;
6949 sect
->alignment_power
= 2;
6951 return elfcore_maybe_make_sect (abfd
, name
, sect
);
6954 /* prstatus_t exists on:
6956 linux 2.[01] + glibc
6960 #if defined (HAVE_PRSTATUS_T)
6963 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6968 if (note
->descsz
== sizeof (prstatus_t
))
6972 size
= sizeof (prstat
.pr_reg
);
6973 offset
= offsetof (prstatus_t
, pr_reg
);
6974 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
6976 /* Do not overwrite the core signal if it
6977 has already been set by another thread. */
6978 if (elf_tdata (abfd
)->core_signal
== 0)
6979 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
6980 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
6982 /* pr_who exists on:
6985 pr_who doesn't exist on:
6988 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6989 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
6992 #if defined (HAVE_PRSTATUS32_T)
6993 else if (note
->descsz
== sizeof (prstatus32_t
))
6995 /* 64-bit host, 32-bit corefile */
6996 prstatus32_t prstat
;
6998 size
= sizeof (prstat
.pr_reg
);
6999 offset
= offsetof (prstatus32_t
, pr_reg
);
7000 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7002 /* Do not overwrite the core signal if it
7003 has already been set by another thread. */
7004 if (elf_tdata (abfd
)->core_signal
== 0)
7005 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7006 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7008 /* pr_who exists on:
7011 pr_who doesn't exist on:
7014 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7015 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7018 #endif /* HAVE_PRSTATUS32_T */
7021 /* Fail - we don't know how to handle any other
7022 note size (ie. data object type). */
7026 /* Make a ".reg/999" section and a ".reg" section. */
7027 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7028 size
, note
->descpos
+ offset
);
7030 #endif /* defined (HAVE_PRSTATUS_T) */
7032 /* Create a pseudosection containing the exact contents of NOTE. */
7034 elfcore_make_note_pseudosection (bfd
*abfd
,
7036 Elf_Internal_Note
*note
)
7038 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7039 note
->descsz
, note
->descpos
);
7042 /* There isn't a consistent prfpregset_t across platforms,
7043 but it doesn't matter, because we don't have to pick this
7044 data structure apart. */
7047 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7049 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7052 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7053 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7057 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7059 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7062 #if defined (HAVE_PRPSINFO_T)
7063 typedef prpsinfo_t elfcore_psinfo_t
;
7064 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7065 typedef prpsinfo32_t elfcore_psinfo32_t
;
7069 #if defined (HAVE_PSINFO_T)
7070 typedef psinfo_t elfcore_psinfo_t
;
7071 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7072 typedef psinfo32_t elfcore_psinfo32_t
;
7076 /* return a malloc'ed copy of a string at START which is at
7077 most MAX bytes long, possibly without a terminating '\0'.
7078 the copy will always have a terminating '\0'. */
7081 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7084 char *end
= memchr (start
, '\0', max
);
7092 dups
= bfd_alloc (abfd
, len
+ 1);
7096 memcpy (dups
, start
, len
);
7102 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7104 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7106 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7108 elfcore_psinfo_t psinfo
;
7110 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7112 elf_tdata (abfd
)->core_program
7113 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7114 sizeof (psinfo
.pr_fname
));
7116 elf_tdata (abfd
)->core_command
7117 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7118 sizeof (psinfo
.pr_psargs
));
7120 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7121 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7123 /* 64-bit host, 32-bit corefile */
7124 elfcore_psinfo32_t psinfo
;
7126 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7128 elf_tdata (abfd
)->core_program
7129 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7130 sizeof (psinfo
.pr_fname
));
7132 elf_tdata (abfd
)->core_command
7133 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7134 sizeof (psinfo
.pr_psargs
));
7140 /* Fail - we don't know how to handle any other
7141 note size (ie. data object type). */
7145 /* Note that for some reason, a spurious space is tacked
7146 onto the end of the args in some (at least one anyway)
7147 implementations, so strip it off if it exists. */
7150 char *command
= elf_tdata (abfd
)->core_command
;
7151 int n
= strlen (command
);
7153 if (0 < n
&& command
[n
- 1] == ' ')
7154 command
[n
- 1] = '\0';
7159 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7161 #if defined (HAVE_PSTATUS_T)
7163 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7165 if (note
->descsz
== sizeof (pstatus_t
)
7166 #if defined (HAVE_PXSTATUS_T)
7167 || note
->descsz
== sizeof (pxstatus_t
)
7173 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7175 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7177 #if defined (HAVE_PSTATUS32_T)
7178 else if (note
->descsz
== sizeof (pstatus32_t
))
7180 /* 64-bit host, 32-bit corefile */
7183 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7185 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7188 /* Could grab some more details from the "representative"
7189 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7190 NT_LWPSTATUS note, presumably. */
7194 #endif /* defined (HAVE_PSTATUS_T) */
7196 #if defined (HAVE_LWPSTATUS_T)
7198 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7200 lwpstatus_t lwpstat
;
7206 if (note
->descsz
!= sizeof (lwpstat
)
7207 #if defined (HAVE_LWPXSTATUS_T)
7208 && note
->descsz
!= sizeof (lwpxstatus_t
)
7213 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7215 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7216 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7218 /* Make a ".reg/999" section. */
7220 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7221 len
= strlen (buf
) + 1;
7222 name
= bfd_alloc (abfd
, len
);
7225 memcpy (name
, buf
, len
);
7227 sect
= bfd_make_section_anyway (abfd
, name
);
7231 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7232 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7233 sect
->filepos
= note
->descpos
7234 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7237 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7238 sect
->size
= sizeof (lwpstat
.pr_reg
);
7239 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7242 sect
->flags
= SEC_HAS_CONTENTS
;
7243 sect
->alignment_power
= 2;
7245 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7248 /* Make a ".reg2/999" section */
7250 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7251 len
= strlen (buf
) + 1;
7252 name
= bfd_alloc (abfd
, len
);
7255 memcpy (name
, buf
, len
);
7257 sect
= bfd_make_section_anyway (abfd
, name
);
7261 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7262 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7263 sect
->filepos
= note
->descpos
7264 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7267 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7268 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7269 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7272 sect
->flags
= SEC_HAS_CONTENTS
;
7273 sect
->alignment_power
= 2;
7275 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7277 #endif /* defined (HAVE_LWPSTATUS_T) */
7279 #if defined (HAVE_WIN32_PSTATUS_T)
7281 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7287 win32_pstatus_t pstatus
;
7289 if (note
->descsz
< sizeof (pstatus
))
7292 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
7294 switch (pstatus
.data_type
)
7296 case NOTE_INFO_PROCESS
:
7297 /* FIXME: need to add ->core_command. */
7298 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
7299 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
7302 case NOTE_INFO_THREAD
:
7303 /* Make a ".reg/999" section. */
7304 sprintf (buf
, ".reg/%ld", (long) pstatus
.data
.thread_info
.tid
);
7306 len
= strlen (buf
) + 1;
7307 name
= bfd_alloc (abfd
, len
);
7311 memcpy (name
, buf
, len
);
7313 sect
= bfd_make_section_anyway (abfd
, name
);
7317 sect
->size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
7318 sect
->filepos
= (note
->descpos
7319 + offsetof (struct win32_pstatus
,
7320 data
.thread_info
.thread_context
));
7321 sect
->flags
= SEC_HAS_CONTENTS
;
7322 sect
->alignment_power
= 2;
7324 if (pstatus
.data
.thread_info
.is_active_thread
)
7325 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7329 case NOTE_INFO_MODULE
:
7330 /* Make a ".module/xxxxxxxx" section. */
7331 sprintf (buf
, ".module/%08lx",
7332 (long) pstatus
.data
.module_info
.base_address
);
7334 len
= strlen (buf
) + 1;
7335 name
= bfd_alloc (abfd
, len
);
7339 memcpy (name
, buf
, len
);
7341 sect
= bfd_make_section_anyway (abfd
, name
);
7346 sect
->size
= note
->descsz
;
7347 sect
->filepos
= note
->descpos
;
7348 sect
->flags
= SEC_HAS_CONTENTS
;
7349 sect
->alignment_power
= 2;
7358 #endif /* HAVE_WIN32_PSTATUS_T */
7361 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7363 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7371 if (bed
->elf_backend_grok_prstatus
)
7372 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
7374 #if defined (HAVE_PRSTATUS_T)
7375 return elfcore_grok_prstatus (abfd
, note
);
7380 #if defined (HAVE_PSTATUS_T)
7382 return elfcore_grok_pstatus (abfd
, note
);
7385 #if defined (HAVE_LWPSTATUS_T)
7387 return elfcore_grok_lwpstatus (abfd
, note
);
7390 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
7391 return elfcore_grok_prfpreg (abfd
, note
);
7393 #if defined (HAVE_WIN32_PSTATUS_T)
7394 case NT_WIN32PSTATUS
:
7395 return elfcore_grok_win32pstatus (abfd
, note
);
7398 case NT_PRXFPREG
: /* Linux SSE extension */
7399 if (note
->namesz
== 6
7400 && strcmp (note
->namedata
, "LINUX") == 0)
7401 return elfcore_grok_prxfpreg (abfd
, note
);
7407 if (bed
->elf_backend_grok_psinfo
)
7408 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
7410 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7411 return elfcore_grok_psinfo (abfd
, note
);
7418 asection
*sect
= bfd_make_section_anyway (abfd
, ".auxv");
7422 sect
->size
= note
->descsz
;
7423 sect
->filepos
= note
->descpos
;
7424 sect
->flags
= SEC_HAS_CONTENTS
;
7425 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
7433 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
7437 cp
= strchr (note
->namedata
, '@');
7440 *lwpidp
= atoi(cp
+ 1);
7447 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7450 /* Signal number at offset 0x08. */
7451 elf_tdata (abfd
)->core_signal
7452 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
7454 /* Process ID at offset 0x50. */
7455 elf_tdata (abfd
)->core_pid
7456 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
7458 /* Command name at 0x7c (max 32 bytes, including nul). */
7459 elf_tdata (abfd
)->core_command
7460 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
7462 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
7467 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7471 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
7472 elf_tdata (abfd
)->core_lwpid
= lwp
;
7474 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
7476 /* NetBSD-specific core "procinfo". Note that we expect to
7477 find this note before any of the others, which is fine,
7478 since the kernel writes this note out first when it
7479 creates a core file. */
7481 return elfcore_grok_netbsd_procinfo (abfd
, note
);
7484 /* As of Jan 2002 there are no other machine-independent notes
7485 defined for NetBSD core files. If the note type is less
7486 than the start of the machine-dependent note types, we don't
7489 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
7493 switch (bfd_get_arch (abfd
))
7495 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7496 PT_GETFPREGS == mach+2. */
7498 case bfd_arch_alpha
:
7499 case bfd_arch_sparc
:
7502 case NT_NETBSDCORE_FIRSTMACH
+0:
7503 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7505 case NT_NETBSDCORE_FIRSTMACH
+2:
7506 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7512 /* On all other arch's, PT_GETREGS == mach+1 and
7513 PT_GETFPREGS == mach+3. */
7518 case NT_NETBSDCORE_FIRSTMACH
+1:
7519 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7521 case NT_NETBSDCORE_FIRSTMACH
+3:
7522 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7532 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, pid_t
*tid
)
7534 void *ddata
= note
->descdata
;
7541 /* nto_procfs_status 'pid' field is at offset 0. */
7542 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
7544 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7545 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
7547 /* nto_procfs_status 'flags' field is at offset 8. */
7548 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
7550 /* nto_procfs_status 'what' field is at offset 14. */
7551 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
7553 elf_tdata (abfd
)->core_signal
= sig
;
7554 elf_tdata (abfd
)->core_lwpid
= *tid
;
7557 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7558 do not come from signals so we make sure we set the current
7559 thread just in case. */
7560 if (flags
& 0x00000080)
7561 elf_tdata (abfd
)->core_lwpid
= *tid
;
7563 /* Make a ".qnx_core_status/%d" section. */
7564 sprintf (buf
, ".qnx_core_status/%ld", (long) *tid
);
7566 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7571 sect
= bfd_make_section_anyway (abfd
, name
);
7575 sect
->size
= note
->descsz
;
7576 sect
->filepos
= note
->descpos
;
7577 sect
->flags
= SEC_HAS_CONTENTS
;
7578 sect
->alignment_power
= 2;
7580 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
7584 elfcore_grok_nto_regs (bfd
*abfd
,
7585 Elf_Internal_Note
*note
,
7593 /* Make a "(base)/%d" section. */
7594 sprintf (buf
, "%s/%ld", base
, (long) tid
);
7596 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7601 sect
= bfd_make_section_anyway (abfd
, name
);
7605 sect
->size
= note
->descsz
;
7606 sect
->filepos
= note
->descpos
;
7607 sect
->flags
= SEC_HAS_CONTENTS
;
7608 sect
->alignment_power
= 2;
7610 /* This is the current thread. */
7611 if (elf_tdata (abfd
)->core_lwpid
== tid
)
7612 return elfcore_maybe_make_sect (abfd
, base
, sect
);
7617 #define BFD_QNT_CORE_INFO 7
7618 #define BFD_QNT_CORE_STATUS 8
7619 #define BFD_QNT_CORE_GREG 9
7620 #define BFD_QNT_CORE_FPREG 10
7623 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7625 /* Every GREG section has a STATUS section before it. Store the
7626 tid from the previous call to pass down to the next gregs
7628 static pid_t tid
= 1;
7632 case BFD_QNT_CORE_INFO
:
7633 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
7634 case BFD_QNT_CORE_STATUS
:
7635 return elfcore_grok_nto_status (abfd
, note
, &tid
);
7636 case BFD_QNT_CORE_GREG
:
7637 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
7638 case BFD_QNT_CORE_FPREG
:
7639 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
7645 /* Function: elfcore_write_note
7652 size of data for note
7655 End of buffer containing note. */
7658 elfcore_write_note (bfd
*abfd
,
7666 Elf_External_Note
*xnp
;
7676 const struct elf_backend_data
*bed
;
7678 namesz
= strlen (name
) + 1;
7679 bed
= get_elf_backend_data (abfd
);
7680 pad
= -namesz
& ((1 << bed
->s
->log_file_align
) - 1);
7683 newspace
= 12 + namesz
+ pad
+ size
;
7685 p
= realloc (buf
, *bufsiz
+ newspace
);
7687 *bufsiz
+= newspace
;
7688 xnp
= (Elf_External_Note
*) dest
;
7689 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
7690 H_PUT_32 (abfd
, size
, xnp
->descsz
);
7691 H_PUT_32 (abfd
, type
, xnp
->type
);
7695 memcpy (dest
, name
, namesz
);
7703 memcpy (dest
, input
, size
);
7707 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7709 elfcore_write_prpsinfo (bfd
*abfd
,
7716 char *note_name
= "CORE";
7718 #if defined (HAVE_PSINFO_T)
7720 note_type
= NT_PSINFO
;
7723 note_type
= NT_PRPSINFO
;
7726 memset (&data
, 0, sizeof (data
));
7727 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
7728 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
7729 return elfcore_write_note (abfd
, buf
, bufsiz
,
7730 note_name
, note_type
, &data
, sizeof (data
));
7732 #endif /* PSINFO_T or PRPSINFO_T */
7734 #if defined (HAVE_PRSTATUS_T)
7736 elfcore_write_prstatus (bfd
*abfd
,
7744 char *note_name
= "CORE";
7746 memset (&prstat
, 0, sizeof (prstat
));
7747 prstat
.pr_pid
= pid
;
7748 prstat
.pr_cursig
= cursig
;
7749 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
7750 return elfcore_write_note (abfd
, buf
, bufsiz
,
7751 note_name
, NT_PRSTATUS
, &prstat
, sizeof (prstat
));
7753 #endif /* HAVE_PRSTATUS_T */
7755 #if defined (HAVE_LWPSTATUS_T)
7757 elfcore_write_lwpstatus (bfd
*abfd
,
7764 lwpstatus_t lwpstat
;
7765 char *note_name
= "CORE";
7767 memset (&lwpstat
, 0, sizeof (lwpstat
));
7768 lwpstat
.pr_lwpid
= pid
>> 16;
7769 lwpstat
.pr_cursig
= cursig
;
7770 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7771 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
7772 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7774 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
7775 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
7777 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
7778 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
7781 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7782 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
7784 #endif /* HAVE_LWPSTATUS_T */
7786 #if defined (HAVE_PSTATUS_T)
7788 elfcore_write_pstatus (bfd
*abfd
,
7796 char *note_name
= "CORE";
7798 memset (&pstat
, 0, sizeof (pstat
));
7799 pstat
.pr_pid
= pid
& 0xffff;
7800 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
7801 NT_PSTATUS
, &pstat
, sizeof (pstat
));
7804 #endif /* HAVE_PSTATUS_T */
7807 elfcore_write_prfpreg (bfd
*abfd
,
7813 char *note_name
= "CORE";
7814 return elfcore_write_note (abfd
, buf
, bufsiz
,
7815 note_name
, NT_FPREGSET
, fpregs
, size
);
7819 elfcore_write_prxfpreg (bfd
*abfd
,
7822 const void *xfpregs
,
7825 char *note_name
= "LINUX";
7826 return elfcore_write_note (abfd
, buf
, bufsiz
,
7827 note_name
, NT_PRXFPREG
, xfpregs
, size
);
7831 elfcore_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
7839 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
7842 buf
= bfd_malloc (size
);
7846 if (bfd_bread (buf
, size
, abfd
) != size
)
7854 while (p
< buf
+ size
)
7856 /* FIXME: bad alignment assumption. */
7857 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
7858 Elf_Internal_Note in
;
7860 in
.type
= H_GET_32 (abfd
, xnp
->type
);
7862 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
7863 in
.namedata
= xnp
->name
;
7865 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
7866 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
7867 in
.descpos
= offset
+ (in
.descdata
- buf
);
7869 if (strncmp (in
.namedata
, "NetBSD-CORE", 11) == 0)
7871 if (! elfcore_grok_netbsd_note (abfd
, &in
))
7874 else if (strncmp (in
.namedata
, "QNX", 3) == 0)
7876 if (! elfcore_grok_nto_note (abfd
, &in
))
7881 if (! elfcore_grok_note (abfd
, &in
))
7885 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
7892 /* Providing external access to the ELF program header table. */
7894 /* Return an upper bound on the number of bytes required to store a
7895 copy of ABFD's program header table entries. Return -1 if an error
7896 occurs; bfd_get_error will return an appropriate code. */
7899 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
7901 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7903 bfd_set_error (bfd_error_wrong_format
);
7907 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
7910 /* Copy ABFD's program header table entries to *PHDRS. The entries
7911 will be stored as an array of Elf_Internal_Phdr structures, as
7912 defined in include/elf/internal.h. To find out how large the
7913 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7915 Return the number of program header table entries read, or -1 if an
7916 error occurs; bfd_get_error will return an appropriate code. */
7919 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
7923 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7925 bfd_set_error (bfd_error_wrong_format
);
7929 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
7930 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
7931 num_phdrs
* sizeof (Elf_Internal_Phdr
));
7937 _bfd_elf_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
7940 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7942 i_ehdrp
= elf_elfheader (abfd
);
7943 if (i_ehdrp
== NULL
)
7944 sprintf_vma (buf
, value
);
7947 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7949 #if BFD_HOST_64BIT_LONG
7950 sprintf (buf
, "%016lx", value
);
7952 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
7953 _bfd_int64_low (value
));
7957 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
7960 sprintf_vma (buf
, value
);
7965 _bfd_elf_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
7968 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
7970 i_ehdrp
= elf_elfheader (abfd
);
7971 if (i_ehdrp
== NULL
)
7972 fprintf_vma ((FILE *) stream
, value
);
7975 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
7977 #if BFD_HOST_64BIT_LONG
7978 fprintf ((FILE *) stream
, "%016lx", value
);
7980 fprintf ((FILE *) stream
, "%08lx%08lx",
7981 _bfd_int64_high (value
), _bfd_int64_low (value
));
7985 fprintf ((FILE *) stream
, "%08lx",
7986 (unsigned long) (value
& 0xffffffff));
7989 fprintf_vma ((FILE *) stream
, value
);
7993 enum elf_reloc_type_class
7994 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
7996 return reloc_class_normal
;
7999 /* For RELA architectures, return the relocation value for a
8000 relocation against a local symbol. */
8003 _bfd_elf_rela_local_sym (bfd
*abfd
,
8004 Elf_Internal_Sym
*sym
,
8006 Elf_Internal_Rela
*rel
)
8008 asection
*sec
= *psec
;
8011 relocation
= (sec
->output_section
->vma
8012 + sec
->output_offset
8014 if ((sec
->flags
& SEC_MERGE
)
8015 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
8016 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
8019 _bfd_merged_section_offset (abfd
, psec
,
8020 elf_section_data (sec
)->sec_info
,
8021 sym
->st_value
+ rel
->r_addend
);
8024 /* If we have changed the section, and our original section is
8025 marked with SEC_EXCLUDE, it means that the original
8026 SEC_MERGE section has been completely subsumed in some
8027 other SEC_MERGE section. In this case, we need to leave
8028 some info around for --emit-relocs. */
8029 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
8030 sec
->kept_section
= *psec
;
8033 rel
->r_addend
-= relocation
;
8034 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
8040 _bfd_elf_rel_local_sym (bfd
*abfd
,
8041 Elf_Internal_Sym
*sym
,
8045 asection
*sec
= *psec
;
8047 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
8048 return sym
->st_value
+ addend
;
8050 return _bfd_merged_section_offset (abfd
, psec
,
8051 elf_section_data (sec
)->sec_info
,
8052 sym
->st_value
+ addend
);
8056 _bfd_elf_section_offset (bfd
*abfd
,
8057 struct bfd_link_info
*info
,
8061 switch (sec
->sec_info_type
)
8063 case ELF_INFO_TYPE_STABS
:
8064 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
8066 case ELF_INFO_TYPE_EH_FRAME
:
8067 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
8073 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8074 reconstruct an ELF file by reading the segments out of remote memory
8075 based on the ELF file header at EHDR_VMA and the ELF program headers it
8076 points to. If not null, *LOADBASEP is filled in with the difference
8077 between the VMAs from which the segments were read, and the VMAs the
8078 file headers (and hence BFD's idea of each section's VMA) put them at.
8080 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8081 remote memory at target address VMA into the local buffer at MYADDR; it
8082 should return zero on success or an `errno' code on failure. TEMPL must
8083 be a BFD for an ELF target with the word size and byte order found in
8084 the remote memory. */
8087 bfd_elf_bfd_from_remote_memory
8091 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
8093 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
8094 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
8098 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
8099 long symcount ATTRIBUTE_UNUSED
,
8100 asymbol
**syms ATTRIBUTE_UNUSED
,
8105 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8108 const char *relplt_name
;
8109 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8113 Elf_Internal_Shdr
*hdr
;
8119 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
8122 if (dynsymcount
<= 0)
8125 if (!bed
->plt_sym_val
)
8128 relplt_name
= bed
->relplt_name
;
8129 if (relplt_name
== NULL
)
8130 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
8131 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
8135 hdr
= &elf_section_data (relplt
)->this_hdr
;
8136 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
8137 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
8140 plt
= bfd_get_section_by_name (abfd
, ".plt");
8144 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8145 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
8148 count
= relplt
->size
/ hdr
->sh_entsize
;
8149 size
= count
* sizeof (asymbol
);
8150 p
= relplt
->relocation
;
8151 for (i
= 0; i
< count
; i
++, s
++, p
++)
8152 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
8154 s
= *ret
= bfd_malloc (size
);
8158 names
= (char *) (s
+ count
);
8159 p
= relplt
->relocation
;
8161 for (i
= 0; i
< count
; i
++, s
++, p
++)
8166 addr
= bed
->plt_sym_val (i
, plt
, p
);
8167 if (addr
== (bfd_vma
) -1)
8170 *s
= **p
->sym_ptr_ptr
;
8172 s
->value
= addr
- plt
->vma
;
8174 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
8175 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
8177 memcpy (names
, "@plt", sizeof ("@plt"));
8178 names
+= sizeof ("@plt");
8185 /* Sort symbol by binding and section. We want to put definitions
8186 sorted by section at the beginning. */
8189 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
8191 const Elf_Internal_Sym
*s1
;
8192 const Elf_Internal_Sym
*s2
;
8195 /* Make sure that undefined symbols are at the end. */
8196 s1
= (const Elf_Internal_Sym
*) arg1
;
8197 if (s1
->st_shndx
== SHN_UNDEF
)
8199 s2
= (const Elf_Internal_Sym
*) arg2
;
8200 if (s2
->st_shndx
== SHN_UNDEF
)
8203 /* Sorted by section index. */
8204 shndx
= s1
->st_shndx
- s2
->st_shndx
;
8208 /* Sorted by binding. */
8209 return ELF_ST_BIND (s1
->st_info
) - ELF_ST_BIND (s2
->st_info
);
8214 Elf_Internal_Sym
*sym
;
8219 elf_sym_name_compare (const void *arg1
, const void *arg2
)
8221 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
8222 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
8223 return strcmp (s1
->name
, s2
->name
);
8226 /* Check if 2 sections define the same set of local and global
8230 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
)
8233 const struct elf_backend_data
*bed1
, *bed2
;
8234 Elf_Internal_Shdr
*hdr1
, *hdr2
;
8235 bfd_size_type symcount1
, symcount2
;
8236 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
8237 Elf_Internal_Sym
*isymstart1
= NULL
, *isymstart2
= NULL
, *isym
;
8238 Elf_Internal_Sym
*isymend
;
8239 struct elf_symbol
*symp
, *symtable1
= NULL
, *symtable2
= NULL
;
8240 bfd_size_type count1
, count2
, i
;
8247 /* If both are .gnu.linkonce sections, they have to have the same
8249 if (strncmp (sec1
->name
, ".gnu.linkonce",
8250 sizeof ".gnu.linkonce" - 1) == 0
8251 && strncmp (sec2
->name
, ".gnu.linkonce",
8252 sizeof ".gnu.linkonce" - 1) == 0)
8253 return strcmp (sec1
->name
+ sizeof ".gnu.linkonce",
8254 sec2
->name
+ sizeof ".gnu.linkonce") == 0;
8256 /* Both sections have to be in ELF. */
8257 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
8258 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
8261 if (elf_section_type (sec1
) != elf_section_type (sec2
))
8264 if ((elf_section_flags (sec1
) & SHF_GROUP
) != 0
8265 && (elf_section_flags (sec2
) & SHF_GROUP
) != 0)
8267 /* If both are members of section groups, they have to have the
8269 if (strcmp (elf_group_name (sec1
), elf_group_name (sec2
)) != 0)
8273 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
8274 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
8275 if (shndx1
== -1 || shndx2
== -1)
8278 bed1
= get_elf_backend_data (bfd1
);
8279 bed2
= get_elf_backend_data (bfd2
);
8280 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
8281 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
8282 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
8283 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
8285 if (symcount1
== 0 || symcount2
== 0)
8288 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
8290 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
8294 if (isymbuf1
== NULL
|| isymbuf2
== NULL
)
8297 /* Sort symbols by binding and section. Global definitions are at
8299 qsort (isymbuf1
, symcount1
, sizeof (Elf_Internal_Sym
),
8300 elf_sort_elf_symbol
);
8301 qsort (isymbuf2
, symcount2
, sizeof (Elf_Internal_Sym
),
8302 elf_sort_elf_symbol
);
8304 /* Count definitions in the section. */
8306 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
;
8307 isym
< isymend
; isym
++)
8309 if (isym
->st_shndx
== (unsigned int) shndx1
)
8316 if (count1
&& isym
->st_shndx
!= (unsigned int) shndx1
)
8321 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
;
8322 isym
< isymend
; isym
++)
8324 if (isym
->st_shndx
== (unsigned int) shndx2
)
8331 if (count2
&& isym
->st_shndx
!= (unsigned int) shndx2
)
8335 if (count1
== 0 || count2
== 0 || count1
!= count2
)
8338 symtable1
= bfd_malloc (count1
* sizeof (struct elf_symbol
));
8339 symtable2
= bfd_malloc (count1
* sizeof (struct elf_symbol
));
8341 if (symtable1
== NULL
|| symtable2
== NULL
)
8345 for (isym
= isymstart1
, isymend
= isym
+ count1
;
8346 isym
< isymend
; isym
++)
8349 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
8356 for (isym
= isymstart2
, isymend
= isym
+ count1
;
8357 isym
< isymend
; isym
++)
8360 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
8366 /* Sort symbol by name. */
8367 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
8368 elf_sym_name_compare
);
8369 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
8370 elf_sym_name_compare
);
8372 for (i
= 0; i
< count1
; i
++)
8373 /* Two symbols must have the same binding, type and name. */
8374 if (symtable1
[i
].sym
->st_info
!= symtable2
[i
].sym
->st_info
8375 || symtable1
[i
].sym
->st_other
!= symtable2
[i
].sym
->st_other
8376 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)