1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2019 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 BFD support for ELF formats is being worked on.
28 Currently, the best supported back ends are for sparc and i386
29 (running svr4 or Solaris 2).
31 Documentation of the internals of the support code still needs
32 to be written. The code is changing quickly enough that we
33 haven't bothered yet. */
35 /* For sparc64-cross-sparc32. */
44 #include "libiberty.h"
45 #include "safe-ctype.h"
46 #include "elf-linux-core.h"
52 static int elf_sort_sections (const void *, const void *);
53 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
54 static bfd_boolean
prep_headers (bfd
*);
55 static bfd_boolean
swap_out_syms (bfd
*, struct elf_strtab_hash
**, int) ;
56 static bfd_boolean
elf_read_notes (bfd
*, file_ptr
, bfd_size_type
,
58 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
59 file_ptr offset
, size_t align
);
61 /* Swap version information in and out. The version information is
62 currently size independent. If that ever changes, this code will
63 need to move into elfcode.h. */
65 /* Swap in a Verdef structure. */
68 _bfd_elf_swap_verdef_in (bfd
*abfd
,
69 const Elf_External_Verdef
*src
,
70 Elf_Internal_Verdef
*dst
)
72 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
73 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
74 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
75 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
76 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
77 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
78 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
81 /* Swap out a Verdef structure. */
84 _bfd_elf_swap_verdef_out (bfd
*abfd
,
85 const Elf_Internal_Verdef
*src
,
86 Elf_External_Verdef
*dst
)
88 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
89 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
90 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
91 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
92 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
93 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
94 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
97 /* Swap in a Verdaux structure. */
100 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
101 const Elf_External_Verdaux
*src
,
102 Elf_Internal_Verdaux
*dst
)
104 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
105 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
108 /* Swap out a Verdaux structure. */
111 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
112 const Elf_Internal_Verdaux
*src
,
113 Elf_External_Verdaux
*dst
)
115 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
116 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
119 /* Swap in a Verneed structure. */
122 _bfd_elf_swap_verneed_in (bfd
*abfd
,
123 const Elf_External_Verneed
*src
,
124 Elf_Internal_Verneed
*dst
)
126 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
127 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
128 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
129 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
130 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
133 /* Swap out a Verneed structure. */
136 _bfd_elf_swap_verneed_out (bfd
*abfd
,
137 const Elf_Internal_Verneed
*src
,
138 Elf_External_Verneed
*dst
)
140 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
141 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
142 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
143 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
144 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
147 /* Swap in a Vernaux structure. */
150 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
151 const Elf_External_Vernaux
*src
,
152 Elf_Internal_Vernaux
*dst
)
154 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
155 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
156 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
157 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
158 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
161 /* Swap out a Vernaux structure. */
164 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
165 const Elf_Internal_Vernaux
*src
,
166 Elf_External_Vernaux
*dst
)
168 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
169 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
170 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
171 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
172 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
175 /* Swap in a Versym structure. */
178 _bfd_elf_swap_versym_in (bfd
*abfd
,
179 const Elf_External_Versym
*src
,
180 Elf_Internal_Versym
*dst
)
182 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
185 /* Swap out a Versym structure. */
188 _bfd_elf_swap_versym_out (bfd
*abfd
,
189 const Elf_Internal_Versym
*src
,
190 Elf_External_Versym
*dst
)
192 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
195 /* Standard ELF hash function. Do not change this function; you will
196 cause invalid hash tables to be generated. */
199 bfd_elf_hash (const char *namearg
)
201 const unsigned char *name
= (const unsigned char *) namearg
;
206 while ((ch
= *name
++) != '\0')
209 if ((g
= (h
& 0xf0000000)) != 0)
212 /* The ELF ABI says `h &= ~g', but this is equivalent in
213 this case and on some machines one insn instead of two. */
217 return h
& 0xffffffff;
220 /* DT_GNU_HASH hash function. Do not change this function; you will
221 cause invalid hash tables to be generated. */
224 bfd_elf_gnu_hash (const char *namearg
)
226 const unsigned char *name
= (const unsigned char *) namearg
;
227 unsigned long h
= 5381;
230 while ((ch
= *name
++) != '\0')
231 h
= (h
<< 5) + h
+ ch
;
232 return h
& 0xffffffff;
235 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
236 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
238 bfd_elf_allocate_object (bfd
*abfd
,
240 enum elf_target_id object_id
)
242 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
243 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
244 if (abfd
->tdata
.any
== NULL
)
247 elf_object_id (abfd
) = object_id
;
248 if (abfd
->direction
!= read_direction
)
250 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
253 elf_tdata (abfd
)->o
= o
;
254 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
261 bfd_elf_make_object (bfd
*abfd
)
263 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
264 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
269 bfd_elf_mkcorefile (bfd
*abfd
)
271 /* I think this can be done just like an object file. */
272 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
274 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
275 return elf_tdata (abfd
)->core
!= NULL
;
279 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
281 Elf_Internal_Shdr
**i_shdrp
;
282 bfd_byte
*shstrtab
= NULL
;
284 bfd_size_type shstrtabsize
;
286 i_shdrp
= elf_elfsections (abfd
);
288 || shindex
>= elf_numsections (abfd
)
289 || i_shdrp
[shindex
] == 0)
292 shstrtab
= i_shdrp
[shindex
]->contents
;
293 if (shstrtab
== NULL
)
295 /* No cached one, attempt to read, and cache what we read. */
296 offset
= i_shdrp
[shindex
]->sh_offset
;
297 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
299 /* Allocate and clear an extra byte at the end, to prevent crashes
300 in case the string table is not terminated. */
301 if (shstrtabsize
+ 1 <= 1
302 || shstrtabsize
> bfd_get_file_size (abfd
)
303 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
304 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
)
306 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
308 if (bfd_get_error () != bfd_error_system_call
)
309 bfd_set_error (bfd_error_file_truncated
);
310 bfd_release (abfd
, shstrtab
);
312 /* Once we've failed to read it, make sure we don't keep
313 trying. Otherwise, we'll keep allocating space for
314 the string table over and over. */
315 i_shdrp
[shindex
]->sh_size
= 0;
318 shstrtab
[shstrtabsize
] = '\0';
319 i_shdrp
[shindex
]->contents
= shstrtab
;
321 return (char *) shstrtab
;
325 bfd_elf_string_from_elf_section (bfd
*abfd
,
326 unsigned int shindex
,
327 unsigned int strindex
)
329 Elf_Internal_Shdr
*hdr
;
334 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
337 hdr
= elf_elfsections (abfd
)[shindex
];
339 if (hdr
->contents
== NULL
)
341 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
343 /* PR 17512: file: f057ec89. */
344 /* xgettext:c-format */
345 _bfd_error_handler (_("%pB: attempt to load strings from"
346 " a non-string section (number %d)"),
351 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
356 /* PR 24273: The string section's contents may have already
357 been loaded elsewhere, eg because a corrupt file has the
358 string section index in the ELF header pointing at a group
359 section. So be paranoid, and test that the last byte of
360 the section is zero. */
361 if (hdr
->sh_size
== 0 || hdr
->contents
[hdr
->sh_size
- 1] != 0)
365 if (strindex
>= hdr
->sh_size
)
367 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
369 /* xgettext:c-format */
370 (_("%pB: invalid string offset %u >= %" PRIu64
" for section `%s'"),
371 abfd
, strindex
, (uint64_t) hdr
->sh_size
,
372 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
374 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
378 return ((char *) hdr
->contents
) + strindex
;
381 /* Read and convert symbols to internal format.
382 SYMCOUNT specifies the number of symbols to read, starting from
383 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
384 are non-NULL, they are used to store the internal symbols, external
385 symbols, and symbol section index extensions, respectively.
386 Returns a pointer to the internal symbol buffer (malloced if necessary)
387 or NULL if there were no symbols or some kind of problem. */
390 bfd_elf_get_elf_syms (bfd
*ibfd
,
391 Elf_Internal_Shdr
*symtab_hdr
,
394 Elf_Internal_Sym
*intsym_buf
,
396 Elf_External_Sym_Shndx
*extshndx_buf
)
398 Elf_Internal_Shdr
*shndx_hdr
;
400 const bfd_byte
*esym
;
401 Elf_External_Sym_Shndx
*alloc_extshndx
;
402 Elf_External_Sym_Shndx
*shndx
;
403 Elf_Internal_Sym
*alloc_intsym
;
404 Elf_Internal_Sym
*isym
;
405 Elf_Internal_Sym
*isymend
;
406 const struct elf_backend_data
*bed
;
411 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
417 /* Normal syms might have section extension entries. */
419 if (elf_symtab_shndx_list (ibfd
) != NULL
)
421 elf_section_list
* entry
;
422 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
424 /* Find an index section that is linked to this symtab section. */
425 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
428 if (entry
->hdr
.sh_link
>= elf_numsections (ibfd
))
431 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
433 shndx_hdr
= & entry
->hdr
;
438 if (shndx_hdr
== NULL
)
440 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
441 /* Not really accurate, but this was how the old code used to work. */
442 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
443 /* Otherwise we do nothing. The assumption is that
444 the index table will not be needed. */
448 /* Read the symbols. */
450 alloc_extshndx
= NULL
;
452 bed
= get_elf_backend_data (ibfd
);
453 extsym_size
= bed
->s
->sizeof_sym
;
454 amt
= (bfd_size_type
) symcount
* extsym_size
;
455 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
456 if (extsym_buf
== NULL
)
458 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
459 extsym_buf
= alloc_ext
;
461 if (extsym_buf
== NULL
462 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
463 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
469 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
473 amt
= (bfd_size_type
) symcount
* sizeof (Elf_External_Sym_Shndx
);
474 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
475 if (extshndx_buf
== NULL
)
477 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
478 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
479 extshndx_buf
= alloc_extshndx
;
481 if (extshndx_buf
== NULL
482 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
483 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
490 if (intsym_buf
== NULL
)
492 alloc_intsym
= (Elf_Internal_Sym
*)
493 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
494 intsym_buf
= alloc_intsym
;
495 if (intsym_buf
== NULL
)
499 /* Convert the symbols to internal form. */
500 isymend
= intsym_buf
+ symcount
;
501 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
502 shndx
= extshndx_buf
;
504 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
505 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
507 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
508 /* xgettext:c-format */
509 _bfd_error_handler (_("%pB symbol number %lu references"
510 " nonexistent SHT_SYMTAB_SHNDX section"),
511 ibfd
, (unsigned long) symoffset
);
512 if (alloc_intsym
!= NULL
)
519 if (alloc_ext
!= NULL
)
521 if (alloc_extshndx
!= NULL
)
522 free (alloc_extshndx
);
527 /* Look up a symbol name. */
529 bfd_elf_sym_name (bfd
*abfd
,
530 Elf_Internal_Shdr
*symtab_hdr
,
531 Elf_Internal_Sym
*isym
,
535 unsigned int iname
= isym
->st_name
;
536 unsigned int shindex
= symtab_hdr
->sh_link
;
538 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
539 /* Check for a bogus st_shndx to avoid crashing. */
540 && isym
->st_shndx
< elf_numsections (abfd
))
542 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
543 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
546 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
549 else if (sym_sec
&& *name
== '\0')
550 name
= bfd_section_name (abfd
, sym_sec
);
555 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
556 sections. The first element is the flags, the rest are section
559 typedef union elf_internal_group
{
560 Elf_Internal_Shdr
*shdr
;
562 } Elf_Internal_Group
;
564 /* Return the name of the group signature symbol. Why isn't the
565 signature just a string? */
568 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
570 Elf_Internal_Shdr
*hdr
;
571 unsigned char esym
[sizeof (Elf64_External_Sym
)];
572 Elf_External_Sym_Shndx eshndx
;
573 Elf_Internal_Sym isym
;
575 /* First we need to ensure the symbol table is available. Make sure
576 that it is a symbol table section. */
577 if (ghdr
->sh_link
>= elf_numsections (abfd
))
579 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
580 if (hdr
->sh_type
!= SHT_SYMTAB
581 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
584 /* Go read the symbol. */
585 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
586 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
587 &isym
, esym
, &eshndx
) == NULL
)
590 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
593 /* Set next_in_group list pointer, and group name for NEWSECT. */
596 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
598 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
600 /* If num_group is zero, read in all SHT_GROUP sections. The count
601 is set to -1 if there are no SHT_GROUP sections. */
604 unsigned int i
, shnum
;
606 /* First count the number of groups. If we have a SHT_GROUP
607 section with just a flag word (ie. sh_size is 4), ignore it. */
608 shnum
= elf_numsections (abfd
);
611 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
612 ( (shdr)->sh_type == SHT_GROUP \
613 && (shdr)->sh_size >= minsize \
614 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
615 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
617 for (i
= 0; i
< shnum
; i
++)
619 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
621 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
627 num_group
= (unsigned) -1;
628 elf_tdata (abfd
)->num_group
= num_group
;
629 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
633 /* We keep a list of elf section headers for group sections,
634 so we can find them quickly. */
637 elf_tdata (abfd
)->num_group
= num_group
;
638 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
639 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
640 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
642 memset (elf_tdata (abfd
)->group_sect_ptr
, 0,
643 num_group
* sizeof (Elf_Internal_Shdr
*));
646 for (i
= 0; i
< shnum
; i
++)
648 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
650 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
653 Elf_Internal_Group
*dest
;
655 /* Make sure the group section has a BFD section
657 if (!bfd_section_from_shdr (abfd
, i
))
660 /* Add to list of sections. */
661 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
664 /* Read the raw contents. */
665 BFD_ASSERT (sizeof (*dest
) >= 4);
666 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
667 shdr
->contents
= (unsigned char *)
668 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
669 /* PR binutils/4110: Handle corrupt group headers. */
670 if (shdr
->contents
== NULL
)
673 /* xgettext:c-format */
674 (_("%pB: corrupt size field in group section"
675 " header: %#" PRIx64
),
676 abfd
, (uint64_t) shdr
->sh_size
);
677 bfd_set_error (bfd_error_bad_value
);
682 memset (shdr
->contents
, 0, amt
);
684 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
685 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
689 /* xgettext:c-format */
690 (_("%pB: invalid size field in group section"
691 " header: %#" PRIx64
""),
692 abfd
, (uint64_t) shdr
->sh_size
);
693 bfd_set_error (bfd_error_bad_value
);
695 /* PR 17510: If the group contents are even
696 partially corrupt, do not allow any of the
697 contents to be used. */
698 memset (shdr
->contents
, 0, amt
);
702 /* Translate raw contents, a flag word followed by an
703 array of elf section indices all in target byte order,
704 to the flag word followed by an array of elf section
706 src
= shdr
->contents
+ shdr
->sh_size
;
707 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
715 idx
= H_GET_32 (abfd
, src
);
716 if (src
== shdr
->contents
)
719 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
720 shdr
->bfd_section
->flags
721 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
726 dest
->shdr
= elf_elfsections (abfd
)[idx
];
727 /* PR binutils/23199: All sections in a
728 section group should be marked with
729 SHF_GROUP. But some tools generate
730 broken objects without SHF_GROUP. Fix
732 dest
->shdr
->sh_flags
|= SHF_GROUP
;
735 || dest
->shdr
->sh_type
== SHT_GROUP
)
738 (_("%pB: invalid entry in SHT_GROUP section [%u]"),
746 /* PR 17510: Corrupt binaries might contain invalid groups. */
747 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
749 elf_tdata (abfd
)->num_group
= num_group
;
751 /* If all groups are invalid then fail. */
754 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
755 elf_tdata (abfd
)->num_group
= num_group
= -1;
757 (_("%pB: no valid group sections found"), abfd
);
758 bfd_set_error (bfd_error_bad_value
);
764 if (num_group
!= (unsigned) -1)
766 unsigned int search_offset
= elf_tdata (abfd
)->group_search_offset
;
769 for (j
= 0; j
< num_group
; j
++)
771 /* Begin search from previous found group. */
772 unsigned i
= (j
+ search_offset
) % num_group
;
774 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
775 Elf_Internal_Group
*idx
;
781 idx
= (Elf_Internal_Group
*) shdr
->contents
;
782 if (idx
== NULL
|| shdr
->sh_size
< 4)
784 /* See PR 21957 for a reproducer. */
785 /* xgettext:c-format */
786 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
787 abfd
, shdr
->bfd_section
);
788 elf_tdata (abfd
)->group_sect_ptr
[i
] = NULL
;
789 bfd_set_error (bfd_error_bad_value
);
792 n_elt
= shdr
->sh_size
/ 4;
794 /* Look through this group's sections to see if current
795 section is a member. */
797 if ((++idx
)->shdr
== hdr
)
801 /* We are a member of this group. Go looking through
802 other members to see if any others are linked via
804 idx
= (Elf_Internal_Group
*) shdr
->contents
;
805 n_elt
= shdr
->sh_size
/ 4;
807 if ((++idx
)->shdr
!= NULL
808 && (s
= idx
->shdr
->bfd_section
) != NULL
809 && elf_next_in_group (s
) != NULL
)
813 /* Snarf the group name from other member, and
814 insert current section in circular list. */
815 elf_group_name (newsect
) = elf_group_name (s
);
816 elf_next_in_group (newsect
) = elf_next_in_group (s
);
817 elf_next_in_group (s
) = newsect
;
823 gname
= group_signature (abfd
, shdr
);
826 elf_group_name (newsect
) = gname
;
828 /* Start a circular list with one element. */
829 elf_next_in_group (newsect
) = newsect
;
832 /* If the group section has been created, point to the
834 if (shdr
->bfd_section
!= NULL
)
835 elf_next_in_group (shdr
->bfd_section
) = newsect
;
837 elf_tdata (abfd
)->group_search_offset
= i
;
844 if (elf_group_name (newsect
) == NULL
)
846 /* xgettext:c-format */
847 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
855 _bfd_elf_setup_sections (bfd
*abfd
)
858 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
859 bfd_boolean result
= TRUE
;
862 /* Process SHF_LINK_ORDER. */
863 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
865 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
866 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
868 unsigned int elfsec
= this_hdr
->sh_link
;
869 /* FIXME: The old Intel compiler and old strip/objcopy may
870 not set the sh_link or sh_info fields. Hence we could
871 get the situation where elfsec is 0. */
874 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
875 if (bed
->link_order_error_handler
)
876 bed
->link_order_error_handler
877 /* xgettext:c-format */
878 (_("%pB: warning: sh_link not set for section `%pA'"),
883 asection
*linksec
= NULL
;
885 if (elfsec
< elf_numsections (abfd
))
887 this_hdr
= elf_elfsections (abfd
)[elfsec
];
888 linksec
= this_hdr
->bfd_section
;
892 Some strip/objcopy may leave an incorrect value in
893 sh_link. We don't want to proceed. */
897 /* xgettext:c-format */
898 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
899 s
->owner
, elfsec
, s
);
903 elf_linked_to_section (s
) = linksec
;
906 else if (this_hdr
->sh_type
== SHT_GROUP
907 && elf_next_in_group (s
) == NULL
)
910 /* xgettext:c-format */
911 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
912 abfd
, elf_section_data (s
)->this_idx
);
917 /* Process section groups. */
918 if (num_group
== (unsigned) -1)
921 for (i
= 0; i
< num_group
; i
++)
923 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
924 Elf_Internal_Group
*idx
;
927 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
928 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
931 /* xgettext:c-format */
932 (_("%pB: section group entry number %u is corrupt"),
938 idx
= (Elf_Internal_Group
*) shdr
->contents
;
939 n_elt
= shdr
->sh_size
/ 4;
945 if (idx
->shdr
== NULL
)
947 else if (idx
->shdr
->bfd_section
)
948 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
949 else if (idx
->shdr
->sh_type
!= SHT_RELA
950 && idx
->shdr
->sh_type
!= SHT_REL
)
952 /* There are some unknown sections in the group. */
954 /* xgettext:c-format */
955 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
958 bfd_elf_string_from_elf_section (abfd
,
959 (elf_elfheader (abfd
)
972 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
974 return elf_next_in_group (sec
) != NULL
;
978 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
980 unsigned int len
= strlen (name
);
981 char *new_name
= bfd_alloc (abfd
, len
+ 2);
982 if (new_name
== NULL
)
986 memcpy (new_name
+ 2, name
+ 1, len
);
991 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
993 unsigned int len
= strlen (name
);
994 char *new_name
= bfd_alloc (abfd
, len
);
995 if (new_name
== NULL
)
998 memcpy (new_name
+ 1, name
+ 2, len
- 1);
1002 /* Make a BFD section from an ELF section. We store a pointer to the
1003 BFD section in the bfd_section field of the header. */
1006 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
1007 Elf_Internal_Shdr
*hdr
,
1013 const struct elf_backend_data
*bed
;
1015 if (hdr
->bfd_section
!= NULL
)
1018 newsect
= bfd_make_section_anyway (abfd
, name
);
1019 if (newsect
== NULL
)
1022 hdr
->bfd_section
= newsect
;
1023 elf_section_data (newsect
)->this_hdr
= *hdr
;
1024 elf_section_data (newsect
)->this_idx
= shindex
;
1026 /* Always use the real type/flags. */
1027 elf_section_type (newsect
) = hdr
->sh_type
;
1028 elf_section_flags (newsect
) = hdr
->sh_flags
;
1030 newsect
->filepos
= hdr
->sh_offset
;
1032 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
1033 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
1034 || ! bfd_set_section_alignment (abfd
, newsect
,
1035 bfd_log2 (hdr
->sh_addralign
)))
1038 flags
= SEC_NO_FLAGS
;
1039 if (hdr
->sh_type
!= SHT_NOBITS
)
1040 flags
|= SEC_HAS_CONTENTS
;
1041 if (hdr
->sh_type
== SHT_GROUP
)
1043 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1046 if (hdr
->sh_type
!= SHT_NOBITS
)
1049 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
1050 flags
|= SEC_READONLY
;
1051 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1053 else if ((flags
& SEC_LOAD
) != 0)
1055 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
1058 newsect
->entsize
= hdr
->sh_entsize
;
1060 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
1061 flags
|= SEC_STRINGS
;
1062 if (hdr
->sh_flags
& SHF_GROUP
)
1063 if (!setup_group (abfd
, hdr
, newsect
))
1065 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
1066 flags
|= SEC_THREAD_LOCAL
;
1067 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
1068 flags
|= SEC_EXCLUDE
;
1070 if ((flags
& SEC_ALLOC
) == 0)
1072 /* The debugging sections appear to be recognized only by name,
1073 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1074 if (name
[0] == '.')
1079 p
= ".debug", n
= 6;
1080 else if (name
[1] == 'g' && name
[2] == 'n')
1081 p
= ".gnu.linkonce.wi.", n
= 17;
1082 else if (name
[1] == 'g' && name
[2] == 'd')
1083 p
= ".gdb_index", n
= 11; /* yes we really do mean 11. */
1084 else if (name
[1] == 'l')
1086 else if (name
[1] == 's')
1088 else if (name
[1] == 'z')
1089 p
= ".zdebug", n
= 7;
1092 if (p
!= NULL
&& strncmp (name
, p
, n
) == 0)
1093 flags
|= SEC_DEBUGGING
;
1097 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1098 only link a single copy of the section. This is used to support
1099 g++. g++ will emit each template expansion in its own section.
1100 The symbols will be defined as weak, so that multiple definitions
1101 are permitted. The GNU linker extension is to actually discard
1102 all but one of the sections. */
1103 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1104 && elf_next_in_group (newsect
) == NULL
)
1105 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1107 bed
= get_elf_backend_data (abfd
);
1108 if (bed
->elf_backend_section_flags
)
1109 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1112 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
1115 /* We do not parse the PT_NOTE segments as we are interested even in the
1116 separate debug info files which may have the segments offsets corrupted.
1117 PT_NOTEs from the core files are currently not parsed using BFD. */
1118 if (hdr
->sh_type
== SHT_NOTE
)
1122 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1125 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1126 hdr
->sh_offset
, hdr
->sh_addralign
);
1130 if ((flags
& SEC_ALLOC
) != 0)
1132 Elf_Internal_Phdr
*phdr
;
1133 unsigned int i
, nload
;
1135 /* Some ELF linkers produce binaries with all the program header
1136 p_paddr fields zero. If we have such a binary with more than
1137 one PT_LOAD header, then leave the section lma equal to vma
1138 so that we don't create sections with overlapping lma. */
1139 phdr
= elf_tdata (abfd
)->phdr
;
1140 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1141 if (phdr
->p_paddr
!= 0)
1143 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1145 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1148 phdr
= elf_tdata (abfd
)->phdr
;
1149 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1151 if (((phdr
->p_type
== PT_LOAD
1152 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1153 || phdr
->p_type
== PT_TLS
)
1154 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1156 if ((flags
& SEC_LOAD
) == 0)
1157 newsect
->lma
= (phdr
->p_paddr
1158 + hdr
->sh_addr
- phdr
->p_vaddr
);
1160 /* We used to use the same adjustment for SEC_LOAD
1161 sections, but that doesn't work if the segment
1162 is packed with code from multiple VMAs.
1163 Instead we calculate the section LMA based on
1164 the segment LMA. It is assumed that the
1165 segment will contain sections with contiguous
1166 LMAs, even if the VMAs are not. */
1167 newsect
->lma
= (phdr
->p_paddr
1168 + hdr
->sh_offset
- phdr
->p_offset
);
1170 /* With contiguous segments, we can't tell from file
1171 offsets whether a section with zero size should
1172 be placed at the end of one segment or the
1173 beginning of the next. Decide based on vaddr. */
1174 if (hdr
->sh_addr
>= phdr
->p_vaddr
1175 && (hdr
->sh_addr
+ hdr
->sh_size
1176 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1182 /* Compress/decompress DWARF debug sections with names: .debug_* and
1183 .zdebug_*, after the section flags is set. */
1184 if ((flags
& SEC_DEBUGGING
)
1185 && ((name
[1] == 'd' && name
[6] == '_')
1186 || (name
[1] == 'z' && name
[7] == '_')))
1188 enum { nothing
, compress
, decompress
} action
= nothing
;
1189 int compression_header_size
;
1190 bfd_size_type uncompressed_size
;
1191 unsigned int uncompressed_align_power
;
1192 bfd_boolean compressed
1193 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1194 &compression_header_size
,
1196 &uncompressed_align_power
);
1199 /* Compressed section. Check if we should decompress. */
1200 if ((abfd
->flags
& BFD_DECOMPRESS
))
1201 action
= decompress
;
1204 /* Compress the uncompressed section or convert from/to .zdebug*
1205 section. Check if we should compress. */
1206 if (action
== nothing
)
1208 if (newsect
->size
!= 0
1209 && (abfd
->flags
& BFD_COMPRESS
)
1210 && compression_header_size
>= 0
1211 && uncompressed_size
> 0
1213 || ((compression_header_size
> 0)
1214 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1220 if (action
== compress
)
1222 if (!bfd_init_section_compress_status (abfd
, newsect
))
1225 /* xgettext:c-format */
1226 (_("%pB: unable to initialize compress status for section %s"),
1233 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1236 /* xgettext:c-format */
1237 (_("%pB: unable to initialize decompress status for section %s"),
1243 if (abfd
->is_linker_input
)
1246 && (action
== decompress
1247 || (action
== compress
1248 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1250 /* Convert section name from .zdebug_* to .debug_* so
1251 that linker will consider this section as a debug
1253 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1254 if (new_name
== NULL
)
1256 bfd_rename_section (abfd
, newsect
, new_name
);
1260 /* For objdump, don't rename the section. For objcopy, delay
1261 section rename to elf_fake_sections. */
1262 newsect
->flags
|= SEC_ELF_RENAME
;
1268 const char *const bfd_elf_section_type_names
[] =
1270 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1271 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1272 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1275 /* ELF relocs are against symbols. If we are producing relocatable
1276 output, and the reloc is against an external symbol, and nothing
1277 has given us any additional addend, the resulting reloc will also
1278 be against the same symbol. In such a case, we don't want to
1279 change anything about the way the reloc is handled, since it will
1280 all be done at final link time. Rather than put special case code
1281 into bfd_perform_relocation, all the reloc types use this howto
1282 function. It just short circuits the reloc if producing
1283 relocatable output against an external symbol. */
1285 bfd_reloc_status_type
1286 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1287 arelent
*reloc_entry
,
1289 void *data ATTRIBUTE_UNUSED
,
1290 asection
*input_section
,
1292 char **error_message ATTRIBUTE_UNUSED
)
1294 if (output_bfd
!= NULL
1295 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1296 && (! reloc_entry
->howto
->partial_inplace
1297 || reloc_entry
->addend
== 0))
1299 reloc_entry
->address
+= input_section
->output_offset
;
1300 return bfd_reloc_ok
;
1303 return bfd_reloc_continue
;
1306 /* Returns TRUE if section A matches section B.
1307 Names, addresses and links may be different, but everything else
1308 should be the same. */
1311 section_match (const Elf_Internal_Shdr
* a
,
1312 const Elf_Internal_Shdr
* b
)
1314 if (a
->sh_type
!= b
->sh_type
1315 || ((a
->sh_flags
^ b
->sh_flags
) & ~SHF_INFO_LINK
) != 0
1316 || a
->sh_addralign
!= b
->sh_addralign
1317 || a
->sh_entsize
!= b
->sh_entsize
)
1319 if (a
->sh_type
== SHT_SYMTAB
1320 || a
->sh_type
== SHT_STRTAB
)
1322 return a
->sh_size
== b
->sh_size
;
1325 /* Find a section in OBFD that has the same characteristics
1326 as IHEADER. Return the index of this section or SHN_UNDEF if
1327 none can be found. Check's section HINT first, as this is likely
1328 to be the correct section. */
1331 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1332 const unsigned int hint
)
1334 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1337 BFD_ASSERT (iheader
!= NULL
);
1339 /* See PR 20922 for a reproducer of the NULL test. */
1340 if (hint
< elf_numsections (obfd
)
1341 && oheaders
[hint
] != NULL
1342 && section_match (oheaders
[hint
], iheader
))
1345 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1347 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1349 if (oheader
== NULL
)
1351 if (section_match (oheader
, iheader
))
1352 /* FIXME: Do we care if there is a potential for
1353 multiple matches ? */
1360 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1361 Processor specific section, based upon a matching input section.
1362 Returns TRUE upon success, FALSE otherwise. */
1365 copy_special_section_fields (const bfd
*ibfd
,
1367 const Elf_Internal_Shdr
*iheader
,
1368 Elf_Internal_Shdr
*oheader
,
1369 const unsigned int secnum
)
1371 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1372 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1373 bfd_boolean changed
= FALSE
;
1374 unsigned int sh_link
;
1376 if (oheader
->sh_type
== SHT_NOBITS
)
1378 /* This is a feature for objcopy --only-keep-debug:
1379 When a section's type is changed to NOBITS, we preserve
1380 the sh_link and sh_info fields so that they can be
1381 matched up with the original.
1383 Note: Strictly speaking these assignments are wrong.
1384 The sh_link and sh_info fields should point to the
1385 relevent sections in the output BFD, which may not be in
1386 the same location as they were in the input BFD. But
1387 the whole point of this action is to preserve the
1388 original values of the sh_link and sh_info fields, so
1389 that they can be matched up with the section headers in
1390 the original file. So strictly speaking we may be
1391 creating an invalid ELF file, but it is only for a file
1392 that just contains debug info and only for sections
1393 without any contents. */
1394 if (oheader
->sh_link
== 0)
1395 oheader
->sh_link
= iheader
->sh_link
;
1396 if (oheader
->sh_info
== 0)
1397 oheader
->sh_info
= iheader
->sh_info
;
1401 /* Allow the target a chance to decide how these fields should be set. */
1402 if (bed
->elf_backend_copy_special_section_fields
!= NULL
1403 && bed
->elf_backend_copy_special_section_fields
1404 (ibfd
, obfd
, iheader
, oheader
))
1407 /* We have an iheader which might match oheader, and which has non-zero
1408 sh_info and/or sh_link fields. Attempt to follow those links and find
1409 the section in the output bfd which corresponds to the linked section
1410 in the input bfd. */
1411 if (iheader
->sh_link
!= SHN_UNDEF
)
1413 /* See PR 20931 for a reproducer. */
1414 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1417 /* xgettext:c-format */
1418 (_("%pB: invalid sh_link field (%d) in section number %d"),
1419 ibfd
, iheader
->sh_link
, secnum
);
1423 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1424 if (sh_link
!= SHN_UNDEF
)
1426 oheader
->sh_link
= sh_link
;
1430 /* FIXME: Should we install iheader->sh_link
1431 if we could not find a match ? */
1433 /* xgettext:c-format */
1434 (_("%pB: failed to find link section for section %d"), obfd
, secnum
);
1437 if (iheader
->sh_info
)
1439 /* The sh_info field can hold arbitrary information, but if the
1440 SHF_LINK_INFO flag is set then it should be interpreted as a
1442 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1444 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1446 if (sh_link
!= SHN_UNDEF
)
1447 oheader
->sh_flags
|= SHF_INFO_LINK
;
1450 /* No idea what it means - just copy it. */
1451 sh_link
= iheader
->sh_info
;
1453 if (sh_link
!= SHN_UNDEF
)
1455 oheader
->sh_info
= sh_link
;
1460 /* xgettext:c-format */
1461 (_("%pB: failed to find info section for section %d"), obfd
, secnum
);
1467 /* Copy the program header and other data from one object module to
1471 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1473 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1474 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1475 const struct elf_backend_data
*bed
;
1478 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1479 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1482 if (!elf_flags_init (obfd
))
1484 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1485 elf_flags_init (obfd
) = TRUE
;
1488 elf_gp (obfd
) = elf_gp (ibfd
);
1490 /* Also copy the EI_OSABI field. */
1491 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1492 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1494 /* If set, copy the EI_ABIVERSION field. */
1495 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1496 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1497 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1499 /* Copy object attributes. */
1500 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1502 if (iheaders
== NULL
|| oheaders
== NULL
)
1505 bed
= get_elf_backend_data (obfd
);
1507 /* Possibly copy other fields in the section header. */
1508 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1511 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1513 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1514 because of a special case need for generating separate debug info
1515 files. See below for more details. */
1517 || (oheader
->sh_type
!= SHT_NOBITS
1518 && oheader
->sh_type
< SHT_LOOS
))
1521 /* Ignore empty sections, and sections whose
1522 fields have already been initialised. */
1523 if (oheader
->sh_size
== 0
1524 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1527 /* Scan for the matching section in the input bfd.
1528 First we try for a direct mapping between the input and output sections. */
1529 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1531 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1533 if (iheader
== NULL
)
1536 if (oheader
->bfd_section
!= NULL
1537 && iheader
->bfd_section
!= NULL
1538 && iheader
->bfd_section
->output_section
!= NULL
1539 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1541 /* We have found a connection from the input section to the
1542 output section. Attempt to copy the header fields. If
1543 this fails then do not try any further sections - there
1544 should only be a one-to-one mapping between input and output. */
1545 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1546 j
= elf_numsections (ibfd
);
1551 if (j
< elf_numsections (ibfd
))
1554 /* That failed. So try to deduce the corresponding input section.
1555 Unfortunately we cannot compare names as the output string table
1556 is empty, so instead we check size, address and type. */
1557 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1559 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1561 if (iheader
== NULL
)
1564 /* Try matching fields in the input section's header.
1565 Since --only-keep-debug turns all non-debug sections into
1566 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1568 if ((oheader
->sh_type
== SHT_NOBITS
1569 || iheader
->sh_type
== oheader
->sh_type
)
1570 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1571 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1572 && iheader
->sh_addralign
== oheader
->sh_addralign
1573 && iheader
->sh_entsize
== oheader
->sh_entsize
1574 && iheader
->sh_size
== oheader
->sh_size
1575 && iheader
->sh_addr
== oheader
->sh_addr
1576 && (iheader
->sh_info
!= oheader
->sh_info
1577 || iheader
->sh_link
!= oheader
->sh_link
))
1579 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1584 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1586 /* Final attempt. Call the backend copy function
1587 with a NULL input section. */
1588 if (bed
->elf_backend_copy_special_section_fields
!= NULL
)
1589 bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
, NULL
, oheader
);
1597 get_segment_type (unsigned int p_type
)
1602 case PT_NULL
: pt
= "NULL"; break;
1603 case PT_LOAD
: pt
= "LOAD"; break;
1604 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1605 case PT_INTERP
: pt
= "INTERP"; break;
1606 case PT_NOTE
: pt
= "NOTE"; break;
1607 case PT_SHLIB
: pt
= "SHLIB"; break;
1608 case PT_PHDR
: pt
= "PHDR"; break;
1609 case PT_TLS
: pt
= "TLS"; break;
1610 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1611 case PT_GNU_STACK
: pt
= "STACK"; break;
1612 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1613 default: pt
= NULL
; break;
1618 /* Print out the program headers. */
1621 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1623 FILE *f
= (FILE *) farg
;
1624 Elf_Internal_Phdr
*p
;
1626 bfd_byte
*dynbuf
= NULL
;
1628 p
= elf_tdata (abfd
)->phdr
;
1633 fprintf (f
, _("\nProgram Header:\n"));
1634 c
= elf_elfheader (abfd
)->e_phnum
;
1635 for (i
= 0; i
< c
; i
++, p
++)
1637 const char *pt
= get_segment_type (p
->p_type
);
1642 sprintf (buf
, "0x%lx", p
->p_type
);
1645 fprintf (f
, "%8s off 0x", pt
);
1646 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1647 fprintf (f
, " vaddr 0x");
1648 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1649 fprintf (f
, " paddr 0x");
1650 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1651 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1652 fprintf (f
, " filesz 0x");
1653 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1654 fprintf (f
, " memsz 0x");
1655 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1656 fprintf (f
, " flags %c%c%c",
1657 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1658 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1659 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1660 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1661 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1666 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1669 unsigned int elfsec
;
1670 unsigned long shlink
;
1671 bfd_byte
*extdyn
, *extdynend
;
1673 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1675 fprintf (f
, _("\nDynamic Section:\n"));
1677 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1680 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1681 if (elfsec
== SHN_BAD
)
1683 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1685 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1686 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1689 /* PR 17512: file: 6f427532. */
1690 if (s
->size
< extdynsize
)
1692 extdynend
= extdyn
+ s
->size
;
1693 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1695 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1697 Elf_Internal_Dyn dyn
;
1698 const char *name
= "";
1700 bfd_boolean stringp
;
1701 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1703 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1705 if (dyn
.d_tag
== DT_NULL
)
1712 if (bed
->elf_backend_get_target_dtag
)
1713 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1715 if (!strcmp (name
, ""))
1717 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1722 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1723 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1724 case DT_PLTGOT
: name
= "PLTGOT"; break;
1725 case DT_HASH
: name
= "HASH"; break;
1726 case DT_STRTAB
: name
= "STRTAB"; break;
1727 case DT_SYMTAB
: name
= "SYMTAB"; break;
1728 case DT_RELA
: name
= "RELA"; break;
1729 case DT_RELASZ
: name
= "RELASZ"; break;
1730 case DT_RELAENT
: name
= "RELAENT"; break;
1731 case DT_STRSZ
: name
= "STRSZ"; break;
1732 case DT_SYMENT
: name
= "SYMENT"; break;
1733 case DT_INIT
: name
= "INIT"; break;
1734 case DT_FINI
: name
= "FINI"; break;
1735 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1736 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1737 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1738 case DT_REL
: name
= "REL"; break;
1739 case DT_RELSZ
: name
= "RELSZ"; break;
1740 case DT_RELENT
: name
= "RELENT"; break;
1741 case DT_PLTREL
: name
= "PLTREL"; break;
1742 case DT_DEBUG
: name
= "DEBUG"; break;
1743 case DT_TEXTREL
: name
= "TEXTREL"; break;
1744 case DT_JMPREL
: name
= "JMPREL"; break;
1745 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1746 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1747 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1748 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1749 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1750 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1751 case DT_FLAGS
: name
= "FLAGS"; break;
1752 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1753 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1754 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1755 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1756 case DT_MOVEENT
: name
= "MOVEENT"; break;
1757 case DT_MOVESZ
: name
= "MOVESZ"; break;
1758 case DT_FEATURE
: name
= "FEATURE"; break;
1759 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1760 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1761 case DT_SYMINENT
: name
= "SYMINENT"; break;
1762 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1763 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1764 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1765 case DT_PLTPAD
: name
= "PLTPAD"; break;
1766 case DT_MOVETAB
: name
= "MOVETAB"; break;
1767 case DT_SYMINFO
: name
= "SYMINFO"; break;
1768 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1769 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1770 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1771 case DT_VERSYM
: name
= "VERSYM"; break;
1772 case DT_VERDEF
: name
= "VERDEF"; break;
1773 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1774 case DT_VERNEED
: name
= "VERNEED"; break;
1775 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1776 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1777 case DT_USED
: name
= "USED"; break;
1778 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1779 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1782 fprintf (f
, " %-20s ", name
);
1786 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1791 unsigned int tagv
= dyn
.d_un
.d_val
;
1793 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1796 fprintf (f
, "%s", string
);
1805 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1806 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1808 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1812 if (elf_dynverdef (abfd
) != 0)
1814 Elf_Internal_Verdef
*t
;
1816 fprintf (f
, _("\nVersion definitions:\n"));
1817 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1819 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1820 t
->vd_flags
, t
->vd_hash
,
1821 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1822 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1824 Elf_Internal_Verdaux
*a
;
1827 for (a
= t
->vd_auxptr
->vda_nextptr
;
1831 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1837 if (elf_dynverref (abfd
) != 0)
1839 Elf_Internal_Verneed
*t
;
1841 fprintf (f
, _("\nVersion References:\n"));
1842 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1844 Elf_Internal_Vernaux
*a
;
1846 fprintf (f
, _(" required from %s:\n"),
1847 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1848 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1849 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1850 a
->vna_flags
, a
->vna_other
,
1851 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1863 /* Get version string. */
1866 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1867 bfd_boolean
*hidden
)
1869 const char *version_string
= NULL
;
1870 if (elf_dynversym (abfd
) != 0
1871 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1873 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1875 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1876 vernum
&= VERSYM_VERSION
;
1879 version_string
= "";
1880 else if (vernum
== 1
1881 && (vernum
> elf_tdata (abfd
)->cverdefs
1882 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1884 version_string
= "Base";
1885 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1887 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1890 Elf_Internal_Verneed
*t
;
1892 version_string
= _("<corrupt>");
1893 for (t
= elf_tdata (abfd
)->verref
;
1897 Elf_Internal_Vernaux
*a
;
1899 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1901 if (a
->vna_other
== vernum
)
1903 version_string
= a
->vna_nodename
;
1910 return version_string
;
1913 /* Display ELF-specific fields of a symbol. */
1916 bfd_elf_print_symbol (bfd
*abfd
,
1919 bfd_print_symbol_type how
)
1921 FILE *file
= (FILE *) filep
;
1924 case bfd_print_symbol_name
:
1925 fprintf (file
, "%s", symbol
->name
);
1927 case bfd_print_symbol_more
:
1928 fprintf (file
, "elf ");
1929 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1930 fprintf (file
, " %x", symbol
->flags
);
1932 case bfd_print_symbol_all
:
1934 const char *section_name
;
1935 const char *name
= NULL
;
1936 const struct elf_backend_data
*bed
;
1937 unsigned char st_other
;
1939 const char *version_string
;
1942 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1944 bed
= get_elf_backend_data (abfd
);
1945 if (bed
->elf_backend_print_symbol_all
)
1946 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1950 name
= symbol
->name
;
1951 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1954 fprintf (file
, " %s\t", section_name
);
1955 /* Print the "other" value for a symbol. For common symbols,
1956 we've already printed the size; now print the alignment.
1957 For other symbols, we have no specified alignment, and
1958 we've printed the address; now print the size. */
1959 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1960 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1962 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1963 bfd_fprintf_vma (abfd
, file
, val
);
1965 /* If we have version information, print it. */
1966 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
1972 fprintf (file
, " %-11s", version_string
);
1977 fprintf (file
, " (%s)", version_string
);
1978 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1983 /* If the st_other field is not zero, print it. */
1984 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1989 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1990 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1991 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1993 /* Some other non-defined flags are also present, so print
1995 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1998 fprintf (file
, " %s", name
);
2004 /* ELF .o/exec file reading */
2006 /* Create a new bfd section from an ELF section header. */
2009 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2011 Elf_Internal_Shdr
*hdr
;
2012 Elf_Internal_Ehdr
*ehdr
;
2013 const struct elf_backend_data
*bed
;
2015 bfd_boolean ret
= TRUE
;
2016 static bfd_boolean
* sections_being_created
= NULL
;
2017 static bfd
* sections_being_created_abfd
= NULL
;
2018 static unsigned int nesting
= 0;
2020 if (shindex
>= elf_numsections (abfd
))
2025 /* PR17512: A corrupt ELF binary might contain a recursive group of
2026 sections, with each the string indices pointing to the next in the
2027 loop. Detect this here, by refusing to load a section that we are
2028 already in the process of loading. We only trigger this test if
2029 we have nested at least three sections deep as normal ELF binaries
2030 can expect to recurse at least once.
2032 FIXME: It would be better if this array was attached to the bfd,
2033 rather than being held in a static pointer. */
2035 if (sections_being_created_abfd
!= abfd
)
2036 sections_being_created
= NULL
;
2037 if (sections_being_created
== NULL
)
2039 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
2040 sections_being_created
= (bfd_boolean
*)
2041 bfd_zalloc (abfd
, elf_numsections (abfd
) * sizeof (bfd_boolean
));
2042 sections_being_created_abfd
= abfd
;
2044 if (sections_being_created
[shindex
])
2047 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2050 sections_being_created
[shindex
] = TRUE
;
2053 hdr
= elf_elfsections (abfd
)[shindex
];
2054 ehdr
= elf_elfheader (abfd
);
2055 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2060 bed
= get_elf_backend_data (abfd
);
2061 switch (hdr
->sh_type
)
2064 /* Inactive section. Throw it away. */
2067 case SHT_PROGBITS
: /* Normal section with contents. */
2068 case SHT_NOBITS
: /* .bss section. */
2069 case SHT_HASH
: /* .hash section. */
2070 case SHT_NOTE
: /* .note section. */
2071 case SHT_INIT_ARRAY
: /* .init_array section. */
2072 case SHT_FINI_ARRAY
: /* .fini_array section. */
2073 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2074 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2075 case SHT_GNU_HASH
: /* .gnu.hash section. */
2076 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2079 case SHT_DYNAMIC
: /* Dynamic linking information. */
2080 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2083 if (hdr
->sh_link
> elf_numsections (abfd
))
2085 /* PR 10478: Accept Solaris binaries with a sh_link
2086 field set to SHN_BEFORE or SHN_AFTER. */
2087 switch (bfd_get_arch (abfd
))
2090 case bfd_arch_sparc
:
2091 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2092 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2094 /* Otherwise fall through. */
2099 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2101 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2103 Elf_Internal_Shdr
*dynsymhdr
;
2105 /* The shared libraries distributed with hpux11 have a bogus
2106 sh_link field for the ".dynamic" section. Find the
2107 string table for the ".dynsym" section instead. */
2108 if (elf_dynsymtab (abfd
) != 0)
2110 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2111 hdr
->sh_link
= dynsymhdr
->sh_link
;
2115 unsigned int i
, num_sec
;
2117 num_sec
= elf_numsections (abfd
);
2118 for (i
= 1; i
< num_sec
; i
++)
2120 dynsymhdr
= elf_elfsections (abfd
)[i
];
2121 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2123 hdr
->sh_link
= dynsymhdr
->sh_link
;
2131 case SHT_SYMTAB
: /* A symbol table. */
2132 if (elf_onesymtab (abfd
) == shindex
)
2135 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2138 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2140 if (hdr
->sh_size
!= 0)
2142 /* Some assemblers erroneously set sh_info to one with a
2143 zero sh_size. ld sees this as a global symbol count
2144 of (unsigned) -1. Fix it here. */
2149 /* PR 18854: A binary might contain more than one symbol table.
2150 Unusual, but possible. Warn, but continue. */
2151 if (elf_onesymtab (abfd
) != 0)
2154 /* xgettext:c-format */
2155 (_("%pB: warning: multiple symbol tables detected"
2156 " - ignoring the table in section %u"),
2160 elf_onesymtab (abfd
) = shindex
;
2161 elf_symtab_hdr (abfd
) = *hdr
;
2162 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2163 abfd
->flags
|= HAS_SYMS
;
2165 /* Sometimes a shared object will map in the symbol table. If
2166 SHF_ALLOC is set, and this is a shared object, then we also
2167 treat this section as a BFD section. We can not base the
2168 decision purely on SHF_ALLOC, because that flag is sometimes
2169 set in a relocatable object file, which would confuse the
2171 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2172 && (abfd
->flags
& DYNAMIC
) != 0
2173 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2177 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2178 can't read symbols without that section loaded as well. It
2179 is most likely specified by the next section header. */
2181 elf_section_list
* entry
;
2182 unsigned int i
, num_sec
;
2184 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2185 if (entry
->hdr
.sh_link
== shindex
)
2188 num_sec
= elf_numsections (abfd
);
2189 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2191 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2193 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2194 && hdr2
->sh_link
== shindex
)
2199 for (i
= 1; i
< shindex
; i
++)
2201 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2203 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2204 && hdr2
->sh_link
== shindex
)
2209 ret
= bfd_section_from_shdr (abfd
, i
);
2210 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2214 case SHT_DYNSYM
: /* A dynamic symbol table. */
2215 if (elf_dynsymtab (abfd
) == shindex
)
2218 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2221 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2223 if (hdr
->sh_size
!= 0)
2226 /* Some linkers erroneously set sh_info to one with a
2227 zero sh_size. ld sees this as a global symbol count
2228 of (unsigned) -1. Fix it here. */
2233 /* PR 18854: A binary might contain more than one dynamic symbol table.
2234 Unusual, but possible. Warn, but continue. */
2235 if (elf_dynsymtab (abfd
) != 0)
2238 /* xgettext:c-format */
2239 (_("%pB: warning: multiple dynamic symbol tables detected"
2240 " - ignoring the table in section %u"),
2244 elf_dynsymtab (abfd
) = shindex
;
2245 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2246 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2247 abfd
->flags
|= HAS_SYMS
;
2249 /* Besides being a symbol table, we also treat this as a regular
2250 section, so that objcopy can handle it. */
2251 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2254 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2256 elf_section_list
* entry
;
2258 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2259 if (entry
->ndx
== shindex
)
2262 entry
= bfd_alloc (abfd
, sizeof * entry
);
2265 entry
->ndx
= shindex
;
2267 entry
->next
= elf_symtab_shndx_list (abfd
);
2268 elf_symtab_shndx_list (abfd
) = entry
;
2269 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2273 case SHT_STRTAB
: /* A string table. */
2274 if (hdr
->bfd_section
!= NULL
)
2277 if (ehdr
->e_shstrndx
== shindex
)
2279 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2280 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2284 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2287 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2288 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2292 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2295 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2296 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2297 elf_elfsections (abfd
)[shindex
] = hdr
;
2298 /* We also treat this as a regular section, so that objcopy
2300 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2305 /* If the string table isn't one of the above, then treat it as a
2306 regular section. We need to scan all the headers to be sure,
2307 just in case this strtab section appeared before the above. */
2308 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2310 unsigned int i
, num_sec
;
2312 num_sec
= elf_numsections (abfd
);
2313 for (i
= 1; i
< num_sec
; i
++)
2315 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2316 if (hdr2
->sh_link
== shindex
)
2318 /* Prevent endless recursion on broken objects. */
2321 if (! bfd_section_from_shdr (abfd
, i
))
2323 if (elf_onesymtab (abfd
) == i
)
2325 if (elf_dynsymtab (abfd
) == i
)
2326 goto dynsymtab_strtab
;
2330 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2335 /* *These* do a lot of work -- but build no sections! */
2337 asection
*target_sect
;
2338 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2339 unsigned int num_sec
= elf_numsections (abfd
);
2340 struct bfd_elf_section_data
*esdt
;
2343 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2344 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2347 /* Check for a bogus link to avoid crashing. */
2348 if (hdr
->sh_link
>= num_sec
)
2351 /* xgettext:c-format */
2352 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2353 abfd
, hdr
->sh_link
, name
, shindex
);
2354 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2359 /* For some incomprehensible reason Oracle distributes
2360 libraries for Solaris in which some of the objects have
2361 bogus sh_link fields. It would be nice if we could just
2362 reject them, but, unfortunately, some people need to use
2363 them. We scan through the section headers; if we find only
2364 one suitable symbol table, we clobber the sh_link to point
2365 to it. I hope this doesn't break anything.
2367 Don't do it on executable nor shared library. */
2368 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2369 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2370 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2376 for (scan
= 1; scan
< num_sec
; scan
++)
2378 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2379 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2390 hdr
->sh_link
= found
;
2393 /* Get the symbol table. */
2394 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2395 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2396 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2399 /* If this is an alloc section in an executable or shared
2400 library, or the reloc section does not use the main symbol
2401 table we don't treat it as a reloc section. BFD can't
2402 adequately represent such a section, so at least for now,
2403 we don't try. We just present it as a normal section. We
2404 also can't use it as a reloc section if it points to the
2405 null section, an invalid section, another reloc section, or
2406 its sh_link points to the null section. */
2407 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2408 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2409 || hdr
->sh_link
== SHN_UNDEF
2410 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2411 || hdr
->sh_info
== SHN_UNDEF
2412 || hdr
->sh_info
>= num_sec
2413 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2414 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2416 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2421 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2424 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2425 if (target_sect
== NULL
)
2428 esdt
= elf_section_data (target_sect
);
2429 if (hdr
->sh_type
== SHT_RELA
)
2430 p_hdr
= &esdt
->rela
.hdr
;
2432 p_hdr
= &esdt
->rel
.hdr
;
2434 /* PR 17512: file: 0b4f81b7. */
2437 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2442 elf_elfsections (abfd
)[shindex
] = hdr2
;
2443 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2444 * bed
->s
->int_rels_per_ext_rel
);
2445 target_sect
->flags
|= SEC_RELOC
;
2446 target_sect
->relocation
= NULL
;
2447 target_sect
->rel_filepos
= hdr
->sh_offset
;
2448 /* In the section to which the relocations apply, mark whether
2449 its relocations are of the REL or RELA variety. */
2450 if (hdr
->sh_size
!= 0)
2452 if (hdr
->sh_type
== SHT_RELA
)
2453 target_sect
->use_rela_p
= 1;
2455 abfd
->flags
|= HAS_RELOC
;
2459 case SHT_GNU_verdef
:
2460 elf_dynverdef (abfd
) = shindex
;
2461 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2462 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2465 case SHT_GNU_versym
:
2466 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2469 elf_dynversym (abfd
) = shindex
;
2470 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2471 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2474 case SHT_GNU_verneed
:
2475 elf_dynverref (abfd
) = shindex
;
2476 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2477 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2484 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2487 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2493 /* Possibly an attributes section. */
2494 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2495 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2497 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2499 _bfd_elf_parse_attributes (abfd
, hdr
);
2503 /* Check for any processor-specific section types. */
2504 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2507 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2509 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2510 /* FIXME: How to properly handle allocated section reserved
2511 for applications? */
2513 /* xgettext:c-format */
2514 (_("%pB: unknown type [%#x] section `%s'"),
2515 abfd
, hdr
->sh_type
, name
);
2518 /* Allow sections reserved for applications. */
2519 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2524 else if (hdr
->sh_type
>= SHT_LOPROC
2525 && hdr
->sh_type
<= SHT_HIPROC
)
2526 /* FIXME: We should handle this section. */
2528 /* xgettext:c-format */
2529 (_("%pB: unknown type [%#x] section `%s'"),
2530 abfd
, hdr
->sh_type
, name
);
2531 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2533 /* Unrecognised OS-specific sections. */
2534 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2535 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2536 required to correctly process the section and the file should
2537 be rejected with an error message. */
2539 /* xgettext:c-format */
2540 (_("%pB: unknown type [%#x] section `%s'"),
2541 abfd
, hdr
->sh_type
, name
);
2544 /* Otherwise it should be processed. */
2545 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2550 /* FIXME: We should handle this section. */
2552 /* xgettext:c-format */
2553 (_("%pB: unknown type [%#x] section `%s'"),
2554 abfd
, hdr
->sh_type
, name
);
2562 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2563 sections_being_created
[shindex
] = FALSE
;
2564 if (-- nesting
== 0)
2566 sections_being_created
= NULL
;
2567 sections_being_created_abfd
= abfd
;
2572 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2575 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2577 unsigned long r_symndx
)
2579 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2581 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2583 Elf_Internal_Shdr
*symtab_hdr
;
2584 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2585 Elf_External_Sym_Shndx eshndx
;
2587 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2588 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2589 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2592 if (cache
->abfd
!= abfd
)
2594 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2597 cache
->indx
[ent
] = r_symndx
;
2600 return &cache
->sym
[ent
];
2603 /* Given an ELF section number, retrieve the corresponding BFD
2607 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2609 if (sec_index
>= elf_numsections (abfd
))
2611 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2614 static const struct bfd_elf_special_section special_sections_b
[] =
2616 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2617 { NULL
, 0, 0, 0, 0 }
2620 static const struct bfd_elf_special_section special_sections_c
[] =
2622 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2623 { NULL
, 0, 0, 0, 0 }
2626 static const struct bfd_elf_special_section special_sections_d
[] =
2628 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2629 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2630 /* There are more DWARF sections than these, but they needn't be added here
2631 unless you have to cope with broken compilers that don't emit section
2632 attributes or you want to help the user writing assembler. */
2633 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2634 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2635 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2636 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2637 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2638 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2639 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2640 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2641 { NULL
, 0, 0, 0, 0 }
2644 static const struct bfd_elf_special_section special_sections_f
[] =
2646 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2647 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2648 { NULL
, 0 , 0, 0, 0 }
2651 static const struct bfd_elf_special_section special_sections_g
[] =
2653 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2654 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2655 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2656 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2657 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2658 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2659 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2660 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2661 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2662 { NULL
, 0, 0, 0, 0 }
2665 static const struct bfd_elf_special_section special_sections_h
[] =
2667 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2668 { NULL
, 0, 0, 0, 0 }
2671 static const struct bfd_elf_special_section special_sections_i
[] =
2673 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2674 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2675 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2676 { NULL
, 0, 0, 0, 0 }
2679 static const struct bfd_elf_special_section special_sections_l
[] =
2681 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2682 { NULL
, 0, 0, 0, 0 }
2685 static const struct bfd_elf_special_section special_sections_n
[] =
2687 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2688 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2689 { NULL
, 0, 0, 0, 0 }
2692 static const struct bfd_elf_special_section special_sections_p
[] =
2694 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2695 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2696 { NULL
, 0, 0, 0, 0 }
2699 static const struct bfd_elf_special_section special_sections_r
[] =
2701 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2702 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2703 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2704 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2705 { NULL
, 0, 0, 0, 0 }
2708 static const struct bfd_elf_special_section special_sections_s
[] =
2710 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2711 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2712 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2713 /* See struct bfd_elf_special_section declaration for the semantics of
2714 this special case where .prefix_length != strlen (.prefix). */
2715 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2716 { NULL
, 0, 0, 0, 0 }
2719 static const struct bfd_elf_special_section special_sections_t
[] =
2721 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2722 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2723 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2724 { NULL
, 0, 0, 0, 0 }
2727 static const struct bfd_elf_special_section special_sections_z
[] =
2729 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2730 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2731 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2732 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2733 { NULL
, 0, 0, 0, 0 }
2736 static const struct bfd_elf_special_section
* const special_sections
[] =
2738 special_sections_b
, /* 'b' */
2739 special_sections_c
, /* 'c' */
2740 special_sections_d
, /* 'd' */
2742 special_sections_f
, /* 'f' */
2743 special_sections_g
, /* 'g' */
2744 special_sections_h
, /* 'h' */
2745 special_sections_i
, /* 'i' */
2748 special_sections_l
, /* 'l' */
2750 special_sections_n
, /* 'n' */
2752 special_sections_p
, /* 'p' */
2754 special_sections_r
, /* 'r' */
2755 special_sections_s
, /* 's' */
2756 special_sections_t
, /* 't' */
2762 special_sections_z
/* 'z' */
2765 const struct bfd_elf_special_section
*
2766 _bfd_elf_get_special_section (const char *name
,
2767 const struct bfd_elf_special_section
*spec
,
2773 len
= strlen (name
);
2775 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2778 int prefix_len
= spec
[i
].prefix_length
;
2780 if (len
< prefix_len
)
2782 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2785 suffix_len
= spec
[i
].suffix_length
;
2786 if (suffix_len
<= 0)
2788 if (name
[prefix_len
] != 0)
2790 if (suffix_len
== 0)
2792 if (name
[prefix_len
] != '.'
2793 && (suffix_len
== -2
2794 || (rela
&& spec
[i
].type
== SHT_REL
)))
2800 if (len
< prefix_len
+ suffix_len
)
2802 if (memcmp (name
+ len
- suffix_len
,
2803 spec
[i
].prefix
+ prefix_len
,
2813 const struct bfd_elf_special_section
*
2814 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2817 const struct bfd_elf_special_section
*spec
;
2818 const struct elf_backend_data
*bed
;
2820 /* See if this is one of the special sections. */
2821 if (sec
->name
== NULL
)
2824 bed
= get_elf_backend_data (abfd
);
2825 spec
= bed
->special_sections
;
2828 spec
= _bfd_elf_get_special_section (sec
->name
,
2829 bed
->special_sections
,
2835 if (sec
->name
[0] != '.')
2838 i
= sec
->name
[1] - 'b';
2839 if (i
< 0 || i
> 'z' - 'b')
2842 spec
= special_sections
[i
];
2847 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2851 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2853 struct bfd_elf_section_data
*sdata
;
2854 const struct elf_backend_data
*bed
;
2855 const struct bfd_elf_special_section
*ssect
;
2857 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2860 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2864 sec
->used_by_bfd
= sdata
;
2867 /* Indicate whether or not this section should use RELA relocations. */
2868 bed
= get_elf_backend_data (abfd
);
2869 sec
->use_rela_p
= bed
->default_use_rela_p
;
2871 /* When we read a file, we don't need to set ELF section type and
2872 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2873 anyway. We will set ELF section type and flags for all linker
2874 created sections. If user specifies BFD section flags, we will
2875 set ELF section type and flags based on BFD section flags in
2876 elf_fake_sections. Special handling for .init_array/.fini_array
2877 output sections since they may contain .ctors/.dtors input
2878 sections. We don't want _bfd_elf_init_private_section_data to
2879 copy ELF section type from .ctors/.dtors input sections. */
2880 if (abfd
->direction
!= read_direction
2881 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2883 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2886 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2887 || ssect
->type
== SHT_INIT_ARRAY
2888 || ssect
->type
== SHT_FINI_ARRAY
))
2890 elf_section_type (sec
) = ssect
->type
;
2891 elf_section_flags (sec
) = ssect
->attr
;
2895 return _bfd_generic_new_section_hook (abfd
, sec
);
2898 /* Create a new bfd section from an ELF program header.
2900 Since program segments have no names, we generate a synthetic name
2901 of the form segment<NUM>, where NUM is generally the index in the
2902 program header table. For segments that are split (see below) we
2903 generate the names segment<NUM>a and segment<NUM>b.
2905 Note that some program segments may have a file size that is different than
2906 (less than) the memory size. All this means is that at execution the
2907 system must allocate the amount of memory specified by the memory size,
2908 but only initialize it with the first "file size" bytes read from the
2909 file. This would occur for example, with program segments consisting
2910 of combined data+bss.
2912 To handle the above situation, this routine generates TWO bfd sections
2913 for the single program segment. The first has the length specified by
2914 the file size of the segment, and the second has the length specified
2915 by the difference between the two sizes. In effect, the segment is split
2916 into its initialized and uninitialized parts.
2921 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2922 Elf_Internal_Phdr
*hdr
,
2924 const char *type_name
)
2932 split
= ((hdr
->p_memsz
> 0)
2933 && (hdr
->p_filesz
> 0)
2934 && (hdr
->p_memsz
> hdr
->p_filesz
));
2936 if (hdr
->p_filesz
> 0)
2938 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2939 len
= strlen (namebuf
) + 1;
2940 name
= (char *) bfd_alloc (abfd
, len
);
2943 memcpy (name
, namebuf
, len
);
2944 newsect
= bfd_make_section (abfd
, name
);
2945 if (newsect
== NULL
)
2947 newsect
->vma
= hdr
->p_vaddr
;
2948 newsect
->lma
= hdr
->p_paddr
;
2949 newsect
->size
= hdr
->p_filesz
;
2950 newsect
->filepos
= hdr
->p_offset
;
2951 newsect
->flags
|= SEC_HAS_CONTENTS
;
2952 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2953 if (hdr
->p_type
== PT_LOAD
)
2955 newsect
->flags
|= SEC_ALLOC
;
2956 newsect
->flags
|= SEC_LOAD
;
2957 if (hdr
->p_flags
& PF_X
)
2959 /* FIXME: all we known is that it has execute PERMISSION,
2961 newsect
->flags
|= SEC_CODE
;
2964 if (!(hdr
->p_flags
& PF_W
))
2966 newsect
->flags
|= SEC_READONLY
;
2970 if (hdr
->p_memsz
> hdr
->p_filesz
)
2974 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2975 len
= strlen (namebuf
) + 1;
2976 name
= (char *) bfd_alloc (abfd
, len
);
2979 memcpy (name
, namebuf
, len
);
2980 newsect
= bfd_make_section (abfd
, name
);
2981 if (newsect
== NULL
)
2983 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2984 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2985 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2986 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2987 align
= newsect
->vma
& -newsect
->vma
;
2988 if (align
== 0 || align
> hdr
->p_align
)
2989 align
= hdr
->p_align
;
2990 newsect
->alignment_power
= bfd_log2 (align
);
2991 if (hdr
->p_type
== PT_LOAD
)
2993 /* Hack for gdb. Segments that have not been modified do
2994 not have their contents written to a core file, on the
2995 assumption that a debugger can find the contents in the
2996 executable. We flag this case by setting the fake
2997 section size to zero. Note that "real" bss sections will
2998 always have their contents dumped to the core file. */
2999 if (bfd_get_format (abfd
) == bfd_core
)
3001 newsect
->flags
|= SEC_ALLOC
;
3002 if (hdr
->p_flags
& PF_X
)
3003 newsect
->flags
|= SEC_CODE
;
3005 if (!(hdr
->p_flags
& PF_W
))
3006 newsect
->flags
|= SEC_READONLY
;
3013 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3015 const struct elf_backend_data
*bed
;
3017 switch (hdr
->p_type
)
3020 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3023 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
3026 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3029 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3032 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3034 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3040 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3043 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3045 case PT_GNU_EH_FRAME
:
3046 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3050 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3053 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3056 /* Check for any processor-specific program segment types. */
3057 bed
= get_elf_backend_data (abfd
);
3058 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3062 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3066 _bfd_elf_single_rel_hdr (asection
*sec
)
3068 if (elf_section_data (sec
)->rel
.hdr
)
3070 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3071 return elf_section_data (sec
)->rel
.hdr
;
3074 return elf_section_data (sec
)->rela
.hdr
;
3078 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3079 Elf_Internal_Shdr
*rel_hdr
,
3080 const char *sec_name
,
3081 bfd_boolean use_rela_p
)
3083 char *name
= (char *) bfd_alloc (abfd
,
3084 sizeof ".rela" + strlen (sec_name
));
3088 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3090 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3092 if (rel_hdr
->sh_name
== (unsigned int) -1)
3098 /* Allocate and initialize a section-header for a new reloc section,
3099 containing relocations against ASECT. It is stored in RELDATA. If
3100 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3104 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3105 struct bfd_elf_section_reloc_data
*reldata
,
3106 const char *sec_name
,
3107 bfd_boolean use_rela_p
,
3108 bfd_boolean delay_st_name_p
)
3110 Elf_Internal_Shdr
*rel_hdr
;
3111 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3113 BFD_ASSERT (reldata
->hdr
== NULL
);
3114 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3115 reldata
->hdr
= rel_hdr
;
3117 if (delay_st_name_p
)
3118 rel_hdr
->sh_name
= (unsigned int) -1;
3119 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3122 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3123 rel_hdr
->sh_entsize
= (use_rela_p
3124 ? bed
->s
->sizeof_rela
3125 : bed
->s
->sizeof_rel
);
3126 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3127 rel_hdr
->sh_flags
= 0;
3128 rel_hdr
->sh_addr
= 0;
3129 rel_hdr
->sh_size
= 0;
3130 rel_hdr
->sh_offset
= 0;
3135 /* Return the default section type based on the passed in section flags. */
3138 bfd_elf_get_default_section_type (flagword flags
)
3140 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3141 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3143 return SHT_PROGBITS
;
3146 struct fake_section_arg
3148 struct bfd_link_info
*link_info
;
3152 /* Set up an ELF internal section header for a section. */
3155 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3157 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3158 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3159 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3160 Elf_Internal_Shdr
*this_hdr
;
3161 unsigned int sh_type
;
3162 const char *name
= asect
->name
;
3163 bfd_boolean delay_st_name_p
= FALSE
;
3167 /* We already failed; just get out of the bfd_map_over_sections
3172 this_hdr
= &esd
->this_hdr
;
3176 /* ld: compress DWARF debug sections with names: .debug_*. */
3177 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3178 && (asect
->flags
& SEC_DEBUGGING
)
3182 /* Set SEC_ELF_COMPRESS to indicate this section should be
3184 asect
->flags
|= SEC_ELF_COMPRESS
;
3186 /* If this section will be compressed, delay adding section
3187 name to section name section after it is compressed in
3188 _bfd_elf_assign_file_positions_for_non_load. */
3189 delay_st_name_p
= TRUE
;
3192 else if ((asect
->flags
& SEC_ELF_RENAME
))
3194 /* objcopy: rename output DWARF debug section. */
3195 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3197 /* When we decompress or compress with SHF_COMPRESSED,
3198 convert section name from .zdebug_* to .debug_* if
3202 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3203 if (new_name
== NULL
)
3211 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3213 /* PR binutils/18087: Compression does not always make a
3214 section smaller. So only rename the section when
3215 compression has actually taken place. If input section
3216 name is .zdebug_*, we should never compress it again. */
3217 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3218 if (new_name
== NULL
)
3223 BFD_ASSERT (name
[1] != 'z');
3228 if (delay_st_name_p
)
3229 this_hdr
->sh_name
= (unsigned int) -1;
3233 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3235 if (this_hdr
->sh_name
== (unsigned int) -1)
3242 /* Don't clear sh_flags. Assembler may set additional bits. */
3244 if ((asect
->flags
& SEC_ALLOC
) != 0
3245 || asect
->user_set_vma
)
3246 this_hdr
->sh_addr
= asect
->vma
;
3248 this_hdr
->sh_addr
= 0;
3250 this_hdr
->sh_offset
= 0;
3251 this_hdr
->sh_size
= asect
->size
;
3252 this_hdr
->sh_link
= 0;
3253 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3254 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3257 /* xgettext:c-format */
3258 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3259 abfd
, asect
->alignment_power
, asect
);
3263 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
3264 /* The sh_entsize and sh_info fields may have been set already by
3265 copy_private_section_data. */
3267 this_hdr
->bfd_section
= asect
;
3268 this_hdr
->contents
= NULL
;
3270 /* If the section type is unspecified, we set it based on
3272 if ((asect
->flags
& SEC_GROUP
) != 0)
3273 sh_type
= SHT_GROUP
;
3275 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3277 if (this_hdr
->sh_type
== SHT_NULL
)
3278 this_hdr
->sh_type
= sh_type
;
3279 else if (this_hdr
->sh_type
== SHT_NOBITS
3280 && sh_type
== SHT_PROGBITS
3281 && (asect
->flags
& SEC_ALLOC
) != 0)
3283 /* Warn if we are changing a NOBITS section to PROGBITS, but
3284 allow the link to proceed. This can happen when users link
3285 non-bss input sections to bss output sections, or emit data
3286 to a bss output section via a linker script. */
3288 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3289 this_hdr
->sh_type
= sh_type
;
3292 switch (this_hdr
->sh_type
)
3303 case SHT_INIT_ARRAY
:
3304 case SHT_FINI_ARRAY
:
3305 case SHT_PREINIT_ARRAY
:
3306 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3310 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3314 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3318 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3322 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3323 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3327 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3328 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3331 case SHT_GNU_versym
:
3332 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3335 case SHT_GNU_verdef
:
3336 this_hdr
->sh_entsize
= 0;
3337 /* objcopy or strip will copy over sh_info, but may not set
3338 cverdefs. The linker will set cverdefs, but sh_info will be
3340 if (this_hdr
->sh_info
== 0)
3341 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3343 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3344 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3347 case SHT_GNU_verneed
:
3348 this_hdr
->sh_entsize
= 0;
3349 /* objcopy or strip will copy over sh_info, but may not set
3350 cverrefs. The linker will set cverrefs, but sh_info will be
3352 if (this_hdr
->sh_info
== 0)
3353 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3355 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3356 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3360 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3364 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3368 if ((asect
->flags
& SEC_ALLOC
) != 0)
3369 this_hdr
->sh_flags
|= SHF_ALLOC
;
3370 if ((asect
->flags
& SEC_READONLY
) == 0)
3371 this_hdr
->sh_flags
|= SHF_WRITE
;
3372 if ((asect
->flags
& SEC_CODE
) != 0)
3373 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3374 if ((asect
->flags
& SEC_MERGE
) != 0)
3376 this_hdr
->sh_flags
|= SHF_MERGE
;
3377 this_hdr
->sh_entsize
= asect
->entsize
;
3379 if ((asect
->flags
& SEC_STRINGS
) != 0)
3380 this_hdr
->sh_flags
|= SHF_STRINGS
;
3381 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3382 this_hdr
->sh_flags
|= SHF_GROUP
;
3383 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3385 this_hdr
->sh_flags
|= SHF_TLS
;
3386 if (asect
->size
== 0
3387 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3389 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3391 this_hdr
->sh_size
= 0;
3394 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3395 if (this_hdr
->sh_size
!= 0)
3396 this_hdr
->sh_type
= SHT_NOBITS
;
3400 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3401 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3403 /* If the section has relocs, set up a section header for the
3404 SHT_REL[A] section. If two relocation sections are required for
3405 this section, it is up to the processor-specific back-end to
3406 create the other. */
3407 if ((asect
->flags
& SEC_RELOC
) != 0)
3409 /* When doing a relocatable link, create both REL and RELA sections if
3412 /* Do the normal setup if we wouldn't create any sections here. */
3413 && esd
->rel
.count
+ esd
->rela
.count
> 0
3414 && (bfd_link_relocatable (arg
->link_info
)
3415 || arg
->link_info
->emitrelocations
))
3417 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3418 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3419 FALSE
, delay_st_name_p
))
3424 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3425 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3426 TRUE
, delay_st_name_p
))
3432 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3434 ? &esd
->rela
: &esd
->rel
),
3444 /* Check for processor-specific section types. */
3445 sh_type
= this_hdr
->sh_type
;
3446 if (bed
->elf_backend_fake_sections
3447 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3453 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3455 /* Don't change the header type from NOBITS if we are being
3456 called for objcopy --only-keep-debug. */
3457 this_hdr
->sh_type
= sh_type
;
3461 /* Fill in the contents of a SHT_GROUP section. Called from
3462 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3463 when ELF targets use the generic linker, ld. Called for ld -r
3464 from bfd_elf_final_link. */
3467 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3469 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3470 asection
*elt
, *first
;
3474 /* Ignore linker created group section. See elfNN_ia64_object_p in
3476 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
3480 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3482 unsigned long symindx
= 0;
3484 /* elf_group_id will have been set up by objcopy and the
3486 if (elf_group_id (sec
) != NULL
)
3487 symindx
= elf_group_id (sec
)->udata
.i
;
3491 /* If called from the assembler, swap_out_syms will have set up
3492 elf_section_syms. */
3493 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3494 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3496 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3498 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3500 /* The ELF backend linker sets sh_info to -2 when the group
3501 signature symbol is global, and thus the index can't be
3502 set until all local symbols are output. */
3504 struct bfd_elf_section_data
*sec_data
;
3505 unsigned long symndx
;
3506 unsigned long extsymoff
;
3507 struct elf_link_hash_entry
*h
;
3509 /* The point of this little dance to the first SHF_GROUP section
3510 then back to the SHT_GROUP section is that this gets us to
3511 the SHT_GROUP in the input object. */
3512 igroup
= elf_sec_group (elf_next_in_group (sec
));
3513 sec_data
= elf_section_data (igroup
);
3514 symndx
= sec_data
->this_hdr
.sh_info
;
3516 if (!elf_bad_symtab (igroup
->owner
))
3518 Elf_Internal_Shdr
*symtab_hdr
;
3520 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3521 extsymoff
= symtab_hdr
->sh_info
;
3523 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3524 while (h
->root
.type
== bfd_link_hash_indirect
3525 || h
->root
.type
== bfd_link_hash_warning
)
3526 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3528 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3531 /* The contents won't be allocated for "ld -r" or objcopy. */
3533 if (sec
->contents
== NULL
)
3536 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3538 /* Arrange for the section to be written out. */
3539 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3540 if (sec
->contents
== NULL
)
3547 loc
= sec
->contents
+ sec
->size
;
3549 /* Get the pointer to the first section in the group that gas
3550 squirreled away here. objcopy arranges for this to be set to the
3551 start of the input section group. */
3552 first
= elt
= elf_next_in_group (sec
);
3554 /* First element is a flag word. Rest of section is elf section
3555 indices for all the sections of the group. Write them backwards
3556 just to keep the group in the same order as given in .section
3557 directives, not that it matters. */
3564 s
= s
->output_section
;
3566 && !bfd_is_abs_section (s
))
3568 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3569 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3571 if (elf_sec
->rel
.hdr
!= NULL
3573 || (input_elf_sec
->rel
.hdr
!= NULL
3574 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3576 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3578 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3580 if (elf_sec
->rela
.hdr
!= NULL
3582 || (input_elf_sec
->rela
.hdr
!= NULL
3583 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3585 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3587 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3590 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3592 elt
= elf_next_in_group (elt
);
3598 BFD_ASSERT (loc
== sec
->contents
);
3600 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3603 /* Given NAME, the name of a relocation section stripped of its
3604 .rel/.rela prefix, return the section in ABFD to which the
3605 relocations apply. */
3608 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3610 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3611 section likely apply to .got.plt or .got section. */
3612 if (get_elf_backend_data (abfd
)->want_got_plt
3613 && strcmp (name
, ".plt") == 0)
3618 sec
= bfd_get_section_by_name (abfd
, name
);
3624 return bfd_get_section_by_name (abfd
, name
);
3627 /* Return the section to which RELOC_SEC applies. */
3630 elf_get_reloc_section (asection
*reloc_sec
)
3635 const struct elf_backend_data
*bed
;
3637 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3638 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3641 /* We look up the section the relocs apply to by name. */
3642 name
= reloc_sec
->name
;
3643 if (strncmp (name
, ".rel", 4) != 0)
3646 if (type
== SHT_RELA
&& *name
++ != 'a')
3649 abfd
= reloc_sec
->owner
;
3650 bed
= get_elf_backend_data (abfd
);
3651 return bed
->get_reloc_section (abfd
, name
);
3654 /* Assign all ELF section numbers. The dummy first section is handled here
3655 too. The link/info pointers for the standard section types are filled
3656 in here too, while we're at it. */
3659 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3661 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3663 unsigned int section_number
;
3664 Elf_Internal_Shdr
**i_shdrp
;
3665 struct bfd_elf_section_data
*d
;
3666 bfd_boolean need_symtab
;
3670 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3672 /* SHT_GROUP sections are in relocatable files only. */
3673 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3675 size_t reloc_count
= 0;
3677 /* Put SHT_GROUP sections first. */
3678 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3680 d
= elf_section_data (sec
);
3682 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3684 if (sec
->flags
& SEC_LINKER_CREATED
)
3686 /* Remove the linker created SHT_GROUP sections. */
3687 bfd_section_list_remove (abfd
, sec
);
3688 abfd
->section_count
--;
3691 d
->this_idx
= section_number
++;
3694 /* Count relocations. */
3695 reloc_count
+= sec
->reloc_count
;
3698 /* Clear HAS_RELOC if there are no relocations. */
3699 if (reloc_count
== 0)
3700 abfd
->flags
&= ~HAS_RELOC
;
3703 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3705 d
= elf_section_data (sec
);
3707 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3708 d
->this_idx
= section_number
++;
3709 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3710 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3713 d
->rel
.idx
= section_number
++;
3714 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3715 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3722 d
->rela
.idx
= section_number
++;
3723 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3724 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3730 need_symtab
= (bfd_get_symcount (abfd
) > 0
3731 || (link_info
== NULL
3732 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3736 elf_onesymtab (abfd
) = section_number
++;
3737 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3738 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3740 elf_section_list
* entry
;
3742 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3744 entry
= bfd_zalloc (abfd
, sizeof * entry
);
3745 entry
->ndx
= section_number
++;
3746 elf_symtab_shndx_list (abfd
) = entry
;
3748 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3749 ".symtab_shndx", FALSE
);
3750 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3753 elf_strtab_sec (abfd
) = section_number
++;
3754 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3757 elf_shstrtab_sec (abfd
) = section_number
++;
3758 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3759 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3761 if (section_number
>= SHN_LORESERVE
)
3763 /* xgettext:c-format */
3764 _bfd_error_handler (_("%pB: too many sections: %u"),
3765 abfd
, section_number
);
3769 elf_numsections (abfd
) = section_number
;
3770 elf_elfheader (abfd
)->e_shnum
= section_number
;
3772 /* Set up the list of section header pointers, in agreement with the
3774 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3775 sizeof (Elf_Internal_Shdr
*));
3776 if (i_shdrp
== NULL
)
3779 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3780 sizeof (Elf_Internal_Shdr
));
3781 if (i_shdrp
[0] == NULL
)
3783 bfd_release (abfd
, i_shdrp
);
3787 elf_elfsections (abfd
) = i_shdrp
;
3789 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3792 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3793 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3795 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3796 BFD_ASSERT (entry
!= NULL
);
3797 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3798 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3800 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3801 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3804 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3808 d
= elf_section_data (sec
);
3810 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3811 if (d
->rel
.idx
!= 0)
3812 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3813 if (d
->rela
.idx
!= 0)
3814 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3816 /* Fill in the sh_link and sh_info fields while we're at it. */
3818 /* sh_link of a reloc section is the section index of the symbol
3819 table. sh_info is the section index of the section to which
3820 the relocation entries apply. */
3821 if (d
->rel
.idx
!= 0)
3823 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3824 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3825 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3827 if (d
->rela
.idx
!= 0)
3829 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3830 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3831 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3834 /* We need to set up sh_link for SHF_LINK_ORDER. */
3835 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3837 s
= elf_linked_to_section (sec
);
3840 /* elf_linked_to_section points to the input section. */
3841 if (link_info
!= NULL
)
3843 /* Check discarded linkonce section. */
3844 if (discarded_section (s
))
3848 /* xgettext:c-format */
3849 (_("%pB: sh_link of section `%pA' points to"
3850 " discarded section `%pA' of `%pB'"),
3851 abfd
, d
->this_hdr
.bfd_section
,
3853 /* Point to the kept section if it has the same
3854 size as the discarded one. */
3855 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3858 bfd_set_error (bfd_error_bad_value
);
3864 s
= s
->output_section
;
3865 BFD_ASSERT (s
!= NULL
);
3869 /* Handle objcopy. */
3870 if (s
->output_section
== NULL
)
3873 /* xgettext:c-format */
3874 (_("%pB: sh_link of section `%pA' points to"
3875 " removed section `%pA' of `%pB'"),
3876 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3877 bfd_set_error (bfd_error_bad_value
);
3880 s
= s
->output_section
;
3882 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3887 The Intel C compiler generates SHT_IA_64_UNWIND with
3888 SHF_LINK_ORDER. But it doesn't set the sh_link or
3889 sh_info fields. Hence we could get the situation
3891 const struct elf_backend_data
*bed
3892 = get_elf_backend_data (abfd
);
3893 if (bed
->link_order_error_handler
)
3894 bed
->link_order_error_handler
3895 /* xgettext:c-format */
3896 (_("%pB: warning: sh_link not set for section `%pA'"),
3901 switch (d
->this_hdr
.sh_type
)
3905 /* A reloc section which we are treating as a normal BFD
3906 section. sh_link is the section index of the symbol
3907 table. sh_info is the section index of the section to
3908 which the relocation entries apply. We assume that an
3909 allocated reloc section uses the dynamic symbol table.
3910 FIXME: How can we be sure? */
3911 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3913 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3915 s
= elf_get_reloc_section (sec
);
3918 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3919 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3924 /* We assume that a section named .stab*str is a stabs
3925 string section. We look for a section with the same name
3926 but without the trailing ``str'', and set its sh_link
3927 field to point to this section. */
3928 if (CONST_STRNEQ (sec
->name
, ".stab")
3929 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3934 len
= strlen (sec
->name
);
3935 alc
= (char *) bfd_malloc (len
- 2);
3938 memcpy (alc
, sec
->name
, len
- 3);
3939 alc
[len
- 3] = '\0';
3940 s
= bfd_get_section_by_name (abfd
, alc
);
3944 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3946 /* This is a .stab section. */
3947 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3948 elf_section_data (s
)->this_hdr
.sh_entsize
3949 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3956 case SHT_GNU_verneed
:
3957 case SHT_GNU_verdef
:
3958 /* sh_link is the section header index of the string table
3959 used for the dynamic entries, or the symbol table, or the
3961 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3963 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3966 case SHT_GNU_LIBLIST
:
3967 /* sh_link is the section header index of the prelink library
3968 list used for the dynamic entries, or the symbol table, or
3969 the version strings. */
3970 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3971 ? ".dynstr" : ".gnu.libstr");
3973 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3978 case SHT_GNU_versym
:
3979 /* sh_link is the section header index of the symbol table
3980 this hash table or version table is for. */
3981 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3983 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3987 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3991 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3992 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3993 debug section name from .debug_* to .zdebug_* if needed. */
3999 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4001 /* If the backend has a special mapping, use it. */
4002 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4003 if (bed
->elf_backend_sym_is_global
)
4004 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4006 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4007 || bfd_is_und_section (bfd_get_section (sym
))
4008 || bfd_is_com_section (bfd_get_section (sym
)));
4011 /* Filter global symbols of ABFD to include in the import library. All
4012 SYMCOUNT symbols of ABFD can be examined from their pointers in
4013 SYMS. Pointers of symbols to keep should be stored contiguously at
4014 the beginning of that array.
4016 Returns the number of symbols to keep. */
4019 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4020 asymbol
**syms
, long symcount
)
4022 long src_count
, dst_count
= 0;
4024 for (src_count
= 0; src_count
< symcount
; src_count
++)
4026 asymbol
*sym
= syms
[src_count
];
4027 char *name
= (char *) bfd_asymbol_name (sym
);
4028 struct bfd_link_hash_entry
*h
;
4030 if (!sym_is_global (abfd
, sym
))
4033 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
4036 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4038 if (h
->linker_def
|| h
->ldscript_def
)
4041 syms
[dst_count
++] = sym
;
4044 syms
[dst_count
] = NULL
;
4049 /* Don't output section symbols for sections that are not going to be
4050 output, that are duplicates or there is no BFD section. */
4053 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4055 elf_symbol_type
*type_ptr
;
4060 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4063 if (sym
->section
== NULL
)
4066 type_ptr
= elf_symbol_from (abfd
, sym
);
4067 return ((type_ptr
!= NULL
4068 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4069 && bfd_is_abs_section (sym
->section
))
4070 || !(sym
->section
->owner
== abfd
4071 || (sym
->section
->output_section
!= NULL
4072 && sym
->section
->output_section
->owner
== abfd
4073 && sym
->section
->output_offset
== 0)
4074 || bfd_is_abs_section (sym
->section
)));
4077 /* Map symbol from it's internal number to the external number, moving
4078 all local symbols to be at the head of the list. */
4081 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4083 unsigned int symcount
= bfd_get_symcount (abfd
);
4084 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4085 asymbol
**sect_syms
;
4086 unsigned int num_locals
= 0;
4087 unsigned int num_globals
= 0;
4088 unsigned int num_locals2
= 0;
4089 unsigned int num_globals2
= 0;
4090 unsigned int max_index
= 0;
4096 fprintf (stderr
, "elf_map_symbols\n");
4100 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4102 if (max_index
< asect
->index
)
4103 max_index
= asect
->index
;
4107 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
4108 if (sect_syms
== NULL
)
4110 elf_section_syms (abfd
) = sect_syms
;
4111 elf_num_section_syms (abfd
) = max_index
;
4113 /* Init sect_syms entries for any section symbols we have already
4114 decided to output. */
4115 for (idx
= 0; idx
< symcount
; idx
++)
4117 asymbol
*sym
= syms
[idx
];
4119 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4121 && !ignore_section_sym (abfd
, sym
)
4122 && !bfd_is_abs_section (sym
->section
))
4124 asection
*sec
= sym
->section
;
4126 if (sec
->owner
!= abfd
)
4127 sec
= sec
->output_section
;
4129 sect_syms
[sec
->index
] = syms
[idx
];
4133 /* Classify all of the symbols. */
4134 for (idx
= 0; idx
< symcount
; idx
++)
4136 if (sym_is_global (abfd
, syms
[idx
]))
4138 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4142 /* We will be adding a section symbol for each normal BFD section. Most
4143 sections will already have a section symbol in outsymbols, but
4144 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4145 at least in that case. */
4146 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4148 if (sect_syms
[asect
->index
] == NULL
)
4150 if (!sym_is_global (abfd
, asect
->symbol
))
4157 /* Now sort the symbols so the local symbols are first. */
4158 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
4159 sizeof (asymbol
*));
4161 if (new_syms
== NULL
)
4164 for (idx
= 0; idx
< symcount
; idx
++)
4166 asymbol
*sym
= syms
[idx
];
4169 if (sym_is_global (abfd
, sym
))
4170 i
= num_locals
+ num_globals2
++;
4171 else if (!ignore_section_sym (abfd
, sym
))
4176 sym
->udata
.i
= i
+ 1;
4178 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4180 if (sect_syms
[asect
->index
] == NULL
)
4182 asymbol
*sym
= asect
->symbol
;
4185 sect_syms
[asect
->index
] = sym
;
4186 if (!sym_is_global (abfd
, sym
))
4189 i
= num_locals
+ num_globals2
++;
4191 sym
->udata
.i
= i
+ 1;
4195 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4197 *pnum_locals
= num_locals
;
4201 /* Align to the maximum file alignment that could be required for any
4202 ELF data structure. */
4204 static inline file_ptr
4205 align_file_position (file_ptr off
, int align
)
4207 return (off
+ align
- 1) & ~(align
- 1);
4210 /* Assign a file position to a section, optionally aligning to the
4211 required section alignment. */
4214 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4218 if (align
&& i_shdrp
->sh_addralign
> 1)
4219 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4220 i_shdrp
->sh_offset
= offset
;
4221 if (i_shdrp
->bfd_section
!= NULL
)
4222 i_shdrp
->bfd_section
->filepos
= offset
;
4223 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4224 offset
+= i_shdrp
->sh_size
;
4228 /* Compute the file positions we are going to put the sections at, and
4229 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4230 is not NULL, this is being called by the ELF backend linker. */
4233 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4234 struct bfd_link_info
*link_info
)
4236 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4237 struct fake_section_arg fsargs
;
4239 struct elf_strtab_hash
*strtab
= NULL
;
4240 Elf_Internal_Shdr
*shstrtab_hdr
;
4241 bfd_boolean need_symtab
;
4243 if (abfd
->output_has_begun
)
4246 /* Do any elf backend specific processing first. */
4247 if (bed
->elf_backend_begin_write_processing
)
4248 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4250 if (! prep_headers (abfd
))
4253 /* Post process the headers if necessary. */
4254 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
4256 fsargs
.failed
= FALSE
;
4257 fsargs
.link_info
= link_info
;
4258 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4262 if (!assign_section_numbers (abfd
, link_info
))
4265 /* The backend linker builds symbol table information itself. */
4266 need_symtab
= (link_info
== NULL
4267 && (bfd_get_symcount (abfd
) > 0
4268 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4272 /* Non-zero if doing a relocatable link. */
4273 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4275 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
4280 if (link_info
== NULL
)
4282 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4287 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4288 /* sh_name was set in prep_headers. */
4289 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4290 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4291 shstrtab_hdr
->sh_addr
= 0;
4292 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4293 shstrtab_hdr
->sh_entsize
= 0;
4294 shstrtab_hdr
->sh_link
= 0;
4295 shstrtab_hdr
->sh_info
= 0;
4296 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4297 shstrtab_hdr
->sh_addralign
= 1;
4299 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4305 Elf_Internal_Shdr
*hdr
;
4307 off
= elf_next_file_pos (abfd
);
4309 hdr
= & elf_symtab_hdr (abfd
);
4310 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4312 if (elf_symtab_shndx_list (abfd
) != NULL
)
4314 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4315 if (hdr
->sh_size
!= 0)
4316 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4317 /* FIXME: What about other symtab_shndx sections in the list ? */
4320 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4321 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4323 elf_next_file_pos (abfd
) = off
;
4325 /* Now that we know where the .strtab section goes, write it
4327 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4328 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4330 _bfd_elf_strtab_free (strtab
);
4333 abfd
->output_has_begun
= TRUE
;
4338 /* Make an initial estimate of the size of the program header. If we
4339 get the number wrong here, we'll redo section placement. */
4341 static bfd_size_type
4342 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4346 const struct elf_backend_data
*bed
;
4348 /* Assume we will need exactly two PT_LOAD segments: one for text
4349 and one for data. */
4352 s
= bfd_get_section_by_name (abfd
, ".interp");
4353 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4355 /* If we have a loadable interpreter section, we need a
4356 PT_INTERP segment. In this case, assume we also need a
4357 PT_PHDR segment, although that may not be true for all
4362 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4364 /* We need a PT_DYNAMIC segment. */
4368 if (info
!= NULL
&& info
->relro
)
4370 /* We need a PT_GNU_RELRO segment. */
4374 if (elf_eh_frame_hdr (abfd
))
4376 /* We need a PT_GNU_EH_FRAME segment. */
4380 if (elf_stack_flags (abfd
))
4382 /* We need a PT_GNU_STACK segment. */
4386 s
= bfd_get_section_by_name (abfd
,
4387 NOTE_GNU_PROPERTY_SECTION_NAME
);
4388 if (s
!= NULL
&& s
->size
!= 0)
4390 /* We need a PT_GNU_PROPERTY segment. */
4394 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4396 if ((s
->flags
& SEC_LOAD
) != 0
4397 && elf_section_type (s
) == SHT_NOTE
)
4399 unsigned int alignment_power
;
4400 /* We need a PT_NOTE segment. */
4402 /* Try to create just one PT_NOTE segment for all adjacent
4403 loadable SHT_NOTE sections. gABI requires that within a
4404 PT_NOTE segment (and also inside of each SHT_NOTE section)
4405 each note should have the same alignment. So we check
4406 whether the sections are correctly aligned. */
4407 alignment_power
= s
->alignment_power
;
4408 while (s
->next
!= NULL
4409 && s
->next
->alignment_power
== alignment_power
4410 && (s
->next
->flags
& SEC_LOAD
) != 0
4411 && elf_section_type (s
->next
) == SHT_NOTE
)
4416 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4418 if (s
->flags
& SEC_THREAD_LOCAL
)
4420 /* We need a PT_TLS segment. */
4426 bed
= get_elf_backend_data (abfd
);
4428 if ((abfd
->flags
& D_PAGED
) != 0)
4430 /* Add a PT_GNU_MBIND segment for each mbind section. */
4431 unsigned int page_align_power
= bfd_log2 (bed
->commonpagesize
);
4432 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4433 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4435 if (elf_section_data (s
)->this_hdr
.sh_info
4439 /* xgettext:c-format */
4440 (_("%pB: GNU_MBIN section `%pA' has invalid sh_info field: %d"),
4441 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4444 /* Align mbind section to page size. */
4445 if (s
->alignment_power
< page_align_power
)
4446 s
->alignment_power
= page_align_power
;
4451 /* Let the backend count up any program headers it might need. */
4452 if (bed
->elf_backend_additional_program_headers
)
4456 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4462 return segs
* bed
->s
->sizeof_phdr
;
4465 /* Find the segment that contains the output_section of section. */
4468 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4470 struct elf_segment_map
*m
;
4471 Elf_Internal_Phdr
*p
;
4473 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4479 for (i
= m
->count
- 1; i
>= 0; i
--)
4480 if (m
->sections
[i
] == section
)
4487 /* Create a mapping from a set of sections to a program segment. */
4489 static struct elf_segment_map
*
4490 make_mapping (bfd
*abfd
,
4491 asection
**sections
,
4496 struct elf_segment_map
*m
;
4501 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4502 amt
+= (to
- from
) * sizeof (asection
*);
4503 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4507 m
->p_type
= PT_LOAD
;
4508 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4509 m
->sections
[i
- from
] = *hdrpp
;
4510 m
->count
= to
- from
;
4512 if (from
== 0 && phdr
)
4514 /* Include the headers in the first PT_LOAD segment. */
4515 m
->includes_filehdr
= 1;
4516 m
->includes_phdrs
= 1;
4522 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4525 struct elf_segment_map
*
4526 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4528 struct elf_segment_map
*m
;
4530 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4531 sizeof (struct elf_segment_map
));
4535 m
->p_type
= PT_DYNAMIC
;
4537 m
->sections
[0] = dynsec
;
4542 /* Possibly add or remove segments from the segment map. */
4545 elf_modify_segment_map (bfd
*abfd
,
4546 struct bfd_link_info
*info
,
4547 bfd_boolean remove_empty_load
)
4549 struct elf_segment_map
**m
;
4550 const struct elf_backend_data
*bed
;
4552 /* The placement algorithm assumes that non allocated sections are
4553 not in PT_LOAD segments. We ensure this here by removing such
4554 sections from the segment map. We also remove excluded
4555 sections. Finally, any PT_LOAD segment without sections is
4557 m
= &elf_seg_map (abfd
);
4560 unsigned int i
, new_count
;
4562 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4564 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4565 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4566 || (*m
)->p_type
!= PT_LOAD
))
4568 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4572 (*m
)->count
= new_count
;
4574 if (remove_empty_load
4575 && (*m
)->p_type
== PT_LOAD
4577 && !(*m
)->includes_phdrs
)
4583 bed
= get_elf_backend_data (abfd
);
4584 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4586 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4593 #define IS_TBSS(s) \
4594 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4596 /* Set up a mapping from BFD sections to program segments. */
4599 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4602 struct elf_segment_map
*m
;
4603 asection
**sections
= NULL
;
4604 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4605 bfd_boolean no_user_phdrs
;
4607 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4610 info
->user_phdrs
= !no_user_phdrs
;
4612 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4616 struct elf_segment_map
*mfirst
;
4617 struct elf_segment_map
**pm
;
4620 unsigned int hdr_index
;
4621 bfd_vma maxpagesize
;
4623 bfd_boolean phdr_in_segment
;
4624 bfd_boolean writable
;
4625 bfd_boolean executable
;
4627 asection
*first_tls
= NULL
;
4628 asection
*first_mbind
= NULL
;
4629 asection
*dynsec
, *eh_frame_hdr
;
4631 bfd_vma addr_mask
, wrap_to
= 0;
4632 bfd_size_type phdr_size
;
4634 /* Select the allocated sections, and sort them. */
4636 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4637 sizeof (asection
*));
4638 if (sections
== NULL
)
4641 /* Calculate top address, avoiding undefined behaviour of shift
4642 left operator when shift count is equal to size of type
4644 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4645 addr_mask
= (addr_mask
<< 1) + 1;
4648 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4650 if ((s
->flags
& SEC_ALLOC
) != 0)
4654 /* A wrapping section potentially clashes with header. */
4655 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4656 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4659 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4662 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4664 phdr_size
= elf_program_header_size (abfd
);
4665 if (phdr_size
== (bfd_size_type
) -1)
4666 phdr_size
= get_program_header_size (abfd
, info
);
4667 phdr_size
+= bed
->s
->sizeof_ehdr
;
4668 maxpagesize
= bed
->maxpagesize
;
4669 if (maxpagesize
== 0)
4671 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4673 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4674 >= (phdr_size
& (maxpagesize
- 1))))
4675 /* For compatibility with old scripts that may not be using
4676 SIZEOF_HEADERS, add headers when it looks like space has
4677 been left for them. */
4678 phdr_in_segment
= TRUE
;
4680 /* Build the mapping. */
4684 /* If we have a .interp section, then create a PT_PHDR segment for
4685 the program headers and a PT_INTERP segment for the .interp
4687 s
= bfd_get_section_by_name (abfd
, ".interp");
4688 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4690 amt
= sizeof (struct elf_segment_map
);
4691 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4695 m
->p_type
= PT_PHDR
;
4697 m
->p_flags_valid
= 1;
4698 m
->includes_phdrs
= 1;
4699 phdr_in_segment
= TRUE
;
4703 amt
= sizeof (struct elf_segment_map
);
4704 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4708 m
->p_type
= PT_INTERP
;
4716 /* Look through the sections. We put sections in the same program
4717 segment when the start of the second section can be placed within
4718 a few bytes of the end of the first section. */
4724 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4726 && (dynsec
->flags
& SEC_LOAD
) == 0)
4729 if ((abfd
->flags
& D_PAGED
) == 0)
4730 phdr_in_segment
= FALSE
;
4732 /* Deal with -Ttext or something similar such that the first section
4733 is not adjacent to the program headers. This is an
4734 approximation, since at this point we don't know exactly how many
4735 program headers we will need. */
4736 if (phdr_in_segment
&& count
> 0)
4739 bfd_boolean separate_phdr
= FALSE
;
4741 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4743 && info
->separate_code
4744 && (sections
[0]->flags
& SEC_CODE
) != 0)
4746 /* If data sections should be separate from code and
4747 thus not executable, and the first section is
4748 executable then put the file and program headers in
4749 their own PT_LOAD. */
4750 separate_phdr
= TRUE
;
4751 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4752 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4754 /* The file and program headers are currently on the
4755 same page as the first section. Put them on the
4756 previous page if we can. */
4757 if (phdr_lma
>= maxpagesize
)
4758 phdr_lma
-= maxpagesize
;
4760 separate_phdr
= FALSE
;
4763 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4764 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4765 /* If file and program headers would be placed at the end
4766 of memory then it's probably better to omit them. */
4767 phdr_in_segment
= FALSE
;
4768 else if (phdr_lma
< wrap_to
)
4769 /* If a section wraps around to where we'll be placing
4770 file and program headers, then the headers will be
4772 phdr_in_segment
= FALSE
;
4773 else if (separate_phdr
)
4775 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4778 m
->p_paddr
= phdr_lma
;
4780 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4781 m
->p_paddr_valid
= 1;
4784 phdr_in_segment
= FALSE
;
4788 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4791 bfd_boolean new_segment
;
4795 /* See if this section and the last one will fit in the same
4798 if (last_hdr
== NULL
)
4800 /* If we don't have a segment yet, then we don't need a new
4801 one (we build the last one after this loop). */
4802 new_segment
= FALSE
;
4804 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4806 /* If this section has a different relation between the
4807 virtual address and the load address, then we need a new
4811 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4812 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4814 /* If this section has a load address that makes it overlap
4815 the previous section, then we need a new segment. */
4818 else if ((abfd
->flags
& D_PAGED
) != 0
4819 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4820 == (hdr
->lma
& -maxpagesize
)))
4822 /* If we are demand paged then we can't map two disk
4823 pages onto the same memory page. */
4824 new_segment
= FALSE
;
4826 /* In the next test we have to be careful when last_hdr->lma is close
4827 to the end of the address space. If the aligned address wraps
4828 around to the start of the address space, then there are no more
4829 pages left in memory and it is OK to assume that the current
4830 section can be included in the current segment. */
4831 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4832 + maxpagesize
> last_hdr
->lma
)
4833 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4834 + maxpagesize
<= hdr
->lma
))
4836 /* If putting this section in this segment would force us to
4837 skip a page in the segment, then we need a new segment. */
4840 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4841 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4843 /* We don't want to put a loaded section after a
4844 nonloaded (ie. bss style) section in the same segment
4845 as that will force the non-loaded section to be loaded.
4846 Consider .tbss sections as loaded for this purpose. */
4849 else if ((abfd
->flags
& D_PAGED
) == 0)
4851 /* If the file is not demand paged, which means that we
4852 don't require the sections to be correctly aligned in the
4853 file, then there is no other reason for a new segment. */
4854 new_segment
= FALSE
;
4856 else if (info
!= NULL
4857 && info
->separate_code
4858 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4863 && (hdr
->flags
& SEC_READONLY
) == 0)
4865 /* We don't want to put a writable section in a read only
4871 /* Otherwise, we can use the same segment. */
4872 new_segment
= FALSE
;
4875 /* Allow interested parties a chance to override our decision. */
4876 if (last_hdr
!= NULL
4878 && info
->callbacks
->override_segment_assignment
!= NULL
)
4880 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4886 if ((hdr
->flags
& SEC_READONLY
) == 0)
4888 if ((hdr
->flags
& SEC_CODE
) != 0)
4891 /* .tbss sections effectively have zero size. */
4892 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4896 /* We need a new program segment. We must create a new program
4897 header holding all the sections from hdr_index until hdr. */
4899 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4906 if ((hdr
->flags
& SEC_READONLY
) == 0)
4911 if ((hdr
->flags
& SEC_CODE
) == 0)
4917 /* .tbss sections effectively have zero size. */
4918 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4920 phdr_in_segment
= FALSE
;
4923 /* Create a final PT_LOAD program segment, but not if it's just
4925 if (last_hdr
!= NULL
4926 && (i
- hdr_index
!= 1
4927 || !IS_TBSS (last_hdr
)))
4929 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4937 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4940 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4947 /* For each batch of consecutive loadable SHT_NOTE sections,
4948 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4949 because if we link together nonloadable .note sections and
4950 loadable .note sections, we will generate two .note sections
4951 in the output file. */
4952 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4954 if ((s
->flags
& SEC_LOAD
) != 0
4955 && elf_section_type (s
) == SHT_NOTE
)
4958 unsigned int alignment_power
= s
->alignment_power
;
4961 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4963 if (s2
->next
->alignment_power
== alignment_power
4964 && (s2
->next
->flags
& SEC_LOAD
) != 0
4965 && elf_section_type (s2
->next
) == SHT_NOTE
4966 && align_power (s2
->lma
+ s2
->size
,
4973 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4974 amt
+= count
* sizeof (asection
*);
4975 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4979 m
->p_type
= PT_NOTE
;
4983 m
->sections
[m
->count
- count
--] = s
;
4984 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4987 m
->sections
[m
->count
- 1] = s
;
4988 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4992 if (s
->flags
& SEC_THREAD_LOCAL
)
4998 if (first_mbind
== NULL
4999 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5003 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5006 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5007 amt
+= tls_count
* sizeof (asection
*);
5008 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5013 m
->count
= tls_count
;
5014 /* Mandated PF_R. */
5016 m
->p_flags_valid
= 1;
5018 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
5020 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5023 (_("%pB: TLS sections are not adjacent:"), abfd
);
5026 while (i
< (unsigned int) tls_count
)
5028 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5030 _bfd_error_handler (_(" TLS: %pA"), s
);
5034 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5037 bfd_set_error (bfd_error_bad_value
);
5048 if (first_mbind
&& (abfd
->flags
& D_PAGED
) != 0)
5049 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5050 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5051 && (elf_section_data (s
)->this_hdr
.sh_info
5052 <= PT_GNU_MBIND_NUM
))
5054 /* Mandated PF_R. */
5055 unsigned long p_flags
= PF_R
;
5056 if ((s
->flags
& SEC_READONLY
) == 0)
5058 if ((s
->flags
& SEC_CODE
) != 0)
5061 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5062 m
= bfd_zalloc (abfd
, amt
);
5066 m
->p_type
= (PT_GNU_MBIND_LO
5067 + elf_section_data (s
)->this_hdr
.sh_info
);
5069 m
->p_flags_valid
= 1;
5071 m
->p_flags
= p_flags
;
5077 s
= bfd_get_section_by_name (abfd
,
5078 NOTE_GNU_PROPERTY_SECTION_NAME
);
5079 if (s
!= NULL
&& s
->size
!= 0)
5081 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5082 m
= bfd_zalloc (abfd
, amt
);
5086 m
->p_type
= PT_GNU_PROPERTY
;
5088 m
->p_flags_valid
= 1;
5095 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5097 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5098 if (eh_frame_hdr
!= NULL
5099 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5101 amt
= sizeof (struct elf_segment_map
);
5102 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5106 m
->p_type
= PT_GNU_EH_FRAME
;
5108 m
->sections
[0] = eh_frame_hdr
->output_section
;
5114 if (elf_stack_flags (abfd
))
5116 amt
= sizeof (struct elf_segment_map
);
5117 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5121 m
->p_type
= PT_GNU_STACK
;
5122 m
->p_flags
= elf_stack_flags (abfd
);
5123 m
->p_align
= bed
->stack_align
;
5124 m
->p_flags_valid
= 1;
5125 m
->p_align_valid
= m
->p_align
!= 0;
5126 if (info
->stacksize
> 0)
5128 m
->p_size
= info
->stacksize
;
5129 m
->p_size_valid
= 1;
5136 if (info
!= NULL
&& info
->relro
)
5138 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5140 if (m
->p_type
== PT_LOAD
5142 && m
->sections
[0]->vma
>= info
->relro_start
5143 && m
->sections
[0]->vma
< info
->relro_end
)
5146 while (--i
!= (unsigned) -1)
5147 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5148 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5151 if (i
!= (unsigned) -1)
5156 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5159 amt
= sizeof (struct elf_segment_map
);
5160 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5164 m
->p_type
= PT_GNU_RELRO
;
5171 elf_seg_map (abfd
) = mfirst
;
5174 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5177 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5179 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5184 if (sections
!= NULL
)
5189 /* Sort sections by address. */
5192 elf_sort_sections (const void *arg1
, const void *arg2
)
5194 const asection
*sec1
= *(const asection
**) arg1
;
5195 const asection
*sec2
= *(const asection
**) arg2
;
5196 bfd_size_type size1
, size2
;
5198 /* Sort by LMA first, since this is the address used to
5199 place the section into a segment. */
5200 if (sec1
->lma
< sec2
->lma
)
5202 else if (sec1
->lma
> sec2
->lma
)
5205 /* Then sort by VMA. Normally the LMA and the VMA will be
5206 the same, and this will do nothing. */
5207 if (sec1
->vma
< sec2
->vma
)
5209 else if (sec1
->vma
> sec2
->vma
)
5212 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5214 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5220 /* If the indices are the same, do not return 0
5221 here, but continue to try the next comparison. */
5222 if (sec1
->target_index
- sec2
->target_index
!= 0)
5223 return sec1
->target_index
- sec2
->target_index
;
5228 else if (TOEND (sec2
))
5233 /* Sort by size, to put zero sized sections
5234 before others at the same address. */
5236 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5237 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5244 return sec1
->target_index
- sec2
->target_index
;
5247 /* Ian Lance Taylor writes:
5249 We shouldn't be using % with a negative signed number. That's just
5250 not good. We have to make sure either that the number is not
5251 negative, or that the number has an unsigned type. When the types
5252 are all the same size they wind up as unsigned. When file_ptr is a
5253 larger signed type, the arithmetic winds up as signed long long,
5256 What we're trying to say here is something like ``increase OFF by
5257 the least amount that will cause it to be equal to the VMA modulo
5259 /* In other words, something like:
5261 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5262 off_offset = off % bed->maxpagesize;
5263 if (vma_offset < off_offset)
5264 adjustment = vma_offset + bed->maxpagesize - off_offset;
5266 adjustment = vma_offset - off_offset;
5268 which can be collapsed into the expression below. */
5271 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5273 /* PR binutils/16199: Handle an alignment of zero. */
5274 if (maxpagesize
== 0)
5276 return ((vma
- off
) % maxpagesize
);
5280 print_segment_map (const struct elf_segment_map
*m
)
5283 const char *pt
= get_segment_type (m
->p_type
);
5288 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5289 sprintf (buf
, "LOPROC+%7.7x",
5290 (unsigned int) (m
->p_type
- PT_LOPROC
));
5291 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5292 sprintf (buf
, "LOOS+%7.7x",
5293 (unsigned int) (m
->p_type
- PT_LOOS
));
5295 snprintf (buf
, sizeof (buf
), "%8.8x",
5296 (unsigned int) m
->p_type
);
5300 fprintf (stderr
, "%s:", pt
);
5301 for (j
= 0; j
< m
->count
; j
++)
5302 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5308 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5313 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5315 buf
= bfd_zmalloc (len
);
5318 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5323 /* Assign file positions to the sections based on the mapping from
5324 sections to segments. This function also sets up some fields in
5328 assign_file_positions_for_load_sections (bfd
*abfd
,
5329 struct bfd_link_info
*link_info
)
5331 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5332 struct elf_segment_map
*m
;
5333 Elf_Internal_Phdr
*phdrs
;
5334 Elf_Internal_Phdr
*p
;
5336 bfd_size_type maxpagesize
;
5337 unsigned int pt_load_count
= 0;
5340 bfd_vma header_pad
= 0;
5342 if (link_info
== NULL
5343 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5347 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5351 header_pad
= m
->header_size
;
5356 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5357 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5361 /* PR binutils/12467. */
5362 elf_elfheader (abfd
)->e_phoff
= 0;
5363 elf_elfheader (abfd
)->e_phentsize
= 0;
5366 elf_elfheader (abfd
)->e_phnum
= alloc
;
5368 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5369 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5371 BFD_ASSERT (elf_program_header_size (abfd
)
5372 >= alloc
* bed
->s
->sizeof_phdr
);
5376 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5380 /* We're writing the size in elf_program_header_size (abfd),
5381 see assign_file_positions_except_relocs, so make sure we have
5382 that amount allocated, with trailing space cleared.
5383 The variable alloc contains the computed need, while
5384 elf_program_header_size (abfd) contains the size used for the
5386 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5387 where the layout is forced to according to a larger size in the
5388 last iterations for the testcase ld-elf/header. */
5389 BFD_ASSERT (elf_program_header_size (abfd
) % bed
->s
->sizeof_phdr
5391 phdrs
= (Elf_Internal_Phdr
*)
5393 (elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
),
5394 sizeof (Elf_Internal_Phdr
));
5395 elf_tdata (abfd
)->phdr
= phdrs
;
5400 if ((abfd
->flags
& D_PAGED
) != 0)
5401 maxpagesize
= bed
->maxpagesize
;
5403 off
= bed
->s
->sizeof_ehdr
;
5404 off
+= alloc
* bed
->s
->sizeof_phdr
;
5405 if (header_pad
< (bfd_vma
) off
)
5411 for (m
= elf_seg_map (abfd
), p
= phdrs
, j
= 0;
5413 m
= m
->next
, p
++, j
++)
5417 bfd_boolean no_contents
;
5419 /* If elf_segment_map is not from map_sections_to_segments, the
5420 sections may not be correctly ordered. NOTE: sorting should
5421 not be done to the PT_NOTE section of a corefile, which may
5422 contain several pseudo-sections artificially created by bfd.
5423 Sorting these pseudo-sections breaks things badly. */
5425 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5426 && m
->p_type
== PT_NOTE
))
5427 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5430 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5431 number of sections with contents contributing to both p_filesz
5432 and p_memsz, followed by a number of sections with no contents
5433 that just contribute to p_memsz. In this loop, OFF tracks next
5434 available file offset for PT_LOAD and PT_NOTE segments. */
5435 p
->p_type
= m
->p_type
;
5436 p
->p_flags
= m
->p_flags
;
5439 p
->p_vaddr
= m
->p_vaddr_offset
;
5441 p
->p_vaddr
= m
->sections
[0]->vma
+ m
->p_vaddr_offset
;
5443 if (m
->p_paddr_valid
)
5444 p
->p_paddr
= m
->p_paddr
;
5445 else if (m
->count
== 0)
5448 p
->p_paddr
= m
->sections
[0]->lma
+ m
->p_vaddr_offset
;
5450 if (p
->p_type
== PT_LOAD
5451 && (abfd
->flags
& D_PAGED
) != 0)
5453 /* p_align in demand paged PT_LOAD segments effectively stores
5454 the maximum page size. When copying an executable with
5455 objcopy, we set m->p_align from the input file. Use this
5456 value for maxpagesize rather than bed->maxpagesize, which
5457 may be different. Note that we use maxpagesize for PT_TLS
5458 segment alignment later in this function, so we are relying
5459 on at least one PT_LOAD segment appearing before a PT_TLS
5461 if (m
->p_align_valid
)
5462 maxpagesize
= m
->p_align
;
5464 p
->p_align
= maxpagesize
;
5467 else if (m
->p_align_valid
)
5468 p
->p_align
= m
->p_align
;
5469 else if (m
->count
== 0)
5470 p
->p_align
= 1 << bed
->s
->log_file_align
;
5474 no_contents
= FALSE
;
5476 if (p
->p_type
== PT_LOAD
5479 bfd_size_type align
;
5480 unsigned int align_power
= 0;
5482 if (m
->p_align_valid
)
5486 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5488 unsigned int secalign
;
5490 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
5491 if (secalign
> align_power
)
5492 align_power
= secalign
;
5494 align
= (bfd_size_type
) 1 << align_power
;
5495 if (align
< maxpagesize
)
5496 align
= maxpagesize
;
5499 for (i
= 0; i
< m
->count
; i
++)
5500 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5501 /* If we aren't making room for this section, then
5502 it must be SHT_NOBITS regardless of what we've
5503 set via struct bfd_elf_special_section. */
5504 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5506 /* Find out whether this segment contains any loadable
5509 for (i
= 0; i
< m
->count
; i
++)
5510 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5512 no_contents
= FALSE
;
5516 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5518 /* Broken hardware and/or kernel require that files do not
5519 map the same page with different permissions on some hppa
5521 if (pt_load_count
> 1
5522 && bed
->no_page_alias
5523 && (off
& (maxpagesize
- 1)) != 0
5524 && (off
& -maxpagesize
) == ((off
+ off_adjust
) & -maxpagesize
))
5525 off_adjust
+= maxpagesize
;
5529 /* We shouldn't need to align the segment on disk since
5530 the segment doesn't need file space, but the gABI
5531 arguably requires the alignment and glibc ld.so
5532 checks it. So to comply with the alignment
5533 requirement but not waste file space, we adjust
5534 p_offset for just this segment. (OFF_ADJUST is
5535 subtracted from OFF later.) This may put p_offset
5536 past the end of file, but that shouldn't matter. */
5541 /* Make sure the .dynamic section is the first section in the
5542 PT_DYNAMIC segment. */
5543 else if (p
->p_type
== PT_DYNAMIC
5545 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5548 (_("%pB: The first section in the PT_DYNAMIC segment"
5549 " is not the .dynamic section"),
5551 bfd_set_error (bfd_error_bad_value
);
5554 /* Set the note section type to SHT_NOTE. */
5555 else if (p
->p_type
== PT_NOTE
)
5556 for (i
= 0; i
< m
->count
; i
++)
5557 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5563 if (m
->includes_filehdr
)
5565 if (!m
->p_flags_valid
)
5567 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5568 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5571 if (p
->p_vaddr
< (bfd_vma
) off
5572 || (!m
->p_paddr_valid
5573 && p
->p_paddr
< (bfd_vma
) off
))
5576 (_("%pB: not enough room for program headers,"
5577 " try linking with -N"),
5579 bfd_set_error (bfd_error_bad_value
);
5584 if (!m
->p_paddr_valid
)
5589 if (m
->includes_phdrs
)
5591 if (!m
->p_flags_valid
)
5594 if (!m
->includes_filehdr
)
5596 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5600 p
->p_vaddr
-= off
- p
->p_offset
;
5601 if (!m
->p_paddr_valid
)
5602 p
->p_paddr
-= off
- p
->p_offset
;
5606 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
5607 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
5610 p
->p_filesz
+= header_pad
;
5611 p
->p_memsz
+= header_pad
;
5615 if (p
->p_type
== PT_LOAD
5616 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5618 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5624 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5626 p
->p_filesz
+= adjust
;
5627 p
->p_memsz
+= adjust
;
5631 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5632 maps. Set filepos for sections in PT_LOAD segments, and in
5633 core files, for sections in PT_NOTE segments.
5634 assign_file_positions_for_non_load_sections will set filepos
5635 for other sections and update p_filesz for other segments. */
5636 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5639 bfd_size_type align
;
5640 Elf_Internal_Shdr
*this_hdr
;
5643 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5644 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
5646 if ((p
->p_type
== PT_LOAD
5647 || p
->p_type
== PT_TLS
)
5648 && (this_hdr
->sh_type
!= SHT_NOBITS
5649 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5650 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5651 || p
->p_type
== PT_TLS
))))
5653 bfd_vma p_start
= p
->p_paddr
;
5654 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5655 bfd_vma s_start
= sec
->lma
;
5656 bfd_vma adjust
= s_start
- p_end
;
5660 || p_end
< p_start
))
5663 /* xgettext:c-format */
5664 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5665 abfd
, sec
, (uint64_t) s_start
, (uint64_t) p_end
);
5669 p
->p_memsz
+= adjust
;
5671 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5673 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5675 /* We have a PROGBITS section following NOBITS ones.
5676 Allocate file space for the NOBITS section(s) and
5678 adjust
= p
->p_memsz
- p
->p_filesz
;
5679 if (!write_zeros (abfd
, off
, adjust
))
5683 p
->p_filesz
+= adjust
;
5687 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5689 /* The section at i == 0 is the one that actually contains
5693 this_hdr
->sh_offset
= sec
->filepos
= off
;
5694 off
+= this_hdr
->sh_size
;
5695 p
->p_filesz
= this_hdr
->sh_size
;
5701 /* The rest are fake sections that shouldn't be written. */
5710 if (p
->p_type
== PT_LOAD
)
5712 this_hdr
->sh_offset
= sec
->filepos
= off
;
5713 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5714 off
+= this_hdr
->sh_size
;
5716 else if (this_hdr
->sh_type
== SHT_NOBITS
5717 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5718 && this_hdr
->sh_offset
== 0)
5720 /* This is a .tbss section that didn't get a PT_LOAD.
5721 (See _bfd_elf_map_sections_to_segments "Create a
5722 final PT_LOAD".) Set sh_offset to the value it
5723 would have if we had created a zero p_filesz and
5724 p_memsz PT_LOAD header for the section. This
5725 also makes the PT_TLS header have the same
5727 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5729 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5732 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5734 p
->p_filesz
+= this_hdr
->sh_size
;
5735 /* A load section without SHF_ALLOC is something like
5736 a note section in a PT_NOTE segment. These take
5737 file space but are not loaded into memory. */
5738 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5739 p
->p_memsz
+= this_hdr
->sh_size
;
5741 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5743 if (p
->p_type
== PT_TLS
)
5744 p
->p_memsz
+= this_hdr
->sh_size
;
5746 /* .tbss is special. It doesn't contribute to p_memsz of
5748 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5749 p
->p_memsz
+= this_hdr
->sh_size
;
5752 if (align
> p
->p_align
5753 && !m
->p_align_valid
5754 && (p
->p_type
!= PT_LOAD
5755 || (abfd
->flags
& D_PAGED
) == 0))
5759 if (!m
->p_flags_valid
)
5762 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5764 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5771 /* Check that all sections are in a PT_LOAD segment.
5772 Don't check funky gdb generated core files. */
5773 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5775 bfd_boolean check_vma
= TRUE
;
5777 for (i
= 1; i
< m
->count
; i
++)
5778 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5779 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5780 ->this_hdr
), p
) != 0
5781 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5782 ->this_hdr
), p
) != 0)
5784 /* Looks like we have overlays packed into the segment. */
5789 for (i
= 0; i
< m
->count
; i
++)
5791 Elf_Internal_Shdr
*this_hdr
;
5794 sec
= m
->sections
[i
];
5795 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5796 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5797 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5800 /* xgettext:c-format */
5801 (_("%pB: section `%pA' can't be allocated in segment %d"),
5803 print_segment_map (m
);
5809 elf_next_file_pos (abfd
) = off
;
5813 /* Assign file positions for the other sections. */
5816 assign_file_positions_for_non_load_sections (bfd
*abfd
,
5817 struct bfd_link_info
*link_info
)
5819 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5820 Elf_Internal_Shdr
**i_shdrpp
;
5821 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
5822 Elf_Internal_Phdr
*phdrs
;
5823 Elf_Internal_Phdr
*p
;
5824 struct elf_segment_map
*m
;
5825 struct elf_segment_map
*hdrs_segment
;
5826 bfd_vma filehdr_vaddr
, filehdr_paddr
;
5827 bfd_vma phdrs_vaddr
, phdrs_paddr
;
5831 i_shdrpp
= elf_elfsections (abfd
);
5832 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
5833 off
= elf_next_file_pos (abfd
);
5834 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
5836 Elf_Internal_Shdr
*hdr
;
5839 if (hdr
->bfd_section
!= NULL
5840 && (hdr
->bfd_section
->filepos
!= 0
5841 || (hdr
->sh_type
== SHT_NOBITS
5842 && hdr
->contents
== NULL
)))
5843 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
5844 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
5846 if (hdr
->sh_size
!= 0)
5848 /* xgettext:c-format */
5849 (_("%pB: warning: allocated section `%s' not in segment"),
5851 (hdr
->bfd_section
== NULL
5853 : hdr
->bfd_section
->name
));
5854 /* We don't need to page align empty sections. */
5855 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
5856 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5859 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5861 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
5864 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5865 && hdr
->bfd_section
== NULL
)
5866 || (hdr
->bfd_section
!= NULL
5867 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
5868 /* Compress DWARF debug sections. */
5869 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
5870 || (elf_symtab_shndx_list (abfd
) != NULL
5871 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
5872 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
5873 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
5874 hdr
->sh_offset
= -1;
5876 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5879 /* Now that we have set the section file positions, we can set up
5880 the file positions for the non PT_LOAD segments. */
5884 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
5886 hdrs_segment
= NULL
;
5887 phdrs
= elf_tdata (abfd
)->phdr
;
5888 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5891 if (p
->p_type
!= PT_LOAD
)
5894 if (m
->includes_filehdr
)
5896 filehdr_vaddr
= p
->p_vaddr
;
5897 filehdr_paddr
= p
->p_paddr
;
5899 if (m
->includes_phdrs
)
5901 phdrs_vaddr
= p
->p_vaddr
;
5902 phdrs_paddr
= p
->p_paddr
;
5903 if (m
->includes_filehdr
)
5906 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
5907 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
5912 if (hdrs_segment
!= NULL
&& link_info
!= NULL
)
5914 /* There is a segment that contains both the file headers and the
5915 program headers, so provide a symbol __ehdr_start pointing there.
5916 A program can use this to examine itself robustly. */
5918 struct elf_link_hash_entry
*hash
5919 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5920 FALSE
, FALSE
, TRUE
);
5921 /* If the symbol was referenced and not defined, define it. */
5923 && (hash
->root
.type
== bfd_link_hash_new
5924 || hash
->root
.type
== bfd_link_hash_undefined
5925 || hash
->root
.type
== bfd_link_hash_undefweak
5926 || hash
->root
.type
== bfd_link_hash_common
))
5929 if (hdrs_segment
->count
!= 0)
5930 /* The segment contains sections, so use the first one. */
5931 s
= hdrs_segment
->sections
[0];
5933 /* Use the first (i.e. lowest-addressed) section in any segment. */
5934 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5943 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
5944 hash
->root
.u
.def
.section
= s
;
5948 hash
->root
.u
.def
.value
= filehdr_vaddr
;
5949 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
5952 hash
->root
.type
= bfd_link_hash_defined
;
5953 hash
->def_regular
= 1;
5958 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5960 if (p
->p_type
== PT_GNU_RELRO
)
5965 if (link_info
!= NULL
)
5967 /* During linking the range of the RELRO segment is passed
5968 in link_info. Note that there may be padding between
5969 relro_start and the first RELRO section. */
5970 start
= link_info
->relro_start
;
5971 end
= link_info
->relro_end
;
5973 else if (m
->count
!= 0)
5975 if (!m
->p_size_valid
)
5977 start
= m
->sections
[0]->vma
;
5978 end
= start
+ m
->p_size
;
5989 struct elf_segment_map
*lm
;
5990 const Elf_Internal_Phdr
*lp
;
5993 /* Find a LOAD segment containing a section in the RELRO
5995 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
5997 lm
= lm
->next
, lp
++)
5999 if (lp
->p_type
== PT_LOAD
6001 && (lm
->sections
[lm
->count
- 1]->vma
6002 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6003 ? lm
->sections
[lm
->count
- 1]->size
6005 && lm
->sections
[0]->vma
< end
)
6011 /* Find the section starting the RELRO segment. */
6012 for (i
= 0; i
< lm
->count
; i
++)
6014 asection
*s
= lm
->sections
[i
];
6023 p
->p_vaddr
= lm
->sections
[i
]->vma
;
6024 p
->p_paddr
= lm
->sections
[i
]->lma
;
6025 p
->p_offset
= lm
->sections
[i
]->filepos
;
6026 p
->p_memsz
= end
- p
->p_vaddr
;
6027 p
->p_filesz
= p
->p_memsz
;
6029 /* The RELRO segment typically ends a few bytes
6030 into .got.plt but other layouts are possible.
6031 In cases where the end does not match any
6032 loaded section (for instance is in file
6033 padding), trim p_filesz back to correspond to
6034 the end of loaded section contents. */
6035 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6036 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6038 /* Preserve the alignment and flags if they are
6039 valid. The gold linker generates RW/4 for
6040 the PT_GNU_RELRO section. It is better for
6041 objcopy/strip to honor these attributes
6042 otherwise gdb will choke when using separate
6044 if (!m
->p_align_valid
)
6046 if (!m
->p_flags_valid
)
6052 if (link_info
!= NULL
)
6055 memset (p
, 0, sizeof *p
);
6057 else if (p
->p_type
== PT_GNU_STACK
)
6059 if (m
->p_size_valid
)
6060 p
->p_memsz
= m
->p_size
;
6062 else if (m
->count
!= 0)
6066 if (p
->p_type
!= PT_LOAD
6067 && (p
->p_type
!= PT_NOTE
6068 || bfd_get_format (abfd
) != bfd_core
))
6070 /* A user specified segment layout may include a PHDR
6071 segment that overlaps with a LOAD segment... */
6072 if (p
->p_type
== PT_PHDR
)
6078 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6080 /* PR 17512: file: 2195325e. */
6082 (_("%pB: error: non-load segment %d includes file header "
6083 "and/or program header"),
6084 abfd
, (int) (p
- phdrs
));
6089 p
->p_offset
= m
->sections
[0]->filepos
;
6090 for (i
= m
->count
; i
-- != 0;)
6092 asection
*sect
= m
->sections
[i
];
6093 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6094 if (hdr
->sh_type
!= SHT_NOBITS
)
6096 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6103 else if (m
->includes_filehdr
)
6105 p
->p_vaddr
= filehdr_vaddr
;
6106 if (! m
->p_paddr_valid
)
6107 p
->p_paddr
= filehdr_paddr
;
6109 else if (m
->includes_phdrs
)
6111 p
->p_vaddr
= phdrs_vaddr
;
6112 if (! m
->p_paddr_valid
)
6113 p
->p_paddr
= phdrs_paddr
;
6117 elf_next_file_pos (abfd
) = off
;
6122 static elf_section_list
*
6123 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6125 for (;list
!= NULL
; list
= list
->next
)
6131 /* Work out the file positions of all the sections. This is called by
6132 _bfd_elf_compute_section_file_positions. All the section sizes and
6133 VMAs must be known before this is called.
6135 Reloc sections come in two flavours: Those processed specially as
6136 "side-channel" data attached to a section to which they apply, and
6137 those that bfd doesn't process as relocations. The latter sort are
6138 stored in a normal bfd section by bfd_section_from_shdr. We don't
6139 consider the former sort here, unless they form part of the loadable
6140 image. Reloc sections not assigned here will be handled later by
6141 assign_file_positions_for_relocs.
6143 We also don't set the positions of the .symtab and .strtab here. */
6146 assign_file_positions_except_relocs (bfd
*abfd
,
6147 struct bfd_link_info
*link_info
)
6149 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6150 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6151 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6153 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6154 && bfd_get_format (abfd
) != bfd_core
)
6156 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6157 unsigned int num_sec
= elf_numsections (abfd
);
6158 Elf_Internal_Shdr
**hdrpp
;
6162 /* Start after the ELF header. */
6163 off
= i_ehdrp
->e_ehsize
;
6165 /* We are not creating an executable, which means that we are
6166 not creating a program header, and that the actual order of
6167 the sections in the file is unimportant. */
6168 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6170 Elf_Internal_Shdr
*hdr
;
6173 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6174 && hdr
->bfd_section
== NULL
)
6175 || (hdr
->bfd_section
!= NULL
6176 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
6177 /* Compress DWARF debug sections. */
6178 || i
== elf_onesymtab (abfd
)
6179 || (elf_symtab_shndx_list (abfd
) != NULL
6180 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6181 || i
== elf_strtab_sec (abfd
)
6182 || i
== elf_shstrtab_sec (abfd
))
6184 hdr
->sh_offset
= -1;
6187 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6190 elf_next_file_pos (abfd
) = off
;
6196 /* Assign file positions for the loaded sections based on the
6197 assignment of sections to segments. */
6198 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6201 /* And for non-load sections. */
6202 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6205 if (bed
->elf_backend_modify_program_headers
!= NULL
)
6207 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
6211 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
6212 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6214 unsigned int num_segments
= elf_elfheader (abfd
)->e_phnum
;
6215 Elf_Internal_Phdr
*segment
= elf_tdata (abfd
)->phdr
;
6216 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6218 /* Find the lowest p_vaddr in PT_LOAD segments. */
6219 bfd_vma p_vaddr
= (bfd_vma
) -1;
6220 for (; segment
< end_segment
; segment
++)
6221 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6222 p_vaddr
= segment
->p_vaddr
;
6224 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6225 segments is non-zero. */
6227 i_ehdrp
->e_type
= ET_EXEC
;
6230 /* Write out the program headers. */
6231 alloc
= elf_elfheader (abfd
)->e_phnum
;
6235 /* PR ld/20815 - Check that the program header segment, if present, will
6236 be loaded into memory. FIXME: The check below is not sufficient as
6237 really all PT_LOAD segments should be checked before issuing an error
6238 message. Plus the PHDR segment does not have to be the first segment
6239 in the program header table. But this version of the check should
6240 catch all real world use cases.
6242 FIXME: We used to have code here to sort the PT_LOAD segments into
6243 ascending order, as per the ELF spec. But this breaks some programs,
6244 including the Linux kernel. But really either the spec should be
6245 changed or the programs updated. */
6247 && tdata
->phdr
[0].p_type
== PT_PHDR
6248 && (bed
->elf_backend_allow_non_load_phdr
== NULL
6249 || !bed
->elf_backend_allow_non_load_phdr (abfd
, tdata
->phdr
,
6251 && tdata
->phdr
[1].p_type
== PT_LOAD
6252 && (tdata
->phdr
[1].p_vaddr
> tdata
->phdr
[0].p_vaddr
6253 || (tdata
->phdr
[1].p_vaddr
+ tdata
->phdr
[1].p_memsz
6254 < tdata
->phdr
[0].p_vaddr
+ tdata
->phdr
[0].p_memsz
)))
6256 /* The fix for this error is usually to edit the linker script being
6257 used and set up the program headers manually. Either that or
6258 leave room for the headers at the start of the SECTIONS. */
6259 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
6260 " by LOAD segment"),
6265 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
6266 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6274 prep_headers (bfd
*abfd
)
6276 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6277 struct elf_strtab_hash
*shstrtab
;
6278 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6280 i_ehdrp
= elf_elfheader (abfd
);
6282 shstrtab
= _bfd_elf_strtab_init ();
6283 if (shstrtab
== NULL
)
6286 elf_shstrtab (abfd
) = shstrtab
;
6288 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6289 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6290 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6291 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6293 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6294 i_ehdrp
->e_ident
[EI_DATA
] =
6295 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6296 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6298 if ((abfd
->flags
& DYNAMIC
) != 0)
6299 i_ehdrp
->e_type
= ET_DYN
;
6300 else if ((abfd
->flags
& EXEC_P
) != 0)
6301 i_ehdrp
->e_type
= ET_EXEC
;
6302 else if (bfd_get_format (abfd
) == bfd_core
)
6303 i_ehdrp
->e_type
= ET_CORE
;
6305 i_ehdrp
->e_type
= ET_REL
;
6307 switch (bfd_get_arch (abfd
))
6309 case bfd_arch_unknown
:
6310 i_ehdrp
->e_machine
= EM_NONE
;
6313 /* There used to be a long list of cases here, each one setting
6314 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6315 in the corresponding bfd definition. To avoid duplication,
6316 the switch was removed. Machines that need special handling
6317 can generally do it in elf_backend_final_write_processing(),
6318 unless they need the information earlier than the final write.
6319 Such need can generally be supplied by replacing the tests for
6320 e_machine with the conditions used to determine it. */
6322 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6325 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6326 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6328 /* No program header, for now. */
6329 i_ehdrp
->e_phoff
= 0;
6330 i_ehdrp
->e_phentsize
= 0;
6331 i_ehdrp
->e_phnum
= 0;
6333 /* Each bfd section is section header entry. */
6334 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6335 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6337 /* If we're building an executable, we'll need a program header table. */
6338 if (abfd
->flags
& EXEC_P
)
6339 /* It all happens later. */
6343 i_ehdrp
->e_phentsize
= 0;
6344 i_ehdrp
->e_phoff
= 0;
6347 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6348 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6349 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6350 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6351 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6352 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6353 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6354 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6355 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6361 /* Assign file positions for all the reloc sections which are not part
6362 of the loadable file image, and the file position of section headers. */
6365 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6368 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6369 Elf_Internal_Shdr
*shdrp
;
6370 Elf_Internal_Ehdr
*i_ehdrp
;
6371 const struct elf_backend_data
*bed
;
6373 off
= elf_next_file_pos (abfd
);
6375 shdrpp
= elf_elfsections (abfd
);
6376 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6377 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6380 if (shdrp
->sh_offset
== -1)
6382 asection
*sec
= shdrp
->bfd_section
;
6383 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6384 || shdrp
->sh_type
== SHT_RELA
);
6386 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6390 const char *name
= sec
->name
;
6391 struct bfd_elf_section_data
*d
;
6393 /* Compress DWARF debug sections. */
6394 if (!bfd_compress_section (abfd
, sec
,
6398 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6399 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6401 /* If section is compressed with zlib-gnu, convert
6402 section name from .debug_* to .zdebug_*. */
6404 = convert_debug_to_zdebug (abfd
, name
);
6405 if (new_name
== NULL
)
6409 /* Add section name to section name section. */
6410 if (shdrp
->sh_name
!= (unsigned int) -1)
6413 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6415 d
= elf_section_data (sec
);
6417 /* Add reloc section name to section name section. */
6419 && !_bfd_elf_set_reloc_sh_name (abfd
,
6424 && !_bfd_elf_set_reloc_sh_name (abfd
,
6429 /* Update section size and contents. */
6430 shdrp
->sh_size
= sec
->size
;
6431 shdrp
->contents
= sec
->contents
;
6432 shdrp
->bfd_section
->contents
= NULL
;
6434 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6441 /* Place section name section after DWARF debug sections have been
6443 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6444 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6445 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6446 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6448 /* Place the section headers. */
6449 i_ehdrp
= elf_elfheader (abfd
);
6450 bed
= get_elf_backend_data (abfd
);
6451 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6452 i_ehdrp
->e_shoff
= off
;
6453 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6454 elf_next_file_pos (abfd
) = off
;
6460 _bfd_elf_write_object_contents (bfd
*abfd
)
6462 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6463 Elf_Internal_Shdr
**i_shdrp
;
6465 unsigned int count
, num_sec
;
6466 struct elf_obj_tdata
*t
;
6468 if (! abfd
->output_has_begun
6469 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6471 /* Do not rewrite ELF data when the BFD has been opened for update.
6472 abfd->output_has_begun was set to TRUE on opening, so creation of new
6473 sections, and modification of existing section sizes was restricted.
6474 This means the ELF header, program headers and section headers can't have
6476 If the contents of any sections has been modified, then those changes have
6477 already been written to the BFD. */
6478 else if (abfd
->direction
== both_direction
)
6480 BFD_ASSERT (abfd
->output_has_begun
);
6484 i_shdrp
= elf_elfsections (abfd
);
6487 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6491 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6494 /* After writing the headers, we need to write the sections too... */
6495 num_sec
= elf_numsections (abfd
);
6496 for (count
= 1; count
< num_sec
; count
++)
6498 i_shdrp
[count
]->sh_name
6499 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6500 i_shdrp
[count
]->sh_name
);
6501 if (bed
->elf_backend_section_processing
)
6502 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6504 if (i_shdrp
[count
]->contents
)
6506 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6508 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6509 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6514 /* Write out the section header names. */
6515 t
= elf_tdata (abfd
);
6516 if (elf_shstrtab (abfd
) != NULL
6517 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6518 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6521 if (bed
->elf_backend_final_write_processing
)
6522 (*bed
->elf_backend_final_write_processing
) (abfd
, elf_linker (abfd
));
6524 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6527 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6528 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6529 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6535 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6537 /* Hopefully this can be done just like an object file. */
6538 return _bfd_elf_write_object_contents (abfd
);
6541 /* Given a section, search the header to find them. */
6544 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6546 const struct elf_backend_data
*bed
;
6547 unsigned int sec_index
;
6549 if (elf_section_data (asect
) != NULL
6550 && elf_section_data (asect
)->this_idx
!= 0)
6551 return elf_section_data (asect
)->this_idx
;
6553 if (bfd_is_abs_section (asect
))
6554 sec_index
= SHN_ABS
;
6555 else if (bfd_is_com_section (asect
))
6556 sec_index
= SHN_COMMON
;
6557 else if (bfd_is_und_section (asect
))
6558 sec_index
= SHN_UNDEF
;
6560 sec_index
= SHN_BAD
;
6562 bed
= get_elf_backend_data (abfd
);
6563 if (bed
->elf_backend_section_from_bfd_section
)
6565 int retval
= sec_index
;
6567 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6571 if (sec_index
== SHN_BAD
)
6572 bfd_set_error (bfd_error_nonrepresentable_section
);
6577 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6581 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6583 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6585 flagword flags
= asym_ptr
->flags
;
6587 /* When gas creates relocations against local labels, it creates its
6588 own symbol for the section, but does put the symbol into the
6589 symbol chain, so udata is 0. When the linker is generating
6590 relocatable output, this section symbol may be for one of the
6591 input sections rather than the output section. */
6592 if (asym_ptr
->udata
.i
== 0
6593 && (flags
& BSF_SECTION_SYM
)
6594 && asym_ptr
->section
)
6599 sec
= asym_ptr
->section
;
6600 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6601 sec
= sec
->output_section
;
6602 if (sec
->owner
== abfd
6603 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6604 && elf_section_syms (abfd
)[indx
] != NULL
)
6605 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6608 idx
= asym_ptr
->udata
.i
;
6612 /* This case can occur when using --strip-symbol on a symbol
6613 which is used in a relocation entry. */
6615 /* xgettext:c-format */
6616 (_("%pB: symbol `%s' required but not present"),
6617 abfd
, bfd_asymbol_name (asym_ptr
));
6618 bfd_set_error (bfd_error_no_symbols
);
6625 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6626 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6634 /* Rewrite program header information. */
6637 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6639 Elf_Internal_Ehdr
*iehdr
;
6640 struct elf_segment_map
*map
;
6641 struct elf_segment_map
*map_first
;
6642 struct elf_segment_map
**pointer_to_map
;
6643 Elf_Internal_Phdr
*segment
;
6646 unsigned int num_segments
;
6647 bfd_boolean phdr_included
= FALSE
;
6648 bfd_boolean p_paddr_valid
;
6649 bfd_vma maxpagesize
;
6650 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6651 unsigned int phdr_adjust_num
= 0;
6652 const struct elf_backend_data
*bed
;
6654 bed
= get_elf_backend_data (ibfd
);
6655 iehdr
= elf_elfheader (ibfd
);
6658 pointer_to_map
= &map_first
;
6660 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6661 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6663 /* Returns the end address of the segment + 1. */
6664 #define SEGMENT_END(segment, start) \
6665 (start + (segment->p_memsz > segment->p_filesz \
6666 ? segment->p_memsz : segment->p_filesz))
6668 #define SECTION_SIZE(section, segment) \
6669 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6670 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6671 ? section->size : 0)
6673 /* Returns TRUE if the given section is contained within
6674 the given segment. VMA addresses are compared. */
6675 #define IS_CONTAINED_BY_VMA(section, segment) \
6676 (section->vma >= segment->p_vaddr \
6677 && (section->vma + SECTION_SIZE (section, segment) \
6678 <= (SEGMENT_END (segment, segment->p_vaddr))))
6680 /* Returns TRUE if the given section is contained within
6681 the given segment. LMA addresses are compared. */
6682 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6683 (section->lma >= base \
6684 && (section->lma + SECTION_SIZE (section, segment) >= section->lma) \
6685 && (section->lma + SECTION_SIZE (section, segment) \
6686 <= SEGMENT_END (segment, base)))
6688 /* Handle PT_NOTE segment. */
6689 #define IS_NOTE(p, s) \
6690 (p->p_type == PT_NOTE \
6691 && elf_section_type (s) == SHT_NOTE \
6692 && (bfd_vma) s->filepos >= p->p_offset \
6693 && ((bfd_vma) s->filepos + s->size \
6694 <= p->p_offset + p->p_filesz))
6696 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6698 #define IS_COREFILE_NOTE(p, s) \
6700 && bfd_get_format (ibfd) == bfd_core \
6704 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6705 linker, which generates a PT_INTERP section with p_vaddr and
6706 p_memsz set to 0. */
6707 #define IS_SOLARIS_PT_INTERP(p, s) \
6709 && p->p_paddr == 0 \
6710 && p->p_memsz == 0 \
6711 && p->p_filesz > 0 \
6712 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6714 && (bfd_vma) s->filepos >= p->p_offset \
6715 && ((bfd_vma) s->filepos + s->size \
6716 <= p->p_offset + p->p_filesz))
6718 /* Decide if the given section should be included in the given segment.
6719 A section will be included if:
6720 1. It is within the address space of the segment -- we use the LMA
6721 if that is set for the segment and the VMA otherwise,
6722 2. It is an allocated section or a NOTE section in a PT_NOTE
6724 3. There is an output section associated with it,
6725 4. The section has not already been allocated to a previous segment.
6726 5. PT_GNU_STACK segments do not include any sections.
6727 6. PT_TLS segment includes only SHF_TLS sections.
6728 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6729 8. PT_DYNAMIC should not contain empty sections at the beginning
6730 (with the possible exception of .dynamic). */
6731 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6732 ((((segment->p_paddr \
6733 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6734 : IS_CONTAINED_BY_VMA (section, segment)) \
6735 && (section->flags & SEC_ALLOC) != 0) \
6736 || IS_NOTE (segment, section)) \
6737 && segment->p_type != PT_GNU_STACK \
6738 && (segment->p_type != PT_TLS \
6739 || (section->flags & SEC_THREAD_LOCAL)) \
6740 && (segment->p_type == PT_LOAD \
6741 || segment->p_type == PT_TLS \
6742 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6743 && (segment->p_type != PT_DYNAMIC \
6744 || SECTION_SIZE (section, segment) > 0 \
6745 || (segment->p_paddr \
6746 ? segment->p_paddr != section->lma \
6747 : segment->p_vaddr != section->vma) \
6748 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6750 && (segment->p_type != PT_LOAD || !section->segment_mark))
6752 /* If the output section of a section in the input segment is NULL,
6753 it is removed from the corresponding output segment. */
6754 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6755 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6756 && section->output_section != NULL)
6758 /* Returns TRUE iff seg1 starts after the end of seg2. */
6759 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6760 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6762 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6763 their VMA address ranges and their LMA address ranges overlap.
6764 It is possible to have overlapping VMA ranges without overlapping LMA
6765 ranges. RedBoot images for example can have both .data and .bss mapped
6766 to the same VMA range, but with the .data section mapped to a different
6768 #define SEGMENT_OVERLAPS(seg1, seg2) \
6769 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6770 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6771 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6772 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6774 /* Initialise the segment mark field. */
6775 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6776 section
->segment_mark
= FALSE
;
6778 /* The Solaris linker creates program headers in which all the
6779 p_paddr fields are zero. When we try to objcopy or strip such a
6780 file, we get confused. Check for this case, and if we find it
6781 don't set the p_paddr_valid fields. */
6782 p_paddr_valid
= FALSE
;
6783 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6786 if (segment
->p_paddr
!= 0)
6788 p_paddr_valid
= TRUE
;
6792 /* Scan through the segments specified in the program header
6793 of the input BFD. For this first scan we look for overlaps
6794 in the loadable segments. These can be created by weird
6795 parameters to objcopy. Also, fix some solaris weirdness. */
6796 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6801 Elf_Internal_Phdr
*segment2
;
6803 if (segment
->p_type
== PT_INTERP
)
6804 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6805 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6807 /* Mininal change so that the normal section to segment
6808 assignment code will work. */
6809 segment
->p_vaddr
= section
->vma
;
6813 if (segment
->p_type
!= PT_LOAD
)
6815 /* Remove PT_GNU_RELRO segment. */
6816 if (segment
->p_type
== PT_GNU_RELRO
)
6817 segment
->p_type
= PT_NULL
;
6821 /* Determine if this segment overlaps any previous segments. */
6822 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6824 bfd_signed_vma extra_length
;
6826 if (segment2
->p_type
!= PT_LOAD
6827 || !SEGMENT_OVERLAPS (segment
, segment2
))
6830 /* Merge the two segments together. */
6831 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6833 /* Extend SEGMENT2 to include SEGMENT and then delete
6835 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6836 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6838 if (extra_length
> 0)
6840 segment2
->p_memsz
+= extra_length
;
6841 segment2
->p_filesz
+= extra_length
;
6844 segment
->p_type
= PT_NULL
;
6846 /* Since we have deleted P we must restart the outer loop. */
6848 segment
= elf_tdata (ibfd
)->phdr
;
6853 /* Extend SEGMENT to include SEGMENT2 and then delete
6855 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
6856 - SEGMENT_END (segment
, segment
->p_vaddr
));
6858 if (extra_length
> 0)
6860 segment
->p_memsz
+= extra_length
;
6861 segment
->p_filesz
+= extra_length
;
6864 segment2
->p_type
= PT_NULL
;
6869 /* The second scan attempts to assign sections to segments. */
6870 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6874 unsigned int section_count
;
6875 asection
**sections
;
6876 asection
*output_section
;
6878 asection
*matching_lma
;
6879 asection
*suggested_lma
;
6882 asection
*first_section
;
6884 if (segment
->p_type
== PT_NULL
)
6887 first_section
= NULL
;
6888 /* Compute how many sections might be placed into this segment. */
6889 for (section
= ibfd
->sections
, section_count
= 0;
6891 section
= section
->next
)
6893 /* Find the first section in the input segment, which may be
6894 removed from the corresponding output segment. */
6895 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
6897 if (first_section
== NULL
)
6898 first_section
= section
;
6899 if (section
->output_section
!= NULL
)
6904 /* Allocate a segment map big enough to contain
6905 all of the sections we have selected. */
6906 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
6907 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
6908 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6912 /* Initialise the fields of the segment map. Default to
6913 using the physical address of the segment in the input BFD. */
6915 map
->p_type
= segment
->p_type
;
6916 map
->p_flags
= segment
->p_flags
;
6917 map
->p_flags_valid
= 1;
6919 /* If the first section in the input segment is removed, there is
6920 no need to preserve segment physical address in the corresponding
6922 if (!first_section
|| first_section
->output_section
!= NULL
)
6924 map
->p_paddr
= segment
->p_paddr
;
6925 map
->p_paddr_valid
= p_paddr_valid
;
6928 /* Determine if this segment contains the ELF file header
6929 and if it contains the program headers themselves. */
6930 map
->includes_filehdr
= (segment
->p_offset
== 0
6931 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6932 map
->includes_phdrs
= 0;
6934 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
6936 map
->includes_phdrs
=
6937 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6938 && (segment
->p_offset
+ segment
->p_filesz
6939 >= ((bfd_vma
) iehdr
->e_phoff
6940 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6942 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6943 phdr_included
= TRUE
;
6946 if (section_count
== 0)
6948 /* Special segments, such as the PT_PHDR segment, may contain
6949 no sections, but ordinary, loadable segments should contain
6950 something. They are allowed by the ELF spec however, so only
6951 a warning is produced.
6952 There is however the valid use case of embedded systems which
6953 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6954 flash memory with zeros. No warning is shown for that case. */
6955 if (segment
->p_type
== PT_LOAD
6956 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
6957 /* xgettext:c-format */
6959 (_("%pB: warning: empty loadable segment detected"
6960 " at vaddr=%#" PRIx64
", is this intentional?"),
6961 ibfd
, (uint64_t) segment
->p_vaddr
);
6963 map
->p_vaddr_offset
= segment
->p_vaddr
;
6965 *pointer_to_map
= map
;
6966 pointer_to_map
= &map
->next
;
6971 /* Now scan the sections in the input BFD again and attempt
6972 to add their corresponding output sections to the segment map.
6973 The problem here is how to handle an output section which has
6974 been moved (ie had its LMA changed). There are four possibilities:
6976 1. None of the sections have been moved.
6977 In this case we can continue to use the segment LMA from the
6980 2. All of the sections have been moved by the same amount.
6981 In this case we can change the segment's LMA to match the LMA
6982 of the first section.
6984 3. Some of the sections have been moved, others have not.
6985 In this case those sections which have not been moved can be
6986 placed in the current segment which will have to have its size,
6987 and possibly its LMA changed, and a new segment or segments will
6988 have to be created to contain the other sections.
6990 4. The sections have been moved, but not by the same amount.
6991 In this case we can change the segment's LMA to match the LMA
6992 of the first section and we will have to create a new segment
6993 or segments to contain the other sections.
6995 In order to save time, we allocate an array to hold the section
6996 pointers that we are interested in. As these sections get assigned
6997 to a segment, they are removed from this array. */
6999 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
7000 if (sections
== NULL
)
7003 /* Step One: Scan for segment vs section LMA conflicts.
7004 Also add the sections to the section array allocated above.
7005 Also add the sections to the current segment. In the common
7006 case, where the sections have not been moved, this means that
7007 we have completely filled the segment, and there is nothing
7010 matching_lma
= NULL
;
7011 suggested_lma
= NULL
;
7013 for (section
= first_section
, j
= 0;
7015 section
= section
->next
)
7017 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
7019 output_section
= section
->output_section
;
7021 sections
[j
++] = section
;
7023 /* The Solaris native linker always sets p_paddr to 0.
7024 We try to catch that case here, and set it to the
7025 correct value. Note - some backends require that
7026 p_paddr be left as zero. */
7028 && segment
->p_vaddr
!= 0
7029 && !bed
->want_p_paddr_set_to_zero
7031 && output_section
->lma
!= 0
7032 && (align_power (segment
->p_vaddr
7033 + (map
->includes_filehdr
7034 ? iehdr
->e_ehsize
: 0)
7035 + (map
->includes_phdrs
7036 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7038 output_section
->alignment_power
)
7039 == output_section
->vma
))
7040 map
->p_paddr
= segment
->p_vaddr
;
7042 /* Match up the physical address of the segment with the
7043 LMA address of the output section. */
7044 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7045 || IS_COREFILE_NOTE (segment
, section
)
7046 || (bed
->want_p_paddr_set_to_zero
7047 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
7049 if (matching_lma
== NULL
7050 || output_section
->lma
< matching_lma
->lma
)
7051 matching_lma
= output_section
;
7053 /* We assume that if the section fits within the segment
7054 then it does not overlap any other section within that
7056 map
->sections
[isec
++] = output_section
;
7058 else if (suggested_lma
== NULL
)
7059 suggested_lma
= output_section
;
7061 if (j
== section_count
)
7066 BFD_ASSERT (j
== section_count
);
7068 /* Step Two: Adjust the physical address of the current segment,
7070 if (isec
== section_count
)
7072 /* All of the sections fitted within the segment as currently
7073 specified. This is the default case. Add the segment to
7074 the list of built segments and carry on to process the next
7075 program header in the input BFD. */
7076 map
->count
= section_count
;
7077 *pointer_to_map
= map
;
7078 pointer_to_map
= &map
->next
;
7081 && !bed
->want_p_paddr_set_to_zero
7082 && matching_lma
->lma
!= map
->p_paddr
7083 && !map
->includes_filehdr
7084 && !map
->includes_phdrs
)
7085 /* There is some padding before the first section in the
7086 segment. So, we must account for that in the output
7088 map
->p_vaddr_offset
= map
->p_paddr
- matching_lma
->lma
;
7095 /* Change the current segment's physical address to match
7096 the LMA of the first section that fitted, or if no
7097 section fitted, the first section. */
7098 if (matching_lma
== NULL
)
7099 matching_lma
= suggested_lma
;
7101 map
->p_paddr
= matching_lma
->lma
;
7103 /* Offset the segment physical address from the lma
7104 to allow for space taken up by elf headers. */
7105 if (map
->includes_phdrs
)
7107 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7109 /* iehdr->e_phnum is just an estimate of the number
7110 of program headers that we will need. Make a note
7111 here of the number we used and the segment we chose
7112 to hold these headers, so that we can adjust the
7113 offset when we know the correct value. */
7114 phdr_adjust_num
= iehdr
->e_phnum
;
7115 phdr_adjust_seg
= map
;
7118 if (map
->includes_filehdr
)
7120 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7121 map
->p_paddr
-= iehdr
->e_ehsize
;
7122 /* We've subtracted off the size of headers from the
7123 first section lma, but there may have been some
7124 alignment padding before that section too. Try to
7125 account for that by adjusting the segment lma down to
7126 the same alignment. */
7127 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7128 align
= segment
->p_align
;
7129 map
->p_paddr
&= -align
;
7133 /* Step Three: Loop over the sections again, this time assigning
7134 those that fit to the current segment and removing them from the
7135 sections array; but making sure not to leave large gaps. Once all
7136 possible sections have been assigned to the current segment it is
7137 added to the list of built segments and if sections still remain
7138 to be assigned, a new segment is constructed before repeating
7144 suggested_lma
= NULL
;
7146 /* Fill the current segment with sections that fit. */
7147 for (j
= 0; j
< section_count
; j
++)
7149 section
= sections
[j
];
7151 if (section
== NULL
)
7154 output_section
= section
->output_section
;
7156 BFD_ASSERT (output_section
!= NULL
);
7158 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7159 || IS_COREFILE_NOTE (segment
, section
))
7161 if (map
->count
== 0)
7163 /* If the first section in a segment does not start at
7164 the beginning of the segment, then something is
7166 if (align_power (map
->p_paddr
7167 + (map
->includes_filehdr
7168 ? iehdr
->e_ehsize
: 0)
7169 + (map
->includes_phdrs
7170 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7172 output_section
->alignment_power
)
7173 != output_section
->lma
)
7180 prev_sec
= map
->sections
[map
->count
- 1];
7182 /* If the gap between the end of the previous section
7183 and the start of this section is more than
7184 maxpagesize then we need to start a new segment. */
7185 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7187 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7188 || (prev_sec
->lma
+ prev_sec
->size
7189 > output_section
->lma
))
7191 if (suggested_lma
== NULL
)
7192 suggested_lma
= output_section
;
7198 map
->sections
[map
->count
++] = output_section
;
7201 if (segment
->p_type
== PT_LOAD
)
7202 section
->segment_mark
= TRUE
;
7204 else if (suggested_lma
== NULL
)
7205 suggested_lma
= output_section
;
7208 /* PR 23932. A corrupt input file may contain sections that cannot
7209 be assigned to any segment - because for example they have a
7210 negative size - or segments that do not contain any sections. */
7211 if (map
->count
== 0)
7213 bfd_set_error (bfd_error_bad_value
);
7218 /* Add the current segment to the list of built segments. */
7219 *pointer_to_map
= map
;
7220 pointer_to_map
= &map
->next
;
7222 if (isec
< section_count
)
7224 /* We still have not allocated all of the sections to
7225 segments. Create a new segment here, initialise it
7226 and carry on looping. */
7227 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7228 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7229 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7236 /* Initialise the fields of the segment map. Set the physical
7237 physical address to the LMA of the first section that has
7238 not yet been assigned. */
7240 map
->p_type
= segment
->p_type
;
7241 map
->p_flags
= segment
->p_flags
;
7242 map
->p_flags_valid
= 1;
7243 map
->p_paddr
= suggested_lma
->lma
;
7244 map
->p_paddr_valid
= p_paddr_valid
;
7245 map
->includes_filehdr
= 0;
7246 map
->includes_phdrs
= 0;
7249 while (isec
< section_count
);
7254 elf_seg_map (obfd
) = map_first
;
7256 /* If we had to estimate the number of program headers that were
7257 going to be needed, then check our estimate now and adjust
7258 the offset if necessary. */
7259 if (phdr_adjust_seg
!= NULL
)
7263 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7266 if (count
> phdr_adjust_num
)
7267 phdr_adjust_seg
->p_paddr
7268 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7270 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7271 if (map
->p_type
== PT_PHDR
)
7274 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7275 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7282 #undef IS_CONTAINED_BY_VMA
7283 #undef IS_CONTAINED_BY_LMA
7285 #undef IS_COREFILE_NOTE
7286 #undef IS_SOLARIS_PT_INTERP
7287 #undef IS_SECTION_IN_INPUT_SEGMENT
7288 #undef INCLUDE_SECTION_IN_SEGMENT
7289 #undef SEGMENT_AFTER_SEGMENT
7290 #undef SEGMENT_OVERLAPS
7294 /* Copy ELF program header information. */
7297 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7299 Elf_Internal_Ehdr
*iehdr
;
7300 struct elf_segment_map
*map
;
7301 struct elf_segment_map
*map_first
;
7302 struct elf_segment_map
**pointer_to_map
;
7303 Elf_Internal_Phdr
*segment
;
7305 unsigned int num_segments
;
7306 bfd_boolean phdr_included
= FALSE
;
7307 bfd_boolean p_paddr_valid
;
7309 iehdr
= elf_elfheader (ibfd
);
7312 pointer_to_map
= &map_first
;
7314 /* If all the segment p_paddr fields are zero, don't set
7315 map->p_paddr_valid. */
7316 p_paddr_valid
= FALSE
;
7317 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7318 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7321 if (segment
->p_paddr
!= 0)
7323 p_paddr_valid
= TRUE
;
7327 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7332 unsigned int section_count
;
7334 Elf_Internal_Shdr
*this_hdr
;
7335 asection
*first_section
= NULL
;
7336 asection
*lowest_section
;
7337 bfd_boolean no_contents
= TRUE
;
7339 /* Compute how many sections are in this segment. */
7340 for (section
= ibfd
->sections
, section_count
= 0;
7342 section
= section
->next
)
7344 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7345 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7347 if (first_section
== NULL
)
7348 first_section
= section
;
7349 if (elf_section_type (section
) != SHT_NOBITS
)
7350 no_contents
= FALSE
;
7355 /* Allocate a segment map big enough to contain
7356 all of the sections we have selected. */
7357 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7358 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7359 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7363 /* Initialize the fields of the output segment map with the
7366 map
->p_type
= segment
->p_type
;
7367 map
->p_flags
= segment
->p_flags
;
7368 map
->p_flags_valid
= 1;
7369 map
->p_paddr
= segment
->p_paddr
;
7370 map
->p_paddr_valid
= p_paddr_valid
;
7371 map
->p_align
= segment
->p_align
;
7372 map
->p_align_valid
= 1;
7373 map
->p_vaddr_offset
= 0;
7375 if (map
->p_type
== PT_GNU_RELRO
7376 || map
->p_type
== PT_GNU_STACK
)
7378 /* The PT_GNU_RELRO segment may contain the first a few
7379 bytes in the .got.plt section even if the whole .got.plt
7380 section isn't in the PT_GNU_RELRO segment. We won't
7381 change the size of the PT_GNU_RELRO segment.
7382 Similarly, PT_GNU_STACK size is significant on uclinux
7384 map
->p_size
= segment
->p_memsz
;
7385 map
->p_size_valid
= 1;
7388 /* Determine if this segment contains the ELF file header
7389 and if it contains the program headers themselves. */
7390 map
->includes_filehdr
= (segment
->p_offset
== 0
7391 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7393 map
->includes_phdrs
= 0;
7394 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7396 map
->includes_phdrs
=
7397 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7398 && (segment
->p_offset
+ segment
->p_filesz
7399 >= ((bfd_vma
) iehdr
->e_phoff
7400 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7402 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7403 phdr_included
= TRUE
;
7406 lowest_section
= NULL
;
7407 if (section_count
!= 0)
7409 unsigned int isec
= 0;
7411 for (section
= first_section
;
7413 section
= section
->next
)
7415 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7416 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7418 map
->sections
[isec
++] = section
->output_section
;
7419 if ((section
->flags
& SEC_ALLOC
) != 0)
7423 if (lowest_section
== NULL
7424 || section
->lma
< lowest_section
->lma
)
7425 lowest_section
= section
;
7427 /* Section lmas are set up from PT_LOAD header
7428 p_paddr in _bfd_elf_make_section_from_shdr.
7429 If this header has a p_paddr that disagrees
7430 with the section lma, flag the p_paddr as
7432 if ((section
->flags
& SEC_LOAD
) != 0)
7433 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7435 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7436 if (section
->lma
- segment
->p_paddr
!= seg_off
)
7437 map
->p_paddr_valid
= FALSE
;
7439 if (isec
== section_count
)
7445 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
7447 /* Try to keep the space used by the headers plus any
7448 padding fixed. If there are sections with file contents
7449 in this segment then the lowest sh_offset is the best
7450 guess. Otherwise the segment only has file contents for
7451 the headers, and p_filesz is the best guess. */
7453 map
->header_size
= segment
->p_filesz
;
7455 map
->header_size
= lowest_section
->filepos
;
7458 if (section_count
== 0)
7459 map
->p_vaddr_offset
= segment
->p_vaddr
;
7460 else if (!map
->includes_phdrs
7461 && !map
->includes_filehdr
7462 && map
->p_paddr_valid
)
7463 /* Account for padding before the first section. */
7464 map
->p_vaddr_offset
= (segment
->p_paddr
7465 - (lowest_section
? lowest_section
->lma
: 0));
7467 map
->count
= section_count
;
7468 *pointer_to_map
= map
;
7469 pointer_to_map
= &map
->next
;
7472 elf_seg_map (obfd
) = map_first
;
7476 /* Copy private BFD data. This copies or rewrites ELF program header
7480 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7482 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7483 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7486 if (elf_tdata (ibfd
)->phdr
== NULL
)
7489 if (ibfd
->xvec
== obfd
->xvec
)
7491 /* Check to see if any sections in the input BFD
7492 covered by ELF program header have changed. */
7493 Elf_Internal_Phdr
*segment
;
7494 asection
*section
, *osec
;
7495 unsigned int i
, num_segments
;
7496 Elf_Internal_Shdr
*this_hdr
;
7497 const struct elf_backend_data
*bed
;
7499 bed
= get_elf_backend_data (ibfd
);
7501 /* Regenerate the segment map if p_paddr is set to 0. */
7502 if (bed
->want_p_paddr_set_to_zero
)
7505 /* Initialize the segment mark field. */
7506 for (section
= obfd
->sections
; section
!= NULL
;
7507 section
= section
->next
)
7508 section
->segment_mark
= FALSE
;
7510 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7511 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7515 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7516 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7517 which severly confuses things, so always regenerate the segment
7518 map in this case. */
7519 if (segment
->p_paddr
== 0
7520 && segment
->p_memsz
== 0
7521 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7524 for (section
= ibfd
->sections
;
7525 section
!= NULL
; section
= section
->next
)
7527 /* We mark the output section so that we know it comes
7528 from the input BFD. */
7529 osec
= section
->output_section
;
7531 osec
->segment_mark
= TRUE
;
7533 /* Check if this section is covered by the segment. */
7534 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7535 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7537 /* FIXME: Check if its output section is changed or
7538 removed. What else do we need to check? */
7540 || section
->flags
!= osec
->flags
7541 || section
->lma
!= osec
->lma
7542 || section
->vma
!= osec
->vma
7543 || section
->size
!= osec
->size
7544 || section
->rawsize
!= osec
->rawsize
7545 || section
->alignment_power
!= osec
->alignment_power
)
7551 /* Check to see if any output section do not come from the
7553 for (section
= obfd
->sections
; section
!= NULL
;
7554 section
= section
->next
)
7556 if (!section
->segment_mark
)
7559 section
->segment_mark
= FALSE
;
7562 return copy_elf_program_header (ibfd
, obfd
);
7566 if (ibfd
->xvec
== obfd
->xvec
)
7568 /* When rewriting program header, set the output maxpagesize to
7569 the maximum alignment of input PT_LOAD segments. */
7570 Elf_Internal_Phdr
*segment
;
7572 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7573 bfd_vma maxpagesize
= 0;
7575 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7578 if (segment
->p_type
== PT_LOAD
7579 && maxpagesize
< segment
->p_align
)
7581 /* PR 17512: file: f17299af. */
7582 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7583 /* xgettext:c-format */
7584 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7585 PRIx64
" is too large"),
7586 ibfd
, (uint64_t) segment
->p_align
);
7588 maxpagesize
= segment
->p_align
;
7591 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7592 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7595 return rewrite_elf_program_header (ibfd
, obfd
);
7598 /* Initialize private output section information from input section. */
7601 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7605 struct bfd_link_info
*link_info
)
7608 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7609 bfd_boolean final_link
= (link_info
!= NULL
7610 && !bfd_link_relocatable (link_info
));
7612 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7613 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7616 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7618 /* For objcopy and relocatable link, don't copy the output ELF
7619 section type from input if the output BFD section flags have been
7620 set to something different. For a final link allow some flags
7621 that the linker clears to differ. */
7622 if (elf_section_type (osec
) == SHT_NULL
7623 && (osec
->flags
== isec
->flags
7625 && ((osec
->flags
^ isec
->flags
)
7626 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7627 elf_section_type (osec
) = elf_section_type (isec
);
7629 /* FIXME: Is this correct for all OS/PROC specific flags? */
7630 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7631 & (SHF_MASKOS
| SHF_MASKPROC
));
7633 /* Copy sh_info from input for mbind section. */
7634 if (elf_section_flags (isec
) & SHF_GNU_MBIND
)
7635 elf_section_data (osec
)->this_hdr
.sh_info
7636 = elf_section_data (isec
)->this_hdr
.sh_info
;
7638 /* Set things up for objcopy and relocatable link. The output
7639 SHT_GROUP section will have its elf_next_in_group pointing back
7640 to the input group members. Ignore linker created group section.
7641 See elfNN_ia64_object_p in elfxx-ia64.c. */
7642 if ((link_info
== NULL
7643 || !link_info
->resolve_section_groups
)
7644 && (elf_sec_group (isec
) == NULL
7645 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7647 if (elf_section_flags (isec
) & SHF_GROUP
)
7648 elf_section_flags (osec
) |= SHF_GROUP
;
7649 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7650 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7653 /* If not decompress, preserve SHF_COMPRESSED. */
7654 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7655 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7658 ihdr
= &elf_section_data (isec
)->this_hdr
;
7660 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7661 don't use the output section of the linked-to section since it
7662 may be NULL at this point. */
7663 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7665 ohdr
= &elf_section_data (osec
)->this_hdr
;
7666 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7667 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7670 osec
->use_rela_p
= isec
->use_rela_p
;
7675 /* Copy private section information. This copies over the entsize
7676 field, and sometimes the info field. */
7679 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7684 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7686 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7687 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7690 ihdr
= &elf_section_data (isec
)->this_hdr
;
7691 ohdr
= &elf_section_data (osec
)->this_hdr
;
7693 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7695 if (ihdr
->sh_type
== SHT_SYMTAB
7696 || ihdr
->sh_type
== SHT_DYNSYM
7697 || ihdr
->sh_type
== SHT_GNU_verneed
7698 || ihdr
->sh_type
== SHT_GNU_verdef
)
7699 ohdr
->sh_info
= ihdr
->sh_info
;
7701 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7705 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7706 necessary if we are removing either the SHT_GROUP section or any of
7707 the group member sections. DISCARDED is the value that a section's
7708 output_section has if the section will be discarded, NULL when this
7709 function is called from objcopy, bfd_abs_section_ptr when called
7713 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7717 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7718 if (elf_section_type (isec
) == SHT_GROUP
)
7720 asection
*first
= elf_next_in_group (isec
);
7721 asection
*s
= first
;
7722 bfd_size_type removed
= 0;
7726 /* If this member section is being output but the
7727 SHT_GROUP section is not, then clear the group info
7728 set up by _bfd_elf_copy_private_section_data. */
7729 if (s
->output_section
!= discarded
7730 && isec
->output_section
== discarded
)
7732 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7733 elf_group_name (s
->output_section
) = NULL
;
7735 /* Conversely, if the member section is not being output
7736 but the SHT_GROUP section is, then adjust its size. */
7737 else if (s
->output_section
== discarded
7738 && isec
->output_section
!= discarded
)
7740 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7742 if (elf_sec
->rel
.hdr
!= NULL
7743 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7745 if (elf_sec
->rela
.hdr
!= NULL
7746 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7749 s
= elf_next_in_group (s
);
7755 if (discarded
!= NULL
)
7757 /* If we've been called for ld -r, then we need to
7758 adjust the input section size. */
7759 if (isec
->rawsize
== 0)
7760 isec
->rawsize
= isec
->size
;
7761 isec
->size
= isec
->rawsize
- removed
;
7762 if (isec
->size
<= 4)
7765 isec
->flags
|= SEC_EXCLUDE
;
7770 /* Adjust the output section size when called from
7772 isec
->output_section
->size
-= removed
;
7773 if (isec
->output_section
->size
<= 4)
7775 isec
->output_section
->size
= 0;
7776 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7785 /* Copy private header information. */
7788 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7790 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7791 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7794 /* Copy over private BFD data if it has not already been copied.
7795 This must be done here, rather than in the copy_private_bfd_data
7796 entry point, because the latter is called after the section
7797 contents have been set, which means that the program headers have
7798 already been worked out. */
7799 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7801 if (! copy_private_bfd_data (ibfd
, obfd
))
7805 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7808 /* Copy private symbol information. If this symbol is in a section
7809 which we did not map into a BFD section, try to map the section
7810 index correctly. We use special macro definitions for the mapped
7811 section indices; these definitions are interpreted by the
7812 swap_out_syms function. */
7814 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7815 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7816 #define MAP_STRTAB (SHN_HIOS + 3)
7817 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7818 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7821 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7826 elf_symbol_type
*isym
, *osym
;
7828 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7829 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7832 isym
= elf_symbol_from (ibfd
, isymarg
);
7833 osym
= elf_symbol_from (obfd
, osymarg
);
7836 && isym
->internal_elf_sym
.st_shndx
!= 0
7838 && bfd_is_abs_section (isym
->symbol
.section
))
7842 shndx
= isym
->internal_elf_sym
.st_shndx
;
7843 if (shndx
== elf_onesymtab (ibfd
))
7844 shndx
= MAP_ONESYMTAB
;
7845 else if (shndx
== elf_dynsymtab (ibfd
))
7846 shndx
= MAP_DYNSYMTAB
;
7847 else if (shndx
== elf_strtab_sec (ibfd
))
7849 else if (shndx
== elf_shstrtab_sec (ibfd
))
7850 shndx
= MAP_SHSTRTAB
;
7851 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
7852 shndx
= MAP_SYM_SHNDX
;
7853 osym
->internal_elf_sym
.st_shndx
= shndx
;
7859 /* Swap out the symbols. */
7862 swap_out_syms (bfd
*abfd
,
7863 struct elf_strtab_hash
**sttp
,
7866 const struct elf_backend_data
*bed
;
7869 struct elf_strtab_hash
*stt
;
7870 Elf_Internal_Shdr
*symtab_hdr
;
7871 Elf_Internal_Shdr
*symtab_shndx_hdr
;
7872 Elf_Internal_Shdr
*symstrtab_hdr
;
7873 struct elf_sym_strtab
*symstrtab
;
7874 bfd_byte
*outbound_syms
;
7875 bfd_byte
*outbound_shndx
;
7876 unsigned long outbound_syms_index
;
7877 unsigned long outbound_shndx_index
;
7879 unsigned int num_locals
;
7881 bfd_boolean name_local_sections
;
7883 if (!elf_map_symbols (abfd
, &num_locals
))
7886 /* Dump out the symtabs. */
7887 stt
= _bfd_elf_strtab_init ();
7891 bed
= get_elf_backend_data (abfd
);
7892 symcount
= bfd_get_symcount (abfd
);
7893 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7894 symtab_hdr
->sh_type
= SHT_SYMTAB
;
7895 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
7896 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
7897 symtab_hdr
->sh_info
= num_locals
+ 1;
7898 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
7900 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
7901 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7903 /* Allocate buffer to swap out the .strtab section. */
7904 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc ((symcount
+ 1)
7905 * sizeof (*symstrtab
));
7906 if (symstrtab
== NULL
)
7908 _bfd_elf_strtab_free (stt
);
7912 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
7913 bed
->s
->sizeof_sym
);
7914 if (outbound_syms
== NULL
)
7917 _bfd_elf_strtab_free (stt
);
7921 symtab_hdr
->contents
= outbound_syms
;
7922 outbound_syms_index
= 0;
7924 outbound_shndx
= NULL
;
7925 outbound_shndx_index
= 0;
7927 if (elf_symtab_shndx_list (abfd
))
7929 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
7930 if (symtab_shndx_hdr
->sh_name
!= 0)
7932 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
7933 outbound_shndx
= (bfd_byte
*)
7934 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
7935 if (outbound_shndx
== NULL
)
7938 symtab_shndx_hdr
->contents
= outbound_shndx
;
7939 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
7940 symtab_shndx_hdr
->sh_size
= amt
;
7941 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
7942 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
7944 /* FIXME: What about any other headers in the list ? */
7947 /* Now generate the data (for "contents"). */
7949 /* Fill in zeroth symbol and swap it out. */
7950 Elf_Internal_Sym sym
;
7956 sym
.st_shndx
= SHN_UNDEF
;
7957 sym
.st_target_internal
= 0;
7958 symstrtab
[0].sym
= sym
;
7959 symstrtab
[0].dest_index
= outbound_syms_index
;
7960 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
7961 outbound_syms_index
++;
7962 if (outbound_shndx
!= NULL
)
7963 outbound_shndx_index
++;
7967 = (bed
->elf_backend_name_local_section_symbols
7968 && bed
->elf_backend_name_local_section_symbols (abfd
));
7970 syms
= bfd_get_outsymbols (abfd
);
7971 for (idx
= 0; idx
< symcount
;)
7973 Elf_Internal_Sym sym
;
7974 bfd_vma value
= syms
[idx
]->value
;
7975 elf_symbol_type
*type_ptr
;
7976 flagword flags
= syms
[idx
]->flags
;
7979 if (!name_local_sections
7980 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
7982 /* Local section symbols have no name. */
7983 sym
.st_name
= (unsigned long) -1;
7987 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7988 to get the final offset for st_name. */
7990 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
7992 if (sym
.st_name
== (unsigned long) -1)
7996 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
7998 if ((flags
& BSF_SECTION_SYM
) == 0
7999 && bfd_is_com_section (syms
[idx
]->section
))
8001 /* ELF common symbols put the alignment into the `value' field,
8002 and the size into the `size' field. This is backwards from
8003 how BFD handles it, so reverse it here. */
8004 sym
.st_size
= value
;
8005 if (type_ptr
== NULL
8006 || type_ptr
->internal_elf_sym
.st_value
== 0)
8007 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8009 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8010 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8011 (abfd
, syms
[idx
]->section
);
8015 asection
*sec
= syms
[idx
]->section
;
8018 if (sec
->output_section
)
8020 value
+= sec
->output_offset
;
8021 sec
= sec
->output_section
;
8024 /* Don't add in the section vma for relocatable output. */
8025 if (! relocatable_p
)
8027 sym
.st_value
= value
;
8028 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8030 if (bfd_is_abs_section (sec
)
8032 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8034 /* This symbol is in a real ELF section which we did
8035 not create as a BFD section. Undo the mapping done
8036 by copy_private_symbol_data. */
8037 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8041 shndx
= elf_onesymtab (abfd
);
8044 shndx
= elf_dynsymtab (abfd
);
8047 shndx
= elf_strtab_sec (abfd
);
8050 shndx
= elf_shstrtab_sec (abfd
);
8053 if (elf_symtab_shndx_list (abfd
))
8054 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8063 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8065 if (shndx
== SHN_BAD
)
8069 /* Writing this would be a hell of a lot easier if
8070 we had some decent documentation on bfd, and
8071 knew what to expect of the library, and what to
8072 demand of applications. For example, it
8073 appears that `objcopy' might not set the
8074 section of a symbol to be a section that is
8075 actually in the output file. */
8076 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8078 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8079 if (shndx
== SHN_BAD
)
8081 /* xgettext:c-format */
8083 (_("unable to find equivalent output section"
8084 " for symbol '%s' from section '%s'"),
8085 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8087 bfd_set_error (bfd_error_invalid_operation
);
8093 sym
.st_shndx
= shndx
;
8096 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8098 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8099 type
= STT_GNU_IFUNC
;
8100 else if ((flags
& BSF_FUNCTION
) != 0)
8102 else if ((flags
& BSF_OBJECT
) != 0)
8104 else if ((flags
& BSF_RELC
) != 0)
8106 else if ((flags
& BSF_SRELC
) != 0)
8111 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8114 /* Processor-specific types. */
8115 if (type_ptr
!= NULL
8116 && bed
->elf_backend_get_symbol_type
)
8117 type
= ((*bed
->elf_backend_get_symbol_type
)
8118 (&type_ptr
->internal_elf_sym
, type
));
8120 if (flags
& BSF_SECTION_SYM
)
8122 if (flags
& BSF_GLOBAL
)
8123 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8125 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8127 else if (bfd_is_com_section (syms
[idx
]->section
))
8129 if (type
!= STT_TLS
)
8131 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8132 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8133 ? STT_COMMON
: STT_OBJECT
);
8135 type
= ((flags
& BSF_ELF_COMMON
) != 0
8136 ? STT_COMMON
: STT_OBJECT
);
8138 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8140 else if (bfd_is_und_section (syms
[idx
]->section
))
8141 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8145 else if (flags
& BSF_FILE
)
8146 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8149 int bind
= STB_LOCAL
;
8151 if (flags
& BSF_LOCAL
)
8153 else if (flags
& BSF_GNU_UNIQUE
)
8154 bind
= STB_GNU_UNIQUE
;
8155 else if (flags
& BSF_WEAK
)
8157 else if (flags
& BSF_GLOBAL
)
8160 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8163 if (type_ptr
!= NULL
)
8165 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8166 sym
.st_target_internal
8167 = type_ptr
->internal_elf_sym
.st_target_internal
;
8172 sym
.st_target_internal
= 0;
8176 symstrtab
[idx
].sym
= sym
;
8177 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8178 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8180 outbound_syms_index
++;
8181 if (outbound_shndx
!= NULL
)
8182 outbound_shndx_index
++;
8185 /* Finalize the .strtab section. */
8186 _bfd_elf_strtab_finalize (stt
);
8188 /* Swap out the .strtab section. */
8189 for (idx
= 0; idx
<= symcount
; idx
++)
8191 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8192 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8193 elfsym
->sym
.st_name
= 0;
8195 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8196 elfsym
->sym
.st_name
);
8197 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8199 + (elfsym
->dest_index
8200 * bed
->s
->sizeof_sym
)),
8202 + (elfsym
->destshndx_index
8203 * sizeof (Elf_External_Sym_Shndx
))));
8208 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8209 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8210 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8211 symstrtab_hdr
->sh_addr
= 0;
8212 symstrtab_hdr
->sh_entsize
= 0;
8213 symstrtab_hdr
->sh_link
= 0;
8214 symstrtab_hdr
->sh_info
= 0;
8215 symstrtab_hdr
->sh_addralign
= 1;
8220 /* Return the number of bytes required to hold the symtab vector.
8222 Note that we base it on the count plus 1, since we will null terminate
8223 the vector allocated based on this size. However, the ELF symbol table
8224 always has a dummy entry as symbol #0, so it ends up even. */
8227 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8229 bfd_size_type symcount
;
8231 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8233 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8234 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8236 bfd_set_error (bfd_error_file_too_big
);
8239 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8241 symtab_size
-= sizeof (asymbol
*);
8247 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8249 bfd_size_type symcount
;
8251 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8253 if (elf_dynsymtab (abfd
) == 0)
8255 bfd_set_error (bfd_error_invalid_operation
);
8259 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8260 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8262 bfd_set_error (bfd_error_file_too_big
);
8265 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8267 symtab_size
-= sizeof (asymbol
*);
8273 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
8276 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8279 /* Canonicalize the relocs. */
8282 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8289 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8291 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
8294 tblptr
= section
->relocation
;
8295 for (i
= 0; i
< section
->reloc_count
; i
++)
8296 *relptr
++ = tblptr
++;
8300 return section
->reloc_count
;
8304 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8306 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8307 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
8310 bfd_get_symcount (abfd
) = symcount
;
8315 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8316 asymbol
**allocation
)
8318 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8319 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
8322 bfd_get_dynamic_symcount (abfd
) = symcount
;
8326 /* Return the size required for the dynamic reloc entries. Any loadable
8327 section that was actually installed in the BFD, and has type SHT_REL
8328 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8329 dynamic reloc section. */
8332 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8334 bfd_size_type count
;
8337 if (elf_dynsymtab (abfd
) == 0)
8339 bfd_set_error (bfd_error_invalid_operation
);
8344 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8345 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8346 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8347 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8349 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8350 if (count
> LONG_MAX
/ sizeof (arelent
*))
8352 bfd_set_error (bfd_error_file_too_big
);
8356 return count
* sizeof (arelent
*);
8359 /* Canonicalize the dynamic relocation entries. Note that we return the
8360 dynamic relocations as a single block, although they are actually
8361 associated with particular sections; the interface, which was
8362 designed for SunOS style shared libraries, expects that there is only
8363 one set of dynamic relocs. Any loadable section that was actually
8364 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8365 dynamic symbol table, is considered to be a dynamic reloc section. */
8368 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8372 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8376 if (elf_dynsymtab (abfd
) == 0)
8378 bfd_set_error (bfd_error_invalid_operation
);
8382 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8384 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8386 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8387 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8388 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8393 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8395 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8397 for (i
= 0; i
< count
; i
++)
8408 /* Read in the version information. */
8411 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8413 bfd_byte
*contents
= NULL
;
8414 unsigned int freeidx
= 0;
8416 if (elf_dynverref (abfd
) != 0)
8418 Elf_Internal_Shdr
*hdr
;
8419 Elf_External_Verneed
*everneed
;
8420 Elf_Internal_Verneed
*iverneed
;
8422 bfd_byte
*contents_end
;
8424 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8426 if (hdr
->sh_info
== 0
8427 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8429 error_return_bad_verref
:
8431 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8432 bfd_set_error (bfd_error_bad_value
);
8433 error_return_verref
:
8434 elf_tdata (abfd
)->verref
= NULL
;
8435 elf_tdata (abfd
)->cverrefs
= 0;
8439 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8440 if (contents
== NULL
)
8441 goto error_return_verref
;
8443 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8444 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8445 goto error_return_verref
;
8447 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
8448 bfd_alloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
8450 if (elf_tdata (abfd
)->verref
== NULL
)
8451 goto error_return_verref
;
8453 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8454 == sizeof (Elf_External_Vernaux
));
8455 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8456 everneed
= (Elf_External_Verneed
*) contents
;
8457 iverneed
= elf_tdata (abfd
)->verref
;
8458 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8460 Elf_External_Vernaux
*evernaux
;
8461 Elf_Internal_Vernaux
*ivernaux
;
8464 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8466 iverneed
->vn_bfd
= abfd
;
8468 iverneed
->vn_filename
=
8469 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8471 if (iverneed
->vn_filename
== NULL
)
8472 goto error_return_bad_verref
;
8474 if (iverneed
->vn_cnt
== 0)
8475 iverneed
->vn_auxptr
= NULL
;
8478 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8479 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
8480 sizeof (Elf_Internal_Vernaux
));
8481 if (iverneed
->vn_auxptr
== NULL
)
8482 goto error_return_verref
;
8485 if (iverneed
->vn_aux
8486 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8487 goto error_return_bad_verref
;
8489 evernaux
= ((Elf_External_Vernaux
*)
8490 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8491 ivernaux
= iverneed
->vn_auxptr
;
8492 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8494 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8496 ivernaux
->vna_nodename
=
8497 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8498 ivernaux
->vna_name
);
8499 if (ivernaux
->vna_nodename
== NULL
)
8500 goto error_return_bad_verref
;
8502 if (ivernaux
->vna_other
> freeidx
)
8503 freeidx
= ivernaux
->vna_other
;
8505 ivernaux
->vna_nextptr
= NULL
;
8506 if (ivernaux
->vna_next
== 0)
8508 iverneed
->vn_cnt
= j
+ 1;
8511 if (j
+ 1 < iverneed
->vn_cnt
)
8512 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8514 if (ivernaux
->vna_next
8515 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8516 goto error_return_bad_verref
;
8518 evernaux
= ((Elf_External_Vernaux
*)
8519 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8522 iverneed
->vn_nextref
= NULL
;
8523 if (iverneed
->vn_next
== 0)
8525 if (i
+ 1 < hdr
->sh_info
)
8526 iverneed
->vn_nextref
= iverneed
+ 1;
8528 if (iverneed
->vn_next
8529 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8530 goto error_return_bad_verref
;
8532 everneed
= ((Elf_External_Verneed
*)
8533 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8535 elf_tdata (abfd
)->cverrefs
= i
;
8541 if (elf_dynverdef (abfd
) != 0)
8543 Elf_Internal_Shdr
*hdr
;
8544 Elf_External_Verdef
*everdef
;
8545 Elf_Internal_Verdef
*iverdef
;
8546 Elf_Internal_Verdef
*iverdefarr
;
8547 Elf_Internal_Verdef iverdefmem
;
8549 unsigned int maxidx
;
8550 bfd_byte
*contents_end_def
, *contents_end_aux
;
8552 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8554 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8556 error_return_bad_verdef
:
8558 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8559 bfd_set_error (bfd_error_bad_value
);
8560 error_return_verdef
:
8561 elf_tdata (abfd
)->verdef
= NULL
;
8562 elf_tdata (abfd
)->cverdefs
= 0;
8566 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8567 if (contents
== NULL
)
8568 goto error_return_verdef
;
8569 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8570 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8571 goto error_return_verdef
;
8573 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8574 >= sizeof (Elf_External_Verdaux
));
8575 contents_end_def
= contents
+ hdr
->sh_size
8576 - sizeof (Elf_External_Verdef
);
8577 contents_end_aux
= contents
+ hdr
->sh_size
8578 - sizeof (Elf_External_Verdaux
);
8580 /* We know the number of entries in the section but not the maximum
8581 index. Therefore we have to run through all entries and find
8583 everdef
= (Elf_External_Verdef
*) contents
;
8585 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8587 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8589 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8590 goto error_return_bad_verdef
;
8591 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8592 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8594 if (iverdefmem
.vd_next
== 0)
8597 if (iverdefmem
.vd_next
8598 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8599 goto error_return_bad_verdef
;
8601 everdef
= ((Elf_External_Verdef
*)
8602 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8605 if (default_imported_symver
)
8607 if (freeidx
> maxidx
)
8613 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8614 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
8615 if (elf_tdata (abfd
)->verdef
== NULL
)
8616 goto error_return_verdef
;
8618 elf_tdata (abfd
)->cverdefs
= maxidx
;
8620 everdef
= (Elf_External_Verdef
*) contents
;
8621 iverdefarr
= elf_tdata (abfd
)->verdef
;
8622 for (i
= 0; i
< hdr
->sh_info
; i
++)
8624 Elf_External_Verdaux
*everdaux
;
8625 Elf_Internal_Verdaux
*iverdaux
;
8628 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8630 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8631 goto error_return_bad_verdef
;
8633 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8634 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8636 iverdef
->vd_bfd
= abfd
;
8638 if (iverdef
->vd_cnt
== 0)
8639 iverdef
->vd_auxptr
= NULL
;
8642 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8643 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
8644 sizeof (Elf_Internal_Verdaux
));
8645 if (iverdef
->vd_auxptr
== NULL
)
8646 goto error_return_verdef
;
8650 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8651 goto error_return_bad_verdef
;
8653 everdaux
= ((Elf_External_Verdaux
*)
8654 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8655 iverdaux
= iverdef
->vd_auxptr
;
8656 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8658 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8660 iverdaux
->vda_nodename
=
8661 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8662 iverdaux
->vda_name
);
8663 if (iverdaux
->vda_nodename
== NULL
)
8664 goto error_return_bad_verdef
;
8666 iverdaux
->vda_nextptr
= NULL
;
8667 if (iverdaux
->vda_next
== 0)
8669 iverdef
->vd_cnt
= j
+ 1;
8672 if (j
+ 1 < iverdef
->vd_cnt
)
8673 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8675 if (iverdaux
->vda_next
8676 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8677 goto error_return_bad_verdef
;
8679 everdaux
= ((Elf_External_Verdaux
*)
8680 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8683 iverdef
->vd_nodename
= NULL
;
8684 if (iverdef
->vd_cnt
)
8685 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8687 iverdef
->vd_nextdef
= NULL
;
8688 if (iverdef
->vd_next
== 0)
8690 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8691 iverdef
->vd_nextdef
= iverdef
+ 1;
8693 everdef
= ((Elf_External_Verdef
*)
8694 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8700 else if (default_imported_symver
)
8707 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8708 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8709 if (elf_tdata (abfd
)->verdef
== NULL
)
8712 elf_tdata (abfd
)->cverdefs
= freeidx
;
8715 /* Create a default version based on the soname. */
8716 if (default_imported_symver
)
8718 Elf_Internal_Verdef
*iverdef
;
8719 Elf_Internal_Verdaux
*iverdaux
;
8721 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8723 iverdef
->vd_version
= VER_DEF_CURRENT
;
8724 iverdef
->vd_flags
= 0;
8725 iverdef
->vd_ndx
= freeidx
;
8726 iverdef
->vd_cnt
= 1;
8728 iverdef
->vd_bfd
= abfd
;
8730 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8731 if (iverdef
->vd_nodename
== NULL
)
8732 goto error_return_verdef
;
8733 iverdef
->vd_nextdef
= NULL
;
8734 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8735 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8736 if (iverdef
->vd_auxptr
== NULL
)
8737 goto error_return_verdef
;
8739 iverdaux
= iverdef
->vd_auxptr
;
8740 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8746 if (contents
!= NULL
)
8752 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8754 elf_symbol_type
*newsym
;
8756 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof * newsym
);
8759 newsym
->symbol
.the_bfd
= abfd
;
8760 return &newsym
->symbol
;
8764 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8768 bfd_symbol_info (symbol
, ret
);
8771 /* Return whether a symbol name implies a local symbol. Most targets
8772 use this function for the is_local_label_name entry point, but some
8776 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8779 /* Normal local symbols start with ``.L''. */
8780 if (name
[0] == '.' && name
[1] == 'L')
8783 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8784 DWARF debugging symbols starting with ``..''. */
8785 if (name
[0] == '.' && name
[1] == '.')
8788 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8789 emitting DWARF debugging output. I suspect this is actually a
8790 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8791 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8792 underscore to be emitted on some ELF targets). For ease of use,
8793 we treat such symbols as local. */
8794 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8797 /* Treat assembler generated fake symbols, dollar local labels and
8798 forward-backward labels (aka local labels) as locals.
8799 These labels have the form:
8801 L0^A.* (fake symbols)
8803 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8805 Versions which start with .L will have already been matched above,
8806 so we only need to match the rest. */
8807 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8809 bfd_boolean ret
= FALSE
;
8813 for (p
= name
+ 2; (c
= *p
); p
++)
8815 if (c
== 1 || c
== 2)
8817 if (c
== 1 && p
== name
+ 2)
8818 /* A fake symbol. */
8821 /* FIXME: We are being paranoid here and treating symbols like
8822 L0^Bfoo as if there were non-local, on the grounds that the
8823 assembler will never generate them. But can any symbol
8824 containing an ASCII value in the range 1-31 ever be anything
8825 other than some kind of local ? */
8842 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
8843 asymbol
*symbol ATTRIBUTE_UNUSED
)
8850 _bfd_elf_set_arch_mach (bfd
*abfd
,
8851 enum bfd_architecture arch
,
8852 unsigned long machine
)
8854 /* If this isn't the right architecture for this backend, and this
8855 isn't the generic backend, fail. */
8856 if (arch
!= get_elf_backend_data (abfd
)->arch
8857 && arch
!= bfd_arch_unknown
8858 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
8861 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
8864 /* Find the nearest line to a particular section and offset,
8865 for error reporting. */
8868 _bfd_elf_find_nearest_line (bfd
*abfd
,
8872 const char **filename_ptr
,
8873 const char **functionname_ptr
,
8874 unsigned int *line_ptr
,
8875 unsigned int *discriminator_ptr
)
8879 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
8880 filename_ptr
, functionname_ptr
,
8881 line_ptr
, discriminator_ptr
,
8882 dwarf_debug_sections
, 0,
8883 &elf_tdata (abfd
)->dwarf2_find_line_info
)
8884 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
8885 filename_ptr
, functionname_ptr
,
8888 if (!*functionname_ptr
)
8889 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8890 *filename_ptr
? NULL
: filename_ptr
,
8895 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
8896 &found
, filename_ptr
,
8897 functionname_ptr
, line_ptr
,
8898 &elf_tdata (abfd
)->line_info
))
8900 if (found
&& (*functionname_ptr
|| *line_ptr
))
8903 if (symbols
== NULL
)
8906 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8907 filename_ptr
, functionname_ptr
))
8914 /* Find the line for a symbol. */
8917 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
8918 const char **filename_ptr
, unsigned int *line_ptr
)
8920 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
8921 filename_ptr
, NULL
, line_ptr
, NULL
,
8922 dwarf_debug_sections
, 0,
8923 &elf_tdata (abfd
)->dwarf2_find_line_info
);
8926 /* After a call to bfd_find_nearest_line, successive calls to
8927 bfd_find_inliner_info can be used to get source information about
8928 each level of function inlining that terminated at the address
8929 passed to bfd_find_nearest_line. Currently this is only supported
8930 for DWARF2 with appropriate DWARF3 extensions. */
8933 _bfd_elf_find_inliner_info (bfd
*abfd
,
8934 const char **filename_ptr
,
8935 const char **functionname_ptr
,
8936 unsigned int *line_ptr
)
8939 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
8940 functionname_ptr
, line_ptr
,
8941 & elf_tdata (abfd
)->dwarf2_find_line_info
);
8946 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
8948 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8949 int ret
= bed
->s
->sizeof_ehdr
;
8951 if (!bfd_link_relocatable (info
))
8953 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
8955 if (phdr_size
== (bfd_size_type
) -1)
8957 struct elf_segment_map
*m
;
8960 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
8961 phdr_size
+= bed
->s
->sizeof_phdr
;
8964 phdr_size
= get_program_header_size (abfd
, info
);
8967 elf_program_header_size (abfd
) = phdr_size
;
8975 _bfd_elf_set_section_contents (bfd
*abfd
,
8977 const void *location
,
8979 bfd_size_type count
)
8981 Elf_Internal_Shdr
*hdr
;
8984 if (! abfd
->output_has_begun
8985 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
8991 hdr
= &elf_section_data (section
)->this_hdr
;
8992 if (hdr
->sh_offset
== (file_ptr
) -1)
8994 /* We must compress this section. Write output to the buffer. */
8995 unsigned char *contents
= hdr
->contents
;
8996 if ((offset
+ count
) > hdr
->sh_size
8997 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
8998 || contents
== NULL
)
9000 memcpy (contents
+ offset
, location
, count
);
9003 pos
= hdr
->sh_offset
+ offset
;
9004 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9005 || bfd_bwrite (location
, count
, abfd
) != count
)
9012 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9013 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9014 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9020 /* Try to convert a non-ELF reloc into an ELF one. */
9023 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9025 /* Check whether we really have an ELF howto. */
9027 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9029 bfd_reloc_code_real_type code
;
9030 reloc_howto_type
*howto
;
9032 /* Alien reloc: Try to determine its type to replace it with an
9033 equivalent ELF reloc. */
9035 if (areloc
->howto
->pc_relative
)
9037 switch (areloc
->howto
->bitsize
)
9040 code
= BFD_RELOC_8_PCREL
;
9043 code
= BFD_RELOC_12_PCREL
;
9046 code
= BFD_RELOC_16_PCREL
;
9049 code
= BFD_RELOC_24_PCREL
;
9052 code
= BFD_RELOC_32_PCREL
;
9055 code
= BFD_RELOC_64_PCREL
;
9061 howto
= bfd_reloc_type_lookup (abfd
, code
);
9063 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9065 if (howto
->pcrel_offset
)
9066 areloc
->addend
+= areloc
->address
;
9068 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9073 switch (areloc
->howto
->bitsize
)
9079 code
= BFD_RELOC_14
;
9082 code
= BFD_RELOC_16
;
9085 code
= BFD_RELOC_26
;
9088 code
= BFD_RELOC_32
;
9091 code
= BFD_RELOC_64
;
9097 howto
= bfd_reloc_type_lookup (abfd
, code
);
9101 areloc
->howto
= howto
;
9109 /* xgettext:c-format */
9110 _bfd_error_handler (_("%pB: %s unsupported"),
9111 abfd
, areloc
->howto
->name
);
9112 bfd_set_error (bfd_error_bad_value
);
9117 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9119 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9120 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
9122 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9123 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9124 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9127 return _bfd_generic_close_and_cleanup (abfd
);
9130 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9131 in the relocation's offset. Thus we cannot allow any sort of sanity
9132 range-checking to interfere. There is nothing else to do in processing
9135 bfd_reloc_status_type
9136 _bfd_elf_rel_vtable_reloc_fn
9137 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9138 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9139 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9140 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9142 return bfd_reloc_ok
;
9145 /* Elf core file support. Much of this only works on native
9146 toolchains, since we rely on knowing the
9147 machine-dependent procfs structure in order to pick
9148 out details about the corefile. */
9150 #ifdef HAVE_SYS_PROCFS_H
9151 /* Needed for new procfs interface on sparc-solaris. */
9152 # define _STRUCTURED_PROC 1
9153 # include <sys/procfs.h>
9156 /* Return a PID that identifies a "thread" for threaded cores, or the
9157 PID of the main process for non-threaded cores. */
9160 elfcore_make_pid (bfd
*abfd
)
9164 pid
= elf_tdata (abfd
)->core
->lwpid
;
9166 pid
= elf_tdata (abfd
)->core
->pid
;
9171 /* If there isn't a section called NAME, make one, using
9172 data from SECT. Note, this function will generate a
9173 reference to NAME, so you shouldn't deallocate or
9177 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9181 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9184 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9188 sect2
->size
= sect
->size
;
9189 sect2
->filepos
= sect
->filepos
;
9190 sect2
->alignment_power
= sect
->alignment_power
;
9194 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9195 actually creates up to two pseudosections:
9196 - For the single-threaded case, a section named NAME, unless
9197 such a section already exists.
9198 - For the multi-threaded case, a section named "NAME/PID", where
9199 PID is elfcore_make_pid (abfd).
9200 Both pseudosections have identical contents. */
9202 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9208 char *threaded_name
;
9212 /* Build the section name. */
9214 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9215 len
= strlen (buf
) + 1;
9216 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9217 if (threaded_name
== NULL
)
9219 memcpy (threaded_name
, buf
, len
);
9221 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9226 sect
->filepos
= filepos
;
9227 sect
->alignment_power
= 2;
9229 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9232 /* prstatus_t exists on:
9234 linux 2.[01] + glibc
9238 #if defined (HAVE_PRSTATUS_T)
9241 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9246 if (note
->descsz
== sizeof (prstatus_t
))
9250 size
= sizeof (prstat
.pr_reg
);
9251 offset
= offsetof (prstatus_t
, pr_reg
);
9252 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9254 /* Do not overwrite the core signal if it
9255 has already been set by another thread. */
9256 if (elf_tdata (abfd
)->core
->signal
== 0)
9257 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9258 if (elf_tdata (abfd
)->core
->pid
== 0)
9259 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9261 /* pr_who exists on:
9264 pr_who doesn't exist on:
9267 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9268 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9270 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9273 #if defined (HAVE_PRSTATUS32_T)
9274 else if (note
->descsz
== sizeof (prstatus32_t
))
9276 /* 64-bit host, 32-bit corefile */
9277 prstatus32_t prstat
;
9279 size
= sizeof (prstat
.pr_reg
);
9280 offset
= offsetof (prstatus32_t
, pr_reg
);
9281 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9283 /* Do not overwrite the core signal if it
9284 has already been set by another thread. */
9285 if (elf_tdata (abfd
)->core
->signal
== 0)
9286 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9287 if (elf_tdata (abfd
)->core
->pid
== 0)
9288 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9290 /* pr_who exists on:
9293 pr_who doesn't exist on:
9296 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9297 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9299 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9302 #endif /* HAVE_PRSTATUS32_T */
9305 /* Fail - we don't know how to handle any other
9306 note size (ie. data object type). */
9310 /* Make a ".reg/999" section and a ".reg" section. */
9311 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9312 size
, note
->descpos
+ offset
);
9314 #endif /* defined (HAVE_PRSTATUS_T) */
9316 /* Create a pseudosection containing the exact contents of NOTE. */
9318 elfcore_make_note_pseudosection (bfd
*abfd
,
9320 Elf_Internal_Note
*note
)
9322 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9323 note
->descsz
, note
->descpos
);
9326 /* There isn't a consistent prfpregset_t across platforms,
9327 but it doesn't matter, because we don't have to pick this
9328 data structure apart. */
9331 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9333 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9336 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9337 type of NT_PRXFPREG. Just include the whole note's contents
9341 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9343 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9346 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9347 with a note type of NT_X86_XSTATE. Just include the whole note's
9348 contents literally. */
9351 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9353 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9357 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9359 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9363 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9365 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9369 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9371 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9375 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9377 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9381 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9383 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9387 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9389 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9393 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9395 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9399 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9401 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9405 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9407 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9411 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9413 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9417 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9419 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9423 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9425 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9429 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9431 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9435 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9437 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9441 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9443 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9447 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9449 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9453 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9455 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9459 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9461 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9465 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9467 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9471 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9473 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9477 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9479 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9483 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9485 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9489 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9491 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9495 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9497 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9501 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9503 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9507 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9509 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9513 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9515 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9519 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9521 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9525 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9527 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9531 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9533 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9537 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9539 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9543 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9545 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9549 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9551 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9555 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9557 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9560 #if defined (HAVE_PRPSINFO_T)
9561 typedef prpsinfo_t elfcore_psinfo_t
;
9562 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9563 typedef prpsinfo32_t elfcore_psinfo32_t
;
9567 #if defined (HAVE_PSINFO_T)
9568 typedef psinfo_t elfcore_psinfo_t
;
9569 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9570 typedef psinfo32_t elfcore_psinfo32_t
;
9574 /* return a malloc'ed copy of a string at START which is at
9575 most MAX bytes long, possibly without a terminating '\0'.
9576 the copy will always have a terminating '\0'. */
9579 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9582 char *end
= (char *) memchr (start
, '\0', max
);
9590 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9594 memcpy (dups
, start
, len
);
9600 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9602 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9604 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9606 elfcore_psinfo_t psinfo
;
9608 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9610 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9611 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9613 elf_tdata (abfd
)->core
->program
9614 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9615 sizeof (psinfo
.pr_fname
));
9617 elf_tdata (abfd
)->core
->command
9618 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9619 sizeof (psinfo
.pr_psargs
));
9621 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9622 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9624 /* 64-bit host, 32-bit corefile */
9625 elfcore_psinfo32_t psinfo
;
9627 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9629 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9630 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9632 elf_tdata (abfd
)->core
->program
9633 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9634 sizeof (psinfo
.pr_fname
));
9636 elf_tdata (abfd
)->core
->command
9637 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9638 sizeof (psinfo
.pr_psargs
));
9644 /* Fail - we don't know how to handle any other
9645 note size (ie. data object type). */
9649 /* Note that for some reason, a spurious space is tacked
9650 onto the end of the args in some (at least one anyway)
9651 implementations, so strip it off if it exists. */
9654 char *command
= elf_tdata (abfd
)->core
->command
;
9655 int n
= strlen (command
);
9657 if (0 < n
&& command
[n
- 1] == ' ')
9658 command
[n
- 1] = '\0';
9663 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9665 #if defined (HAVE_PSTATUS_T)
9667 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9669 if (note
->descsz
== sizeof (pstatus_t
)
9670 #if defined (HAVE_PXSTATUS_T)
9671 || note
->descsz
== sizeof (pxstatus_t
)
9677 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9679 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9681 #if defined (HAVE_PSTATUS32_T)
9682 else if (note
->descsz
== sizeof (pstatus32_t
))
9684 /* 64-bit host, 32-bit corefile */
9687 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9689 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9692 /* Could grab some more details from the "representative"
9693 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9694 NT_LWPSTATUS note, presumably. */
9698 #endif /* defined (HAVE_PSTATUS_T) */
9700 #if defined (HAVE_LWPSTATUS_T)
9702 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9704 lwpstatus_t lwpstat
;
9710 if (note
->descsz
!= sizeof (lwpstat
)
9711 #if defined (HAVE_LWPXSTATUS_T)
9712 && note
->descsz
!= sizeof (lwpxstatus_t
)
9717 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
9719 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
9720 /* Do not overwrite the core signal if it has already been set by
9722 if (elf_tdata (abfd
)->core
->signal
== 0)
9723 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
9725 /* Make a ".reg/999" section. */
9727 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
9728 len
= strlen (buf
) + 1;
9729 name
= bfd_alloc (abfd
, len
);
9732 memcpy (name
, buf
, len
);
9734 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9738 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9739 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
9740 sect
->filepos
= note
->descpos
9741 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
9744 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9745 sect
->size
= sizeof (lwpstat
.pr_reg
);
9746 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
9749 sect
->alignment_power
= 2;
9751 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9754 /* Make a ".reg2/999" section */
9756 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
9757 len
= strlen (buf
) + 1;
9758 name
= bfd_alloc (abfd
, len
);
9761 memcpy (name
, buf
, len
);
9763 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9767 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9768 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
9769 sect
->filepos
= note
->descpos
9770 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
9773 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9774 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9775 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9778 sect
->alignment_power
= 2;
9780 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9782 #endif /* defined (HAVE_LWPSTATUS_T) */
9785 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9792 int is_active_thread
;
9795 if (note
->descsz
< 728)
9798 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9801 type
= bfd_get_32 (abfd
, note
->descdata
);
9805 case 1 /* NOTE_INFO_PROCESS */:
9806 /* FIXME: need to add ->core->command. */
9807 /* process_info.pid */
9808 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9809 /* process_info.signal */
9810 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
9813 case 2 /* NOTE_INFO_THREAD */:
9814 /* Make a ".reg/999" section. */
9815 /* thread_info.tid */
9816 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
9818 len
= strlen (buf
) + 1;
9819 name
= (char *) bfd_alloc (abfd
, len
);
9823 memcpy (name
, buf
, len
);
9825 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9829 /* sizeof (thread_info.thread_context) */
9831 /* offsetof (thread_info.thread_context) */
9832 sect
->filepos
= note
->descpos
+ 12;
9833 sect
->alignment_power
= 2;
9835 /* thread_info.is_active_thread */
9836 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9838 if (is_active_thread
)
9839 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9843 case 3 /* NOTE_INFO_MODULE */:
9844 /* Make a ".module/xxxxxxxx" section. */
9845 /* module_info.base_address */
9846 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
9847 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
9849 len
= strlen (buf
) + 1;
9850 name
= (char *) bfd_alloc (abfd
, len
);
9854 memcpy (name
, buf
, len
);
9856 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9861 sect
->size
= note
->descsz
;
9862 sect
->filepos
= note
->descpos
;
9863 sect
->alignment_power
= 2;
9874 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9876 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9884 if (bed
->elf_backend_grok_prstatus
)
9885 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
9887 #if defined (HAVE_PRSTATUS_T)
9888 return elfcore_grok_prstatus (abfd
, note
);
9893 #if defined (HAVE_PSTATUS_T)
9895 return elfcore_grok_pstatus (abfd
, note
);
9898 #if defined (HAVE_LWPSTATUS_T)
9900 return elfcore_grok_lwpstatus (abfd
, note
);
9903 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
9904 return elfcore_grok_prfpreg (abfd
, note
);
9906 case NT_WIN32PSTATUS
:
9907 return elfcore_grok_win32pstatus (abfd
, note
);
9909 case NT_PRXFPREG
: /* Linux SSE extension */
9910 if (note
->namesz
== 6
9911 && strcmp (note
->namedata
, "LINUX") == 0)
9912 return elfcore_grok_prxfpreg (abfd
, note
);
9916 case NT_X86_XSTATE
: /* Linux XSAVE extension */
9917 if (note
->namesz
== 6
9918 && strcmp (note
->namedata
, "LINUX") == 0)
9919 return elfcore_grok_xstatereg (abfd
, note
);
9924 if (note
->namesz
== 6
9925 && strcmp (note
->namedata
, "LINUX") == 0)
9926 return elfcore_grok_ppc_vmx (abfd
, note
);
9931 if (note
->namesz
== 6
9932 && strcmp (note
->namedata
, "LINUX") == 0)
9933 return elfcore_grok_ppc_vsx (abfd
, note
);
9938 if (note
->namesz
== 6
9939 && strcmp (note
->namedata
, "LINUX") == 0)
9940 return elfcore_grok_ppc_tar (abfd
, note
);
9945 if (note
->namesz
== 6
9946 && strcmp (note
->namedata
, "LINUX") == 0)
9947 return elfcore_grok_ppc_ppr (abfd
, note
);
9952 if (note
->namesz
== 6
9953 && strcmp (note
->namedata
, "LINUX") == 0)
9954 return elfcore_grok_ppc_dscr (abfd
, note
);
9959 if (note
->namesz
== 6
9960 && strcmp (note
->namedata
, "LINUX") == 0)
9961 return elfcore_grok_ppc_ebb (abfd
, note
);
9966 if (note
->namesz
== 6
9967 && strcmp (note
->namedata
, "LINUX") == 0)
9968 return elfcore_grok_ppc_pmu (abfd
, note
);
9972 case NT_PPC_TM_CGPR
:
9973 if (note
->namesz
== 6
9974 && strcmp (note
->namedata
, "LINUX") == 0)
9975 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
9979 case NT_PPC_TM_CFPR
:
9980 if (note
->namesz
== 6
9981 && strcmp (note
->namedata
, "LINUX") == 0)
9982 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
9986 case NT_PPC_TM_CVMX
:
9987 if (note
->namesz
== 6
9988 && strcmp (note
->namedata
, "LINUX") == 0)
9989 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
9993 case NT_PPC_TM_CVSX
:
9994 if (note
->namesz
== 6
9995 && strcmp (note
->namedata
, "LINUX") == 0)
9996 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10000 case NT_PPC_TM_SPR
:
10001 if (note
->namesz
== 6
10002 && strcmp (note
->namedata
, "LINUX") == 0)
10003 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10007 case NT_PPC_TM_CTAR
:
10008 if (note
->namesz
== 6
10009 && strcmp (note
->namedata
, "LINUX") == 0)
10010 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10014 case NT_PPC_TM_CPPR
:
10015 if (note
->namesz
== 6
10016 && strcmp (note
->namedata
, "LINUX") == 0)
10017 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10021 case NT_PPC_TM_CDSCR
:
10022 if (note
->namesz
== 6
10023 && strcmp (note
->namedata
, "LINUX") == 0)
10024 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10028 case NT_S390_HIGH_GPRS
:
10029 if (note
->namesz
== 6
10030 && strcmp (note
->namedata
, "LINUX") == 0)
10031 return elfcore_grok_s390_high_gprs (abfd
, note
);
10035 case NT_S390_TIMER
:
10036 if (note
->namesz
== 6
10037 && strcmp (note
->namedata
, "LINUX") == 0)
10038 return elfcore_grok_s390_timer (abfd
, note
);
10042 case NT_S390_TODCMP
:
10043 if (note
->namesz
== 6
10044 && strcmp (note
->namedata
, "LINUX") == 0)
10045 return elfcore_grok_s390_todcmp (abfd
, note
);
10049 case NT_S390_TODPREG
:
10050 if (note
->namesz
== 6
10051 && strcmp (note
->namedata
, "LINUX") == 0)
10052 return elfcore_grok_s390_todpreg (abfd
, note
);
10057 if (note
->namesz
== 6
10058 && strcmp (note
->namedata
, "LINUX") == 0)
10059 return elfcore_grok_s390_ctrs (abfd
, note
);
10063 case NT_S390_PREFIX
:
10064 if (note
->namesz
== 6
10065 && strcmp (note
->namedata
, "LINUX") == 0)
10066 return elfcore_grok_s390_prefix (abfd
, note
);
10070 case NT_S390_LAST_BREAK
:
10071 if (note
->namesz
== 6
10072 && strcmp (note
->namedata
, "LINUX") == 0)
10073 return elfcore_grok_s390_last_break (abfd
, note
);
10077 case NT_S390_SYSTEM_CALL
:
10078 if (note
->namesz
== 6
10079 && strcmp (note
->namedata
, "LINUX") == 0)
10080 return elfcore_grok_s390_system_call (abfd
, note
);
10085 if (note
->namesz
== 6
10086 && strcmp (note
->namedata
, "LINUX") == 0)
10087 return elfcore_grok_s390_tdb (abfd
, note
);
10091 case NT_S390_VXRS_LOW
:
10092 if (note
->namesz
== 6
10093 && strcmp (note
->namedata
, "LINUX") == 0)
10094 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10098 case NT_S390_VXRS_HIGH
:
10099 if (note
->namesz
== 6
10100 && strcmp (note
->namedata
, "LINUX") == 0)
10101 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10105 case NT_S390_GS_CB
:
10106 if (note
->namesz
== 6
10107 && strcmp (note
->namedata
, "LINUX") == 0)
10108 return elfcore_grok_s390_gs_cb (abfd
, note
);
10112 case NT_S390_GS_BC
:
10113 if (note
->namesz
== 6
10114 && strcmp (note
->namedata
, "LINUX") == 0)
10115 return elfcore_grok_s390_gs_bc (abfd
, note
);
10120 if (note
->namesz
== 6
10121 && strcmp (note
->namedata
, "LINUX") == 0)
10122 return elfcore_grok_arm_vfp (abfd
, note
);
10127 if (note
->namesz
== 6
10128 && strcmp (note
->namedata
, "LINUX") == 0)
10129 return elfcore_grok_aarch_tls (abfd
, note
);
10133 case NT_ARM_HW_BREAK
:
10134 if (note
->namesz
== 6
10135 && strcmp (note
->namedata
, "LINUX") == 0)
10136 return elfcore_grok_aarch_hw_break (abfd
, note
);
10140 case NT_ARM_HW_WATCH
:
10141 if (note
->namesz
== 6
10142 && strcmp (note
->namedata
, "LINUX") == 0)
10143 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10148 if (note
->namesz
== 6
10149 && strcmp (note
->namedata
, "LINUX") == 0)
10150 return elfcore_grok_aarch_sve (abfd
, note
);
10154 case NT_ARM_PAC_MASK
:
10155 if (note
->namesz
== 6
10156 && strcmp (note
->namedata
, "LINUX") == 0)
10157 return elfcore_grok_aarch_pauth (abfd
, note
);
10163 if (bed
->elf_backend_grok_psinfo
)
10164 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10166 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10167 return elfcore_grok_psinfo (abfd
, note
);
10174 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
10179 sect
->size
= note
->descsz
;
10180 sect
->filepos
= note
->descpos
;
10181 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10187 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10191 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10198 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10200 struct bfd_build_id
* build_id
;
10202 if (note
->descsz
== 0)
10205 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10206 if (build_id
== NULL
)
10209 build_id
->size
= note
->descsz
;
10210 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10211 abfd
->build_id
= build_id
;
10217 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10219 switch (note
->type
)
10224 case NT_GNU_PROPERTY_TYPE_0
:
10225 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10227 case NT_GNU_BUILD_ID
:
10228 return elfobj_grok_gnu_build_id (abfd
, note
);
10233 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10235 struct sdt_note
*cur
=
10236 (struct sdt_note
*) bfd_alloc (abfd
, sizeof (struct sdt_note
)
10239 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10240 cur
->size
= (bfd_size_type
) note
->descsz
;
10241 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10243 elf_tdata (abfd
)->sdt_note_head
= cur
;
10249 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10251 switch (note
->type
)
10254 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10262 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10266 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10269 if (note
->descsz
< 108)
10274 if (note
->descsz
< 120)
10282 /* Check for version 1 in pr_version. */
10283 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10288 /* Skip over pr_psinfosz. */
10289 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10293 offset
+= 4; /* Padding before pr_psinfosz. */
10297 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10298 elf_tdata (abfd
)->core
->program
10299 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10302 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10303 elf_tdata (abfd
)->core
->command
10304 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10307 /* Padding before pr_pid. */
10310 /* The pr_pid field was added in version "1a". */
10311 if (note
->descsz
< offset
+ 4)
10314 elf_tdata (abfd
)->core
->pid
10315 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10321 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10327 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10328 Also compute minimum size of this note. */
10329 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10333 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10337 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10338 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10345 if (note
->descsz
< min_size
)
10348 /* Check for version 1 in pr_version. */
10349 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10352 /* Extract size of pr_reg from pr_gregsetsz. */
10353 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10354 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10356 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10361 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10365 /* Skip over pr_osreldate. */
10368 /* Read signal from pr_cursig. */
10369 if (elf_tdata (abfd
)->core
->signal
== 0)
10370 elf_tdata (abfd
)->core
->signal
10371 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10374 /* Read TID from pr_pid. */
10375 elf_tdata (abfd
)->core
->lwpid
10376 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10379 /* Padding before pr_reg. */
10380 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10383 /* Make sure that there is enough data remaining in the note. */
10384 if ((note
->descsz
- offset
) < size
)
10387 /* Make a ".reg/999" section and a ".reg" section. */
10388 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10389 size
, note
->descpos
+ offset
);
10393 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10395 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10397 switch (note
->type
)
10400 if (bed
->elf_backend_grok_freebsd_prstatus
)
10401 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10403 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10406 return elfcore_grok_prfpreg (abfd
, note
);
10409 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10411 case NT_FREEBSD_THRMISC
:
10412 if (note
->namesz
== 8)
10413 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10417 case NT_FREEBSD_PROCSTAT_PROC
:
10418 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10421 case NT_FREEBSD_PROCSTAT_FILES
:
10422 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10425 case NT_FREEBSD_PROCSTAT_VMMAP
:
10426 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10429 case NT_FREEBSD_PROCSTAT_AUXV
:
10431 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
10436 sect
->size
= note
->descsz
- 4;
10437 sect
->filepos
= note
->descpos
+ 4;
10438 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10443 case NT_X86_XSTATE
:
10444 if (note
->namesz
== 8)
10445 return elfcore_grok_xstatereg (abfd
, note
);
10449 case NT_FREEBSD_PTLWPINFO
:
10450 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10454 return elfcore_grok_arm_vfp (abfd
, note
);
10462 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10466 cp
= strchr (note
->namedata
, '@');
10469 *lwpidp
= atoi(cp
+ 1);
10476 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10478 if (note
->descsz
<= 0x7c + 31)
10481 /* Signal number at offset 0x08. */
10482 elf_tdata (abfd
)->core
->signal
10483 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10485 /* Process ID at offset 0x50. */
10486 elf_tdata (abfd
)->core
->pid
10487 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10489 /* Command name at 0x7c (max 32 bytes, including nul). */
10490 elf_tdata (abfd
)->core
->command
10491 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10493 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10498 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10502 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10503 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10505 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
10507 /* NetBSD-specific core "procinfo". Note that we expect to
10508 find this note before any of the others, which is fine,
10509 since the kernel writes this note out first when it
10510 creates a core file. */
10512 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10515 /* As of Jan 2002 there are no other machine-independent notes
10516 defined for NetBSD core files. If the note type is less
10517 than the start of the machine-dependent note types, we don't
10520 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10524 switch (bfd_get_arch (abfd
))
10526 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10527 PT_GETFPREGS == mach+2. */
10529 case bfd_arch_alpha
:
10530 case bfd_arch_sparc
:
10531 switch (note
->type
)
10533 case NT_NETBSDCORE_FIRSTMACH
+0:
10534 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10536 case NT_NETBSDCORE_FIRSTMACH
+2:
10537 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10543 /* On all other arch's, PT_GETREGS == mach+1 and
10544 PT_GETFPREGS == mach+3. */
10547 switch (note
->type
)
10549 case NT_NETBSDCORE_FIRSTMACH
+1:
10550 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10552 case NT_NETBSDCORE_FIRSTMACH
+3:
10553 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10563 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10565 if (note
->descsz
<= 0x48 + 31)
10568 /* Signal number at offset 0x08. */
10569 elf_tdata (abfd
)->core
->signal
10570 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10572 /* Process ID at offset 0x20. */
10573 elf_tdata (abfd
)->core
->pid
10574 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
10576 /* Command name at 0x48 (max 32 bytes, including nul). */
10577 elf_tdata (abfd
)->core
->command
10578 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
10584 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10586 if (note
->type
== NT_OPENBSD_PROCINFO
)
10587 return elfcore_grok_openbsd_procinfo (abfd
, note
);
10589 if (note
->type
== NT_OPENBSD_REGS
)
10590 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10592 if (note
->type
== NT_OPENBSD_FPREGS
)
10593 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10595 if (note
->type
== NT_OPENBSD_XFPREGS
)
10596 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
10598 if (note
->type
== NT_OPENBSD_AUXV
)
10600 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
10605 sect
->size
= note
->descsz
;
10606 sect
->filepos
= note
->descpos
;
10607 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10612 if (note
->type
== NT_OPENBSD_WCOOKIE
)
10614 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
10619 sect
->size
= note
->descsz
;
10620 sect
->filepos
= note
->descpos
;
10621 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10630 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
10632 void *ddata
= note
->descdata
;
10639 if (note
->descsz
< 16)
10642 /* nto_procfs_status 'pid' field is at offset 0. */
10643 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
10645 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10646 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
10648 /* nto_procfs_status 'flags' field is at offset 8. */
10649 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
10651 /* nto_procfs_status 'what' field is at offset 14. */
10652 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
10654 elf_tdata (abfd
)->core
->signal
= sig
;
10655 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10658 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10659 do not come from signals so we make sure we set the current
10660 thread just in case. */
10661 if (flags
& 0x00000080)
10662 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10664 /* Make a ".qnx_core_status/%d" section. */
10665 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
10667 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10670 strcpy (name
, buf
);
10672 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10676 sect
->size
= note
->descsz
;
10677 sect
->filepos
= note
->descpos
;
10678 sect
->alignment_power
= 2;
10680 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
10684 elfcore_grok_nto_regs (bfd
*abfd
,
10685 Elf_Internal_Note
*note
,
10693 /* Make a "(base)/%d" section. */
10694 sprintf (buf
, "%s/%ld", base
, tid
);
10696 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10699 strcpy (name
, buf
);
10701 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10705 sect
->size
= note
->descsz
;
10706 sect
->filepos
= note
->descpos
;
10707 sect
->alignment_power
= 2;
10709 /* This is the current thread. */
10710 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
10711 return elfcore_maybe_make_sect (abfd
, base
, sect
);
10716 #define BFD_QNT_CORE_INFO 7
10717 #define BFD_QNT_CORE_STATUS 8
10718 #define BFD_QNT_CORE_GREG 9
10719 #define BFD_QNT_CORE_FPREG 10
10722 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10724 /* Every GREG section has a STATUS section before it. Store the
10725 tid from the previous call to pass down to the next gregs
10727 static long tid
= 1;
10729 switch (note
->type
)
10731 case BFD_QNT_CORE_INFO
:
10732 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
10733 case BFD_QNT_CORE_STATUS
:
10734 return elfcore_grok_nto_status (abfd
, note
, &tid
);
10735 case BFD_QNT_CORE_GREG
:
10736 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
10737 case BFD_QNT_CORE_FPREG
:
10738 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
10745 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10751 /* Use note name as section name. */
10752 len
= note
->namesz
;
10753 name
= (char *) bfd_alloc (abfd
, len
);
10756 memcpy (name
, note
->namedata
, len
);
10757 name
[len
- 1] = '\0';
10759 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10763 sect
->size
= note
->descsz
;
10764 sect
->filepos
= note
->descpos
;
10765 sect
->alignment_power
= 1;
10770 /* Function: elfcore_write_note
10773 buffer to hold note, and current size of buffer
10777 size of data for note
10779 Writes note to end of buffer. ELF64 notes are written exactly as
10780 for ELF32, despite the current (as of 2006) ELF gabi specifying
10781 that they ought to have 8-byte namesz and descsz field, and have
10782 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10785 Pointer to realloc'd buffer, *BUFSIZ updated. */
10788 elfcore_write_note (bfd
*abfd
,
10796 Elf_External_Note
*xnp
;
10803 namesz
= strlen (name
) + 1;
10805 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
10807 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
10810 dest
= buf
+ *bufsiz
;
10811 *bufsiz
+= newspace
;
10812 xnp
= (Elf_External_Note
*) dest
;
10813 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
10814 H_PUT_32 (abfd
, size
, xnp
->descsz
);
10815 H_PUT_32 (abfd
, type
, xnp
->type
);
10819 memcpy (dest
, name
, namesz
);
10827 memcpy (dest
, input
, size
);
10837 /* gcc-8 warns (*) on all the strncpy calls in this function about
10838 possible string truncation. The "truncation" is not a bug. We
10839 have an external representation of structs with fields that are not
10840 necessarily NULL terminated and corresponding internal
10841 representation fields that are one larger so that they can always
10842 be NULL terminated.
10843 gcc versions between 4.2 and 4.6 do not allow pragma control of
10844 diagnostics inside functions, giving a hard error if you try to use
10845 the finer control available with later versions.
10846 gcc prior to 4.2 warns about diagnostic push and pop.
10847 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
10848 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
10849 (*) Depending on your system header files! */
10850 #if GCC_VERSION >= 8000
10851 # pragma GCC diagnostic push
10852 # pragma GCC diagnostic ignored "-Wstringop-truncation"
10855 elfcore_write_prpsinfo (bfd
*abfd
,
10859 const char *psargs
)
10861 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10863 if (bed
->elf_backend_write_core_note
!= NULL
)
10866 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
10867 NT_PRPSINFO
, fname
, psargs
);
10872 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10873 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10874 if (bed
->s
->elfclass
== ELFCLASS32
)
10876 # if defined (HAVE_PSINFO32_T)
10878 int note_type
= NT_PSINFO
;
10881 int note_type
= NT_PRPSINFO
;
10884 memset (&data
, 0, sizeof (data
));
10885 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
10886 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
10887 return elfcore_write_note (abfd
, buf
, bufsiz
,
10888 "CORE", note_type
, &data
, sizeof (data
));
10893 # if defined (HAVE_PSINFO_T)
10895 int note_type
= NT_PSINFO
;
10898 int note_type
= NT_PRPSINFO
;
10901 memset (&data
, 0, sizeof (data
));
10902 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
10903 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
10904 return elfcore_write_note (abfd
, buf
, bufsiz
,
10905 "CORE", note_type
, &data
, sizeof (data
));
10907 #endif /* PSINFO_T or PRPSINFO_T */
10912 #if GCC_VERSION >= 8000
10913 # pragma GCC diagnostic pop
10917 elfcore_write_linux_prpsinfo32
10918 (bfd
*abfd
, char *buf
, int *bufsiz
,
10919 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
10921 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
10923 struct elf_external_linux_prpsinfo32_ugid16 data
;
10925 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
10926 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
10927 &data
, sizeof (data
));
10931 struct elf_external_linux_prpsinfo32_ugid32 data
;
10933 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
10934 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
10935 &data
, sizeof (data
));
10940 elfcore_write_linux_prpsinfo64
10941 (bfd
*abfd
, char *buf
, int *bufsiz
,
10942 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
10944 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
10946 struct elf_external_linux_prpsinfo64_ugid16 data
;
10948 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
10949 return elfcore_write_note (abfd
, buf
, bufsiz
,
10950 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
10954 struct elf_external_linux_prpsinfo64_ugid32 data
;
10956 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
10957 return elfcore_write_note (abfd
, buf
, bufsiz
,
10958 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
10963 elfcore_write_prstatus (bfd
*abfd
,
10970 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10972 if (bed
->elf_backend_write_core_note
!= NULL
)
10975 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
10977 pid
, cursig
, gregs
);
10982 #if defined (HAVE_PRSTATUS_T)
10983 #if defined (HAVE_PRSTATUS32_T)
10984 if (bed
->s
->elfclass
== ELFCLASS32
)
10986 prstatus32_t prstat
;
10988 memset (&prstat
, 0, sizeof (prstat
));
10989 prstat
.pr_pid
= pid
;
10990 prstat
.pr_cursig
= cursig
;
10991 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
10992 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
10993 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11000 memset (&prstat
, 0, sizeof (prstat
));
11001 prstat
.pr_pid
= pid
;
11002 prstat
.pr_cursig
= cursig
;
11003 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11004 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11005 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11007 #endif /* HAVE_PRSTATUS_T */
11013 #if defined (HAVE_LWPSTATUS_T)
11015 elfcore_write_lwpstatus (bfd
*abfd
,
11022 lwpstatus_t lwpstat
;
11023 const char *note_name
= "CORE";
11025 memset (&lwpstat
, 0, sizeof (lwpstat
));
11026 lwpstat
.pr_lwpid
= pid
>> 16;
11027 lwpstat
.pr_cursig
= cursig
;
11028 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11029 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11030 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11031 #if !defined(gregs)
11032 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11033 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11035 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11036 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11039 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11040 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11042 #endif /* HAVE_LWPSTATUS_T */
11044 #if defined (HAVE_PSTATUS_T)
11046 elfcore_write_pstatus (bfd
*abfd
,
11050 int cursig ATTRIBUTE_UNUSED
,
11051 const void *gregs ATTRIBUTE_UNUSED
)
11053 const char *note_name
= "CORE";
11054 #if defined (HAVE_PSTATUS32_T)
11055 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11057 if (bed
->s
->elfclass
== ELFCLASS32
)
11061 memset (&pstat
, 0, sizeof (pstat
));
11062 pstat
.pr_pid
= pid
& 0xffff;
11063 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11064 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11072 memset (&pstat
, 0, sizeof (pstat
));
11073 pstat
.pr_pid
= pid
& 0xffff;
11074 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11075 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11079 #endif /* HAVE_PSTATUS_T */
11082 elfcore_write_prfpreg (bfd
*abfd
,
11085 const void *fpregs
,
11088 const char *note_name
= "CORE";
11089 return elfcore_write_note (abfd
, buf
, bufsiz
,
11090 note_name
, NT_FPREGSET
, fpregs
, size
);
11094 elfcore_write_prxfpreg (bfd
*abfd
,
11097 const void *xfpregs
,
11100 char *note_name
= "LINUX";
11101 return elfcore_write_note (abfd
, buf
, bufsiz
,
11102 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11106 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11107 const void *xfpregs
, int size
)
11110 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11111 note_name
= "FreeBSD";
11113 note_name
= "LINUX";
11114 return elfcore_write_note (abfd
, buf
, bufsiz
,
11115 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11119 elfcore_write_ppc_vmx (bfd
*abfd
,
11122 const void *ppc_vmx
,
11125 char *note_name
= "LINUX";
11126 return elfcore_write_note (abfd
, buf
, bufsiz
,
11127 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11131 elfcore_write_ppc_vsx (bfd
*abfd
,
11134 const void *ppc_vsx
,
11137 char *note_name
= "LINUX";
11138 return elfcore_write_note (abfd
, buf
, bufsiz
,
11139 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11143 elfcore_write_ppc_tar (bfd
*abfd
,
11146 const void *ppc_tar
,
11149 char *note_name
= "LINUX";
11150 return elfcore_write_note (abfd
, buf
, bufsiz
,
11151 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11155 elfcore_write_ppc_ppr (bfd
*abfd
,
11158 const void *ppc_ppr
,
11161 char *note_name
= "LINUX";
11162 return elfcore_write_note (abfd
, buf
, bufsiz
,
11163 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11167 elfcore_write_ppc_dscr (bfd
*abfd
,
11170 const void *ppc_dscr
,
11173 char *note_name
= "LINUX";
11174 return elfcore_write_note (abfd
, buf
, bufsiz
,
11175 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11179 elfcore_write_ppc_ebb (bfd
*abfd
,
11182 const void *ppc_ebb
,
11185 char *note_name
= "LINUX";
11186 return elfcore_write_note (abfd
, buf
, bufsiz
,
11187 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11191 elfcore_write_ppc_pmu (bfd
*abfd
,
11194 const void *ppc_pmu
,
11197 char *note_name
= "LINUX";
11198 return elfcore_write_note (abfd
, buf
, bufsiz
,
11199 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11203 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11206 const void *ppc_tm_cgpr
,
11209 char *note_name
= "LINUX";
11210 return elfcore_write_note (abfd
, buf
, bufsiz
,
11211 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11215 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11218 const void *ppc_tm_cfpr
,
11221 char *note_name
= "LINUX";
11222 return elfcore_write_note (abfd
, buf
, bufsiz
,
11223 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11227 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11230 const void *ppc_tm_cvmx
,
11233 char *note_name
= "LINUX";
11234 return elfcore_write_note (abfd
, buf
, bufsiz
,
11235 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11239 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11242 const void *ppc_tm_cvsx
,
11245 char *note_name
= "LINUX";
11246 return elfcore_write_note (abfd
, buf
, bufsiz
,
11247 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11251 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11254 const void *ppc_tm_spr
,
11257 char *note_name
= "LINUX";
11258 return elfcore_write_note (abfd
, buf
, bufsiz
,
11259 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11263 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11266 const void *ppc_tm_ctar
,
11269 char *note_name
= "LINUX";
11270 return elfcore_write_note (abfd
, buf
, bufsiz
,
11271 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11275 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11278 const void *ppc_tm_cppr
,
11281 char *note_name
= "LINUX";
11282 return elfcore_write_note (abfd
, buf
, bufsiz
,
11283 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11287 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11290 const void *ppc_tm_cdscr
,
11293 char *note_name
= "LINUX";
11294 return elfcore_write_note (abfd
, buf
, bufsiz
,
11295 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11299 elfcore_write_s390_high_gprs (bfd
*abfd
,
11302 const void *s390_high_gprs
,
11305 char *note_name
= "LINUX";
11306 return elfcore_write_note (abfd
, buf
, bufsiz
,
11307 note_name
, NT_S390_HIGH_GPRS
,
11308 s390_high_gprs
, size
);
11312 elfcore_write_s390_timer (bfd
*abfd
,
11315 const void *s390_timer
,
11318 char *note_name
= "LINUX";
11319 return elfcore_write_note (abfd
, buf
, bufsiz
,
11320 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11324 elfcore_write_s390_todcmp (bfd
*abfd
,
11327 const void *s390_todcmp
,
11330 char *note_name
= "LINUX";
11331 return elfcore_write_note (abfd
, buf
, bufsiz
,
11332 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11336 elfcore_write_s390_todpreg (bfd
*abfd
,
11339 const void *s390_todpreg
,
11342 char *note_name
= "LINUX";
11343 return elfcore_write_note (abfd
, buf
, bufsiz
,
11344 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11348 elfcore_write_s390_ctrs (bfd
*abfd
,
11351 const void *s390_ctrs
,
11354 char *note_name
= "LINUX";
11355 return elfcore_write_note (abfd
, buf
, bufsiz
,
11356 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11360 elfcore_write_s390_prefix (bfd
*abfd
,
11363 const void *s390_prefix
,
11366 char *note_name
= "LINUX";
11367 return elfcore_write_note (abfd
, buf
, bufsiz
,
11368 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11372 elfcore_write_s390_last_break (bfd
*abfd
,
11375 const void *s390_last_break
,
11378 char *note_name
= "LINUX";
11379 return elfcore_write_note (abfd
, buf
, bufsiz
,
11380 note_name
, NT_S390_LAST_BREAK
,
11381 s390_last_break
, size
);
11385 elfcore_write_s390_system_call (bfd
*abfd
,
11388 const void *s390_system_call
,
11391 char *note_name
= "LINUX";
11392 return elfcore_write_note (abfd
, buf
, bufsiz
,
11393 note_name
, NT_S390_SYSTEM_CALL
,
11394 s390_system_call
, size
);
11398 elfcore_write_s390_tdb (bfd
*abfd
,
11401 const void *s390_tdb
,
11404 char *note_name
= "LINUX";
11405 return elfcore_write_note (abfd
, buf
, bufsiz
,
11406 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11410 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11413 const void *s390_vxrs_low
,
11416 char *note_name
= "LINUX";
11417 return elfcore_write_note (abfd
, buf
, bufsiz
,
11418 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11422 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11425 const void *s390_vxrs_high
,
11428 char *note_name
= "LINUX";
11429 return elfcore_write_note (abfd
, buf
, bufsiz
,
11430 note_name
, NT_S390_VXRS_HIGH
,
11431 s390_vxrs_high
, size
);
11435 elfcore_write_s390_gs_cb (bfd
*abfd
,
11438 const void *s390_gs_cb
,
11441 char *note_name
= "LINUX";
11442 return elfcore_write_note (abfd
, buf
, bufsiz
,
11443 note_name
, NT_S390_GS_CB
,
11448 elfcore_write_s390_gs_bc (bfd
*abfd
,
11451 const void *s390_gs_bc
,
11454 char *note_name
= "LINUX";
11455 return elfcore_write_note (abfd
, buf
, bufsiz
,
11456 note_name
, NT_S390_GS_BC
,
11461 elfcore_write_arm_vfp (bfd
*abfd
,
11464 const void *arm_vfp
,
11467 char *note_name
= "LINUX";
11468 return elfcore_write_note (abfd
, buf
, bufsiz
,
11469 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11473 elfcore_write_aarch_tls (bfd
*abfd
,
11476 const void *aarch_tls
,
11479 char *note_name
= "LINUX";
11480 return elfcore_write_note (abfd
, buf
, bufsiz
,
11481 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11485 elfcore_write_aarch_hw_break (bfd
*abfd
,
11488 const void *aarch_hw_break
,
11491 char *note_name
= "LINUX";
11492 return elfcore_write_note (abfd
, buf
, bufsiz
,
11493 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11497 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11500 const void *aarch_hw_watch
,
11503 char *note_name
= "LINUX";
11504 return elfcore_write_note (abfd
, buf
, bufsiz
,
11505 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11509 elfcore_write_aarch_sve (bfd
*abfd
,
11512 const void *aarch_sve
,
11515 char *note_name
= "LINUX";
11516 return elfcore_write_note (abfd
, buf
, bufsiz
,
11517 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11521 elfcore_write_aarch_pauth (bfd
*abfd
,
11524 const void *aarch_pauth
,
11527 char *note_name
= "LINUX";
11528 return elfcore_write_note (abfd
, buf
, bufsiz
,
11529 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11533 elfcore_write_register_note (bfd
*abfd
,
11536 const char *section
,
11540 if (strcmp (section
, ".reg2") == 0)
11541 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
11542 if (strcmp (section
, ".reg-xfp") == 0)
11543 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
11544 if (strcmp (section
, ".reg-xstate") == 0)
11545 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
11546 if (strcmp (section
, ".reg-ppc-vmx") == 0)
11547 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
11548 if (strcmp (section
, ".reg-ppc-vsx") == 0)
11549 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
11550 if (strcmp (section
, ".reg-ppc-tar") == 0)
11551 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
11552 if (strcmp (section
, ".reg-ppc-ppr") == 0)
11553 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
11554 if (strcmp (section
, ".reg-ppc-dscr") == 0)
11555 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
11556 if (strcmp (section
, ".reg-ppc-ebb") == 0)
11557 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
11558 if (strcmp (section
, ".reg-ppc-pmu") == 0)
11559 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
11560 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
11561 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
11562 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
11563 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
11564 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
11565 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
11566 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
11567 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
11568 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
11569 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
11570 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
11571 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
11572 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
11573 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
11574 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
11575 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
11576 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
11577 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
11578 if (strcmp (section
, ".reg-s390-timer") == 0)
11579 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
11580 if (strcmp (section
, ".reg-s390-todcmp") == 0)
11581 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
11582 if (strcmp (section
, ".reg-s390-todpreg") == 0)
11583 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
11584 if (strcmp (section
, ".reg-s390-ctrs") == 0)
11585 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
11586 if (strcmp (section
, ".reg-s390-prefix") == 0)
11587 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
11588 if (strcmp (section
, ".reg-s390-last-break") == 0)
11589 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
11590 if (strcmp (section
, ".reg-s390-system-call") == 0)
11591 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
11592 if (strcmp (section
, ".reg-s390-tdb") == 0)
11593 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
11594 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
11595 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
11596 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
11597 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
11598 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
11599 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
11600 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
11601 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
11602 if (strcmp (section
, ".reg-arm-vfp") == 0)
11603 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
11604 if (strcmp (section
, ".reg-aarch-tls") == 0)
11605 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
11606 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
11607 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
11608 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
11609 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
11610 if (strcmp (section
, ".reg-aarch-sve") == 0)
11611 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
11612 if (strcmp (section
, ".reg-aarch-pauth") == 0)
11613 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
11618 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
11623 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11624 gABI specifies that PT_NOTE alignment should be aligned to 4
11625 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11626 align is less than 4, we use 4 byte alignment. */
11629 if (align
!= 4 && align
!= 8)
11633 while (p
< buf
+ size
)
11635 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
11636 Elf_Internal_Note in
;
11638 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
11641 in
.type
= H_GET_32 (abfd
, xnp
->type
);
11643 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
11644 in
.namedata
= xnp
->name
;
11645 if (in
.namesz
> buf
- in
.namedata
+ size
)
11648 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
11649 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
11650 in
.descpos
= offset
+ (in
.descdata
- buf
);
11652 && (in
.descdata
>= buf
+ size
11653 || in
.descsz
> buf
- in
.descdata
+ size
))
11656 switch (bfd_get_format (abfd
))
11663 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11666 const char * string
;
11668 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
11672 GROKER_ELEMENT ("", elfcore_grok_note
),
11673 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
11674 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
11675 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
11676 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
11677 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
)
11679 #undef GROKER_ELEMENT
11682 for (i
= ARRAY_SIZE (grokers
); i
--;)
11684 if (in
.namesz
>= grokers
[i
].len
11685 && strncmp (in
.namedata
, grokers
[i
].string
,
11686 grokers
[i
].len
) == 0)
11688 if (! grokers
[i
].func (abfd
, & in
))
11697 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
11699 if (! elfobj_grok_gnu_note (abfd
, &in
))
11702 else if (in
.namesz
== sizeof "stapsdt"
11703 && strcmp (in
.namedata
, "stapsdt") == 0)
11705 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
11711 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
11718 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
11723 if (size
== 0 || (size
+ 1) == 0)
11726 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
11729 buf
= (char *) bfd_malloc (size
+ 1);
11733 /* PR 17512: file: ec08f814
11734 0-termintate the buffer so that string searches will not overflow. */
11737 if (bfd_bread (buf
, size
, abfd
) != size
11738 || !elf_parse_notes (abfd
, buf
, size
, offset
, align
))
11748 /* Providing external access to the ELF program header table. */
11750 /* Return an upper bound on the number of bytes required to store a
11751 copy of ABFD's program header table entries. Return -1 if an error
11752 occurs; bfd_get_error will return an appropriate code. */
11755 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
11757 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11759 bfd_set_error (bfd_error_wrong_format
);
11763 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
11766 /* Copy ABFD's program header table entries to *PHDRS. The entries
11767 will be stored as an array of Elf_Internal_Phdr structures, as
11768 defined in include/elf/internal.h. To find out how large the
11769 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11771 Return the number of program header table entries read, or -1 if an
11772 error occurs; bfd_get_error will return an appropriate code. */
11775 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
11779 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11781 bfd_set_error (bfd_error_wrong_format
);
11785 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
11786 if (num_phdrs
!= 0)
11787 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
11788 num_phdrs
* sizeof (Elf_Internal_Phdr
));
11793 enum elf_reloc_type_class
11794 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11795 const asection
*rel_sec ATTRIBUTE_UNUSED
,
11796 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
11798 return reloc_class_normal
;
11801 /* For RELA architectures, return the relocation value for a
11802 relocation against a local symbol. */
11805 _bfd_elf_rela_local_sym (bfd
*abfd
,
11806 Elf_Internal_Sym
*sym
,
11808 Elf_Internal_Rela
*rel
)
11810 asection
*sec
= *psec
;
11811 bfd_vma relocation
;
11813 relocation
= (sec
->output_section
->vma
11814 + sec
->output_offset
11816 if ((sec
->flags
& SEC_MERGE
)
11817 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
11818 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
11821 _bfd_merged_section_offset (abfd
, psec
,
11822 elf_section_data (sec
)->sec_info
,
11823 sym
->st_value
+ rel
->r_addend
);
11826 /* If we have changed the section, and our original section is
11827 marked with SEC_EXCLUDE, it means that the original
11828 SEC_MERGE section has been completely subsumed in some
11829 other SEC_MERGE section. In this case, we need to leave
11830 some info around for --emit-relocs. */
11831 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
11832 sec
->kept_section
= *psec
;
11835 rel
->r_addend
-= relocation
;
11836 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
11842 _bfd_elf_rel_local_sym (bfd
*abfd
,
11843 Elf_Internal_Sym
*sym
,
11847 asection
*sec
= *psec
;
11849 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
11850 return sym
->st_value
+ addend
;
11852 return _bfd_merged_section_offset (abfd
, psec
,
11853 elf_section_data (sec
)->sec_info
,
11854 sym
->st_value
+ addend
);
11857 /* Adjust an address within a section. Given OFFSET within SEC, return
11858 the new offset within the section, based upon changes made to the
11859 section. Returns -1 if the offset is now invalid.
11860 The offset (in abnd out) is in target sized bytes, however big a
11864 _bfd_elf_section_offset (bfd
*abfd
,
11865 struct bfd_link_info
*info
,
11869 switch (sec
->sec_info_type
)
11871 case SEC_INFO_TYPE_STABS
:
11872 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
11874 case SEC_INFO_TYPE_EH_FRAME
:
11875 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
11878 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
11880 /* Reverse the offset. */
11881 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11882 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
11884 /* address_size and sec->size are in octets. Convert
11885 to bytes before subtracting the original offset. */
11886 offset
= (sec
->size
- address_size
) / bfd_octets_per_byte (abfd
) - offset
;
11892 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
11893 reconstruct an ELF file by reading the segments out of remote memory
11894 based on the ELF file header at EHDR_VMA and the ELF program headers it
11895 points to. If not null, *LOADBASEP is filled in with the difference
11896 between the VMAs from which the segments were read, and the VMAs the
11897 file headers (and hence BFD's idea of each section's VMA) put them at.
11899 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11900 remote memory at target address VMA into the local buffer at MYADDR; it
11901 should return zero on success or an `errno' code on failure. TEMPL must
11902 be a BFD for an ELF target with the word size and byte order found in
11903 the remote memory. */
11906 bfd_elf_bfd_from_remote_memory
11909 bfd_size_type size
,
11910 bfd_vma
*loadbasep
,
11911 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
11913 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
11914 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
11918 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
11919 long symcount ATTRIBUTE_UNUSED
,
11920 asymbol
**syms ATTRIBUTE_UNUSED
,
11925 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11928 const char *relplt_name
;
11929 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
11933 Elf_Internal_Shdr
*hdr
;
11939 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
11942 if (dynsymcount
<= 0)
11945 if (!bed
->plt_sym_val
)
11948 relplt_name
= bed
->relplt_name
;
11949 if (relplt_name
== NULL
)
11950 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
11951 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
11952 if (relplt
== NULL
)
11955 hdr
= &elf_section_data (relplt
)->this_hdr
;
11956 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
11957 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
11960 plt
= bfd_get_section_by_name (abfd
, ".plt");
11964 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
11965 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
11968 count
= relplt
->size
/ hdr
->sh_entsize
;
11969 size
= count
* sizeof (asymbol
);
11970 p
= relplt
->relocation
;
11971 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
11973 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
11974 if (p
->addend
!= 0)
11977 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
11979 size
+= sizeof ("+0x") - 1 + 8;
11984 s
= *ret
= (asymbol
*) bfd_malloc (size
);
11988 names
= (char *) (s
+ count
);
11989 p
= relplt
->relocation
;
11991 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
11996 addr
= bed
->plt_sym_val (i
, plt
, p
);
11997 if (addr
== (bfd_vma
) -1)
12000 *s
= **p
->sym_ptr_ptr
;
12001 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12002 we are defining a symbol, ensure one of them is set. */
12003 if ((s
->flags
& BSF_LOCAL
) == 0)
12004 s
->flags
|= BSF_GLOBAL
;
12005 s
->flags
|= BSF_SYNTHETIC
;
12007 s
->value
= addr
- plt
->vma
;
12010 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12011 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12013 if (p
->addend
!= 0)
12017 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12018 names
+= sizeof ("+0x") - 1;
12019 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12020 for (a
= buf
; *a
== '0'; ++a
)
12023 memcpy (names
, a
, len
);
12026 memcpy (names
, "@plt", sizeof ("@plt"));
12027 names
+= sizeof ("@plt");
12034 /* It is only used by x86-64 so far.
12035 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12036 but current usage would allow all of _bfd_std_section to be zero. */
12037 static const asymbol lcomm_sym
12038 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12039 asection _bfd_elf_large_com_section
12040 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12041 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12044 _bfd_elf_post_process_headers (bfd
* abfd
,
12045 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
12047 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
12049 i_ehdrp
= elf_elfheader (abfd
);
12051 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12053 /* To make things simpler for the loader on Linux systems we set the
12054 osabi field to ELFOSABI_GNU if the binary contains symbols of
12055 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
12056 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
12057 && elf_tdata (abfd
)->has_gnu_symbols
)
12058 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12062 /* Return TRUE for ELF symbol types that represent functions.
12063 This is the default version of this function, which is sufficient for
12064 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12067 _bfd_elf_is_function_type (unsigned int type
)
12069 return (type
== STT_FUNC
12070 || type
== STT_GNU_IFUNC
);
12073 /* If the ELF symbol SYM might be a function in SEC, return the
12074 function size and set *CODE_OFF to the function's entry point,
12075 otherwise return zero. */
12078 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12081 bfd_size_type size
;
12083 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12084 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12085 || sym
->section
!= sec
)
12088 *code_off
= sym
->value
;
12090 if (!(sym
->flags
& BSF_SYNTHETIC
))
12091 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;