1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2020 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
swap_out_syms (bfd
*, struct elf_strtab_hash
**, int) ;
55 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
56 file_ptr offset
, size_t align
);
58 /* Swap version information in and out. The version information is
59 currently size independent. If that ever changes, this code will
60 need to move into elfcode.h. */
62 /* Swap in a Verdef structure. */
65 _bfd_elf_swap_verdef_in (bfd
*abfd
,
66 const Elf_External_Verdef
*src
,
67 Elf_Internal_Verdef
*dst
)
69 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
70 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
71 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
72 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
73 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
74 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
75 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (bfd
*abfd
,
82 const Elf_Internal_Verdef
*src
,
83 Elf_External_Verdef
*dst
)
85 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
86 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
87 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
88 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
89 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
90 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
91 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
94 /* Swap in a Verdaux structure. */
97 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
98 const Elf_External_Verdaux
*src
,
99 Elf_Internal_Verdaux
*dst
)
101 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
102 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
105 /* Swap out a Verdaux structure. */
108 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
109 const Elf_Internal_Verdaux
*src
,
110 Elf_External_Verdaux
*dst
)
112 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
113 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
116 /* Swap in a Verneed structure. */
119 _bfd_elf_swap_verneed_in (bfd
*abfd
,
120 const Elf_External_Verneed
*src
,
121 Elf_Internal_Verneed
*dst
)
123 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
124 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
125 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
126 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
127 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
130 /* Swap out a Verneed structure. */
133 _bfd_elf_swap_verneed_out (bfd
*abfd
,
134 const Elf_Internal_Verneed
*src
,
135 Elf_External_Verneed
*dst
)
137 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
138 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
139 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
140 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
141 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
144 /* Swap in a Vernaux structure. */
147 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
148 const Elf_External_Vernaux
*src
,
149 Elf_Internal_Vernaux
*dst
)
151 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
152 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
153 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
154 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
155 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
158 /* Swap out a Vernaux structure. */
161 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
162 const Elf_Internal_Vernaux
*src
,
163 Elf_External_Vernaux
*dst
)
165 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
166 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
167 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
168 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
169 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
172 /* Swap in a Versym structure. */
175 _bfd_elf_swap_versym_in (bfd
*abfd
,
176 const Elf_External_Versym
*src
,
177 Elf_Internal_Versym
*dst
)
179 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
182 /* Swap out a Versym structure. */
185 _bfd_elf_swap_versym_out (bfd
*abfd
,
186 const Elf_Internal_Versym
*src
,
187 Elf_External_Versym
*dst
)
189 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
192 /* Standard ELF hash function. Do not change this function; you will
193 cause invalid hash tables to be generated. */
196 bfd_elf_hash (const char *namearg
)
198 const unsigned char *name
= (const unsigned char *) namearg
;
203 while ((ch
= *name
++) != '\0')
206 if ((g
= (h
& 0xf0000000)) != 0)
209 /* The ELF ABI says `h &= ~g', but this is equivalent in
210 this case and on some machines one insn instead of two. */
214 return h
& 0xffffffff;
217 /* DT_GNU_HASH hash function. Do not change this function; you will
218 cause invalid hash tables to be generated. */
221 bfd_elf_gnu_hash (const char *namearg
)
223 const unsigned char *name
= (const unsigned char *) namearg
;
224 unsigned long h
= 5381;
227 while ((ch
= *name
++) != '\0')
228 h
= (h
<< 5) + h
+ ch
;
229 return h
& 0xffffffff;
232 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
233 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
235 bfd_elf_allocate_object (bfd
*abfd
,
237 enum elf_target_id object_id
)
239 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
240 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
241 if (abfd
->tdata
.any
== NULL
)
244 elf_object_id (abfd
) = object_id
;
245 if (abfd
->direction
!= read_direction
)
247 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
250 elf_tdata (abfd
)->o
= o
;
251 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
258 bfd_elf_make_object (bfd
*abfd
)
260 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
261 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
266 bfd_elf_mkcorefile (bfd
*abfd
)
268 /* I think this can be done just like an object file. */
269 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
271 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
272 return elf_tdata (abfd
)->core
!= NULL
;
276 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
278 Elf_Internal_Shdr
**i_shdrp
;
279 bfd_byte
*shstrtab
= NULL
;
281 bfd_size_type shstrtabsize
;
283 i_shdrp
= elf_elfsections (abfd
);
285 || shindex
>= elf_numsections (abfd
)
286 || i_shdrp
[shindex
] == 0)
289 shstrtab
= i_shdrp
[shindex
]->contents
;
290 if (shstrtab
== NULL
)
292 /* No cached one, attempt to read, and cache what we read. */
293 offset
= i_shdrp
[shindex
]->sh_offset
;
294 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
296 /* Allocate and clear an extra byte at the end, to prevent crashes
297 in case the string table is not terminated. */
298 if (shstrtabsize
+ 1 <= 1
299 || shstrtabsize
> bfd_get_file_size (abfd
)
300 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
301 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
)
303 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
305 if (bfd_get_error () != bfd_error_system_call
)
306 bfd_set_error (bfd_error_file_truncated
);
307 bfd_release (abfd
, shstrtab
);
309 /* Once we've failed to read it, make sure we don't keep
310 trying. Otherwise, we'll keep allocating space for
311 the string table over and over. */
312 i_shdrp
[shindex
]->sh_size
= 0;
315 shstrtab
[shstrtabsize
] = '\0';
316 i_shdrp
[shindex
]->contents
= shstrtab
;
318 return (char *) shstrtab
;
322 bfd_elf_string_from_elf_section (bfd
*abfd
,
323 unsigned int shindex
,
324 unsigned int strindex
)
326 Elf_Internal_Shdr
*hdr
;
331 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
334 hdr
= elf_elfsections (abfd
)[shindex
];
336 if (hdr
->contents
== NULL
)
338 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
340 /* PR 17512: file: f057ec89. */
341 /* xgettext:c-format */
342 _bfd_error_handler (_("%pB: attempt to load strings from"
343 " a non-string section (number %d)"),
348 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
353 /* PR 24273: The string section's contents may have already
354 been loaded elsewhere, eg because a corrupt file has the
355 string section index in the ELF header pointing at a group
356 section. So be paranoid, and test that the last byte of
357 the section is zero. */
358 if (hdr
->sh_size
== 0 || hdr
->contents
[hdr
->sh_size
- 1] != 0)
362 if (strindex
>= hdr
->sh_size
)
364 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
366 /* xgettext:c-format */
367 (_("%pB: invalid string offset %u >= %" PRIu64
" for section `%s'"),
368 abfd
, strindex
, (uint64_t) hdr
->sh_size
,
369 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
371 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
375 return ((char *) hdr
->contents
) + strindex
;
378 /* Read and convert symbols to internal format.
379 SYMCOUNT specifies the number of symbols to read, starting from
380 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
381 are non-NULL, they are used to store the internal symbols, external
382 symbols, and symbol section index extensions, respectively.
383 Returns a pointer to the internal symbol buffer (malloced if necessary)
384 or NULL if there were no symbols or some kind of problem. */
387 bfd_elf_get_elf_syms (bfd
*ibfd
,
388 Elf_Internal_Shdr
*symtab_hdr
,
391 Elf_Internal_Sym
*intsym_buf
,
393 Elf_External_Sym_Shndx
*extshndx_buf
)
395 Elf_Internal_Shdr
*shndx_hdr
;
397 const bfd_byte
*esym
;
398 Elf_External_Sym_Shndx
*alloc_extshndx
;
399 Elf_External_Sym_Shndx
*shndx
;
400 Elf_Internal_Sym
*alloc_intsym
;
401 Elf_Internal_Sym
*isym
;
402 Elf_Internal_Sym
*isymend
;
403 const struct elf_backend_data
*bed
;
408 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
414 /* Normal syms might have section extension entries. */
416 if (elf_symtab_shndx_list (ibfd
) != NULL
)
418 elf_section_list
* entry
;
419 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
421 /* Find an index section that is linked to this symtab section. */
422 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
425 if (entry
->hdr
.sh_link
>= elf_numsections (ibfd
))
428 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
430 shndx_hdr
= & entry
->hdr
;
435 if (shndx_hdr
== NULL
)
437 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
438 /* Not really accurate, but this was how the old code used to work. */
439 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
440 /* Otherwise we do nothing. The assumption is that
441 the index table will not be needed. */
445 /* Read the symbols. */
447 alloc_extshndx
= NULL
;
449 bed
= get_elf_backend_data (ibfd
);
450 extsym_size
= bed
->s
->sizeof_sym
;
451 amt
= (bfd_size_type
) symcount
* extsym_size
;
452 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
453 if (extsym_buf
== NULL
)
455 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
456 extsym_buf
= alloc_ext
;
458 if (extsym_buf
== NULL
459 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
460 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
466 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
470 amt
= (bfd_size_type
) symcount
* sizeof (Elf_External_Sym_Shndx
);
471 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
472 if (extshndx_buf
== NULL
)
474 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
475 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
476 extshndx_buf
= alloc_extshndx
;
478 if (extshndx_buf
== NULL
479 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
480 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
487 if (intsym_buf
== NULL
)
489 alloc_intsym
= (Elf_Internal_Sym
*)
490 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
491 intsym_buf
= alloc_intsym
;
492 if (intsym_buf
== NULL
)
496 /* Convert the symbols to internal form. */
497 isymend
= intsym_buf
+ symcount
;
498 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
499 shndx
= extshndx_buf
;
501 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
502 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
504 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
505 /* xgettext:c-format */
506 _bfd_error_handler (_("%pB symbol number %lu references"
507 " nonexistent SHT_SYMTAB_SHNDX section"),
508 ibfd
, (unsigned long) symoffset
);
509 if (alloc_intsym
!= NULL
)
516 if (alloc_ext
!= NULL
)
518 if (alloc_extshndx
!= NULL
)
519 free (alloc_extshndx
);
524 /* Look up a symbol name. */
526 bfd_elf_sym_name (bfd
*abfd
,
527 Elf_Internal_Shdr
*symtab_hdr
,
528 Elf_Internal_Sym
*isym
,
532 unsigned int iname
= isym
->st_name
;
533 unsigned int shindex
= symtab_hdr
->sh_link
;
535 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
536 /* Check for a bogus st_shndx to avoid crashing. */
537 && isym
->st_shndx
< elf_numsections (abfd
))
539 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
540 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
543 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
546 else if (sym_sec
&& *name
== '\0')
547 name
= bfd_section_name (sym_sec
);
552 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
553 sections. The first element is the flags, the rest are section
556 typedef union elf_internal_group
{
557 Elf_Internal_Shdr
*shdr
;
559 } Elf_Internal_Group
;
561 /* Return the name of the group signature symbol. Why isn't the
562 signature just a string? */
565 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
567 Elf_Internal_Shdr
*hdr
;
568 unsigned char esym
[sizeof (Elf64_External_Sym
)];
569 Elf_External_Sym_Shndx eshndx
;
570 Elf_Internal_Sym isym
;
572 /* First we need to ensure the symbol table is available. Make sure
573 that it is a symbol table section. */
574 if (ghdr
->sh_link
>= elf_numsections (abfd
))
576 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
577 if (hdr
->sh_type
!= SHT_SYMTAB
578 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
581 /* Go read the symbol. */
582 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
583 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
584 &isym
, esym
, &eshndx
) == NULL
)
587 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
590 /* Set next_in_group list pointer, and group name for NEWSECT. */
593 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
595 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
597 /* If num_group is zero, read in all SHT_GROUP sections. The count
598 is set to -1 if there are no SHT_GROUP sections. */
601 unsigned int i
, shnum
;
603 /* First count the number of groups. If we have a SHT_GROUP
604 section with just a flag word (ie. sh_size is 4), ignore it. */
605 shnum
= elf_numsections (abfd
);
608 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
609 ( (shdr)->sh_type == SHT_GROUP \
610 && (shdr)->sh_size >= minsize \
611 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
612 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
614 for (i
= 0; i
< shnum
; i
++)
616 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
618 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
624 num_group
= (unsigned) -1;
625 elf_tdata (abfd
)->num_group
= num_group
;
626 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
630 /* We keep a list of elf section headers for group sections,
631 so we can find them quickly. */
634 elf_tdata (abfd
)->num_group
= num_group
;
635 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
636 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
637 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
639 memset (elf_tdata (abfd
)->group_sect_ptr
, 0,
640 num_group
* sizeof (Elf_Internal_Shdr
*));
643 for (i
= 0; i
< shnum
; i
++)
645 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
647 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
650 Elf_Internal_Group
*dest
;
652 /* Make sure the group section has a BFD section
654 if (!bfd_section_from_shdr (abfd
, i
))
657 /* Add to list of sections. */
658 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
661 /* Read the raw contents. */
662 BFD_ASSERT (sizeof (*dest
) >= 4);
663 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
664 shdr
->contents
= (unsigned char *)
665 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
666 /* PR binutils/4110: Handle corrupt group headers. */
667 if (shdr
->contents
== NULL
)
670 /* xgettext:c-format */
671 (_("%pB: corrupt size field in group section"
672 " header: %#" PRIx64
),
673 abfd
, (uint64_t) shdr
->sh_size
);
674 bfd_set_error (bfd_error_bad_value
);
679 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
680 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
684 /* xgettext:c-format */
685 (_("%pB: invalid size field in group section"
686 " header: %#" PRIx64
""),
687 abfd
, (uint64_t) shdr
->sh_size
);
688 bfd_set_error (bfd_error_bad_value
);
690 /* PR 17510: If the group contents are even
691 partially corrupt, do not allow any of the
692 contents to be used. */
693 bfd_release (abfd
, shdr
->contents
);
694 shdr
->contents
= NULL
;
698 /* Translate raw contents, a flag word followed by an
699 array of elf section indices all in target byte order,
700 to the flag word followed by an array of elf section
702 src
= shdr
->contents
+ shdr
->sh_size
;
703 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
711 idx
= H_GET_32 (abfd
, src
);
712 if (src
== shdr
->contents
)
716 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
717 shdr
->bfd_section
->flags
718 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
723 dest
->shdr
= elf_elfsections (abfd
)[idx
];
724 /* PR binutils/23199: All sections in a
725 section group should be marked with
726 SHF_GROUP. But some tools generate
727 broken objects without SHF_GROUP. Fix
729 dest
->shdr
->sh_flags
|= SHF_GROUP
;
732 || dest
->shdr
->sh_type
== SHT_GROUP
)
735 (_("%pB: invalid entry in SHT_GROUP section [%u]"),
743 /* PR 17510: Corrupt binaries might contain invalid groups. */
744 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
746 elf_tdata (abfd
)->num_group
= num_group
;
748 /* If all groups are invalid then fail. */
751 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
752 elf_tdata (abfd
)->num_group
= num_group
= -1;
754 (_("%pB: no valid group sections found"), abfd
);
755 bfd_set_error (bfd_error_bad_value
);
761 if (num_group
!= (unsigned) -1)
763 unsigned int search_offset
= elf_tdata (abfd
)->group_search_offset
;
766 for (j
= 0; j
< num_group
; j
++)
768 /* Begin search from previous found group. */
769 unsigned i
= (j
+ search_offset
) % num_group
;
771 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
772 Elf_Internal_Group
*idx
;
778 idx
= (Elf_Internal_Group
*) shdr
->contents
;
779 if (idx
== NULL
|| shdr
->sh_size
< 4)
781 /* See PR 21957 for a reproducer. */
782 /* xgettext:c-format */
783 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
784 abfd
, shdr
->bfd_section
);
785 elf_tdata (abfd
)->group_sect_ptr
[i
] = NULL
;
786 bfd_set_error (bfd_error_bad_value
);
789 n_elt
= shdr
->sh_size
/ 4;
791 /* Look through this group's sections to see if current
792 section is a member. */
794 if ((++idx
)->shdr
== hdr
)
798 /* We are a member of this group. Go looking through
799 other members to see if any others are linked via
801 idx
= (Elf_Internal_Group
*) shdr
->contents
;
802 n_elt
= shdr
->sh_size
/ 4;
804 if ((++idx
)->shdr
!= NULL
805 && (s
= idx
->shdr
->bfd_section
) != NULL
806 && elf_next_in_group (s
) != NULL
)
810 /* Snarf the group name from other member, and
811 insert current section in circular list. */
812 elf_group_name (newsect
) = elf_group_name (s
);
813 elf_next_in_group (newsect
) = elf_next_in_group (s
);
814 elf_next_in_group (s
) = newsect
;
820 gname
= group_signature (abfd
, shdr
);
823 elf_group_name (newsect
) = gname
;
825 /* Start a circular list with one element. */
826 elf_next_in_group (newsect
) = newsect
;
829 /* If the group section has been created, point to the
831 if (shdr
->bfd_section
!= NULL
)
832 elf_next_in_group (shdr
->bfd_section
) = newsect
;
834 elf_tdata (abfd
)->group_search_offset
= i
;
841 if (elf_group_name (newsect
) == NULL
)
843 /* xgettext:c-format */
844 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
852 _bfd_elf_setup_sections (bfd
*abfd
)
855 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
856 bfd_boolean result
= TRUE
;
859 /* Process SHF_LINK_ORDER. */
860 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
862 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
863 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
865 unsigned int elfsec
= this_hdr
->sh_link
;
866 /* FIXME: The old Intel compiler and old strip/objcopy may
867 not set the sh_link or sh_info fields. Hence we could
868 get the situation where elfsec is 0. */
871 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
872 if (bed
->link_order_error_handler
)
873 bed
->link_order_error_handler
874 /* xgettext:c-format */
875 (_("%pB: warning: sh_link not set for section `%pA'"),
880 asection
*linksec
= NULL
;
882 if (elfsec
< elf_numsections (abfd
))
884 this_hdr
= elf_elfsections (abfd
)[elfsec
];
885 linksec
= this_hdr
->bfd_section
;
889 Some strip/objcopy may leave an incorrect value in
890 sh_link. We don't want to proceed. */
894 /* xgettext:c-format */
895 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
896 s
->owner
, elfsec
, s
);
900 elf_linked_to_section (s
) = linksec
;
903 else if (this_hdr
->sh_type
== SHT_GROUP
904 && elf_next_in_group (s
) == NULL
)
907 /* xgettext:c-format */
908 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
909 abfd
, elf_section_data (s
)->this_idx
);
914 /* Process section groups. */
915 if (num_group
== (unsigned) -1)
918 for (i
= 0; i
< num_group
; i
++)
920 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
921 Elf_Internal_Group
*idx
;
924 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
925 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
928 /* xgettext:c-format */
929 (_("%pB: section group entry number %u is corrupt"),
935 idx
= (Elf_Internal_Group
*) shdr
->contents
;
936 n_elt
= shdr
->sh_size
/ 4;
942 if (idx
->shdr
== NULL
)
944 else if (idx
->shdr
->bfd_section
)
945 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
946 else if (idx
->shdr
->sh_type
!= SHT_RELA
947 && idx
->shdr
->sh_type
!= SHT_REL
)
949 /* There are some unknown sections in the group. */
951 /* xgettext:c-format */
952 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
955 bfd_elf_string_from_elf_section (abfd
,
956 (elf_elfheader (abfd
)
969 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
971 return elf_next_in_group (sec
) != NULL
;
975 bfd_elf_group_name (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
977 if (elf_sec_group (sec
) != NULL
)
978 return elf_group_name (sec
);
983 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
985 unsigned int len
= strlen (name
);
986 char *new_name
= bfd_alloc (abfd
, len
+ 2);
987 if (new_name
== NULL
)
991 memcpy (new_name
+ 2, name
+ 1, len
);
996 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
998 unsigned int len
= strlen (name
);
999 char *new_name
= bfd_alloc (abfd
, len
);
1000 if (new_name
== NULL
)
1003 memcpy (new_name
+ 1, name
+ 2, len
- 1);
1007 /* This a copy of lto_section defined in GCC (lto-streamer.h). */
1011 int16_t major_version
;
1012 int16_t minor_version
;
1013 unsigned char slim_object
;
1015 /* Flags is a private field that is not defined publicly. */
1019 /* Make a BFD section from an ELF section. We store a pointer to the
1020 BFD section in the bfd_section field of the header. */
1023 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
1024 Elf_Internal_Shdr
*hdr
,
1030 const struct elf_backend_data
*bed
;
1032 if (hdr
->bfd_section
!= NULL
)
1035 newsect
= bfd_make_section_anyway (abfd
, name
);
1036 if (newsect
== NULL
)
1039 hdr
->bfd_section
= newsect
;
1040 elf_section_data (newsect
)->this_hdr
= *hdr
;
1041 elf_section_data (newsect
)->this_idx
= shindex
;
1043 /* Always use the real type/flags. */
1044 elf_section_type (newsect
) = hdr
->sh_type
;
1045 elf_section_flags (newsect
) = hdr
->sh_flags
;
1047 newsect
->filepos
= hdr
->sh_offset
;
1049 if (!bfd_set_section_vma (newsect
, hdr
->sh_addr
)
1050 || !bfd_set_section_size (newsect
, hdr
->sh_size
)
1051 || !bfd_set_section_alignment (newsect
, bfd_log2 (hdr
->sh_addralign
)))
1054 flags
= SEC_NO_FLAGS
;
1055 if (hdr
->sh_type
!= SHT_NOBITS
)
1056 flags
|= SEC_HAS_CONTENTS
;
1057 if (hdr
->sh_type
== SHT_GROUP
)
1059 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1062 if (hdr
->sh_type
!= SHT_NOBITS
)
1065 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
1066 flags
|= SEC_READONLY
;
1067 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1069 else if ((flags
& SEC_LOAD
) != 0)
1071 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
1074 newsect
->entsize
= hdr
->sh_entsize
;
1076 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
1077 flags
|= SEC_STRINGS
;
1078 if (hdr
->sh_flags
& SHF_GROUP
)
1079 if (!setup_group (abfd
, hdr
, newsect
))
1081 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
1082 flags
|= SEC_THREAD_LOCAL
;
1083 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
1084 flags
|= SEC_EXCLUDE
;
1086 switch (elf_elfheader (abfd
)->e_ident
[EI_OSABI
])
1088 /* FIXME: We should not recognize SHF_GNU_MBIND for ELFOSABI_NONE,
1089 but binutils as of 2019-07-23 did not set the EI_OSABI header
1093 case ELFOSABI_FREEBSD
:
1094 if ((hdr
->sh_flags
& SHF_GNU_MBIND
) != 0)
1095 elf_tdata (abfd
)->has_gnu_osabi
|= elf_gnu_osabi_mbind
;
1099 if ((flags
& SEC_ALLOC
) == 0)
1101 /* The debugging sections appear to be recognized only by name,
1102 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1103 if (name
[0] == '.')
1105 if (strncmp (name
, ".debug", 6) == 0
1106 || strncmp (name
, ".gnu.linkonce.wi.", 17) == 0
1107 || strncmp (name
, ".zdebug", 7) == 0)
1108 flags
|= SEC_DEBUGGING
| SEC_ELF_OCTETS
;
1109 else if (strncmp (name
, GNU_BUILD_ATTRS_SECTION_NAME
, 21) == 0
1110 || strncmp (name
, ".note.gnu", 9) == 0)
1111 flags
|= SEC_ELF_OCTETS
;
1112 else if (strncmp (name
, ".line", 5) == 0
1113 || strncmp (name
, ".stab", 5) == 0
1114 || strcmp (name
, ".gdb_index") == 0)
1115 flags
|= SEC_DEBUGGING
;
1119 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1120 only link a single copy of the section. This is used to support
1121 g++. g++ will emit each template expansion in its own section.
1122 The symbols will be defined as weak, so that multiple definitions
1123 are permitted. The GNU linker extension is to actually discard
1124 all but one of the sections. */
1125 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1126 && elf_next_in_group (newsect
) == NULL
)
1127 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1129 bed
= get_elf_backend_data (abfd
);
1130 if (bed
->elf_backend_section_flags
)
1131 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1134 if (!bfd_set_section_flags (newsect
, flags
))
1137 /* We do not parse the PT_NOTE segments as we are interested even in the
1138 separate debug info files which may have the segments offsets corrupted.
1139 PT_NOTEs from the core files are currently not parsed using BFD. */
1140 if (hdr
->sh_type
== SHT_NOTE
)
1144 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1147 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1148 hdr
->sh_offset
, hdr
->sh_addralign
);
1152 if ((flags
& SEC_ALLOC
) != 0)
1154 Elf_Internal_Phdr
*phdr
;
1155 unsigned int i
, nload
;
1157 /* Some ELF linkers produce binaries with all the program header
1158 p_paddr fields zero. If we have such a binary with more than
1159 one PT_LOAD header, then leave the section lma equal to vma
1160 so that we don't create sections with overlapping lma. */
1161 phdr
= elf_tdata (abfd
)->phdr
;
1162 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1163 if (phdr
->p_paddr
!= 0)
1165 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1167 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1170 phdr
= elf_tdata (abfd
)->phdr
;
1171 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1173 if (((phdr
->p_type
== PT_LOAD
1174 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1175 || phdr
->p_type
== PT_TLS
)
1176 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1178 if ((flags
& SEC_LOAD
) == 0)
1179 newsect
->lma
= (phdr
->p_paddr
1180 + hdr
->sh_addr
- phdr
->p_vaddr
);
1182 /* We used to use the same adjustment for SEC_LOAD
1183 sections, but that doesn't work if the segment
1184 is packed with code from multiple VMAs.
1185 Instead we calculate the section LMA based on
1186 the segment LMA. It is assumed that the
1187 segment will contain sections with contiguous
1188 LMAs, even if the VMAs are not. */
1189 newsect
->lma
= (phdr
->p_paddr
1190 + hdr
->sh_offset
- phdr
->p_offset
);
1192 /* With contiguous segments, we can't tell from file
1193 offsets whether a section with zero size should
1194 be placed at the end of one segment or the
1195 beginning of the next. Decide based on vaddr. */
1196 if (hdr
->sh_addr
>= phdr
->p_vaddr
1197 && (hdr
->sh_addr
+ hdr
->sh_size
1198 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1204 /* Compress/decompress DWARF debug sections with names: .debug_* and
1205 .zdebug_*, after the section flags is set. */
1206 if ((flags
& SEC_DEBUGGING
)
1207 && ((name
[1] == 'd' && name
[6] == '_')
1208 || (name
[1] == 'z' && name
[7] == '_')))
1210 enum { nothing
, compress
, decompress
} action
= nothing
;
1211 int compression_header_size
;
1212 bfd_size_type uncompressed_size
;
1213 unsigned int uncompressed_align_power
;
1214 bfd_boolean compressed
1215 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1216 &compression_header_size
,
1218 &uncompressed_align_power
);
1221 /* Compressed section. Check if we should decompress. */
1222 if ((abfd
->flags
& BFD_DECOMPRESS
))
1223 action
= decompress
;
1226 /* Compress the uncompressed section or convert from/to .zdebug*
1227 section. Check if we should compress. */
1228 if (action
== nothing
)
1230 if (newsect
->size
!= 0
1231 && (abfd
->flags
& BFD_COMPRESS
)
1232 && compression_header_size
>= 0
1233 && uncompressed_size
> 0
1235 || ((compression_header_size
> 0)
1236 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1242 if (action
== compress
)
1244 if (!bfd_init_section_compress_status (abfd
, newsect
))
1247 /* xgettext:c-format */
1248 (_("%pB: unable to initialize compress status for section %s"),
1255 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1258 /* xgettext:c-format */
1259 (_("%pB: unable to initialize decompress status for section %s"),
1265 if (abfd
->is_linker_input
)
1268 && (action
== decompress
1269 || (action
== compress
1270 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1272 /* Convert section name from .zdebug_* to .debug_* so
1273 that linker will consider this section as a debug
1275 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1276 if (new_name
== NULL
)
1278 bfd_rename_section (newsect
, new_name
);
1282 /* For objdump, don't rename the section. For objcopy, delay
1283 section rename to elf_fake_sections. */
1284 newsect
->flags
|= SEC_ELF_RENAME
;
1287 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
1289 const char *lto_section_name
= ".gnu.lto_.lto.";
1290 if (strncmp (name
, lto_section_name
, strlen (lto_section_name
)) == 0)
1292 struct lto_section lsection
;
1293 if (bfd_get_section_contents (abfd
, newsect
, &lsection
, 0,
1294 sizeof (struct lto_section
)))
1295 abfd
->lto_slim_object
= lsection
.slim_object
;
1301 const char *const bfd_elf_section_type_names
[] =
1303 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1304 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1305 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1308 /* ELF relocs are against symbols. If we are producing relocatable
1309 output, and the reloc is against an external symbol, and nothing
1310 has given us any additional addend, the resulting reloc will also
1311 be against the same symbol. In such a case, we don't want to
1312 change anything about the way the reloc is handled, since it will
1313 all be done at final link time. Rather than put special case code
1314 into bfd_perform_relocation, all the reloc types use this howto
1315 function. It just short circuits the reloc if producing
1316 relocatable output against an external symbol. */
1318 bfd_reloc_status_type
1319 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1320 arelent
*reloc_entry
,
1322 void *data ATTRIBUTE_UNUSED
,
1323 asection
*input_section
,
1325 char **error_message ATTRIBUTE_UNUSED
)
1327 if (output_bfd
!= NULL
1328 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1329 && (! reloc_entry
->howto
->partial_inplace
1330 || reloc_entry
->addend
== 0))
1332 reloc_entry
->address
+= input_section
->output_offset
;
1333 return bfd_reloc_ok
;
1336 return bfd_reloc_continue
;
1339 /* Returns TRUE if section A matches section B.
1340 Names, addresses and links may be different, but everything else
1341 should be the same. */
1344 section_match (const Elf_Internal_Shdr
* a
,
1345 const Elf_Internal_Shdr
* b
)
1347 if (a
->sh_type
!= b
->sh_type
1348 || ((a
->sh_flags
^ b
->sh_flags
) & ~SHF_INFO_LINK
) != 0
1349 || a
->sh_addralign
!= b
->sh_addralign
1350 || a
->sh_entsize
!= b
->sh_entsize
)
1352 if (a
->sh_type
== SHT_SYMTAB
1353 || a
->sh_type
== SHT_STRTAB
)
1355 return a
->sh_size
== b
->sh_size
;
1358 /* Find a section in OBFD that has the same characteristics
1359 as IHEADER. Return the index of this section or SHN_UNDEF if
1360 none can be found. Check's section HINT first, as this is likely
1361 to be the correct section. */
1364 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1365 const unsigned int hint
)
1367 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1370 BFD_ASSERT (iheader
!= NULL
);
1372 /* See PR 20922 for a reproducer of the NULL test. */
1373 if (hint
< elf_numsections (obfd
)
1374 && oheaders
[hint
] != NULL
1375 && section_match (oheaders
[hint
], iheader
))
1378 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1380 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1382 if (oheader
== NULL
)
1384 if (section_match (oheader
, iheader
))
1385 /* FIXME: Do we care if there is a potential for
1386 multiple matches ? */
1393 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1394 Processor specific section, based upon a matching input section.
1395 Returns TRUE upon success, FALSE otherwise. */
1398 copy_special_section_fields (const bfd
*ibfd
,
1400 const Elf_Internal_Shdr
*iheader
,
1401 Elf_Internal_Shdr
*oheader
,
1402 const unsigned int secnum
)
1404 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1405 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1406 bfd_boolean changed
= FALSE
;
1407 unsigned int sh_link
;
1409 if (oheader
->sh_type
== SHT_NOBITS
)
1411 /* This is a feature for objcopy --only-keep-debug:
1412 When a section's type is changed to NOBITS, we preserve
1413 the sh_link and sh_info fields so that they can be
1414 matched up with the original.
1416 Note: Strictly speaking these assignments are wrong.
1417 The sh_link and sh_info fields should point to the
1418 relevent sections in the output BFD, which may not be in
1419 the same location as they were in the input BFD. But
1420 the whole point of this action is to preserve the
1421 original values of the sh_link and sh_info fields, so
1422 that they can be matched up with the section headers in
1423 the original file. So strictly speaking we may be
1424 creating an invalid ELF file, but it is only for a file
1425 that just contains debug info and only for sections
1426 without any contents. */
1427 if (oheader
->sh_link
== 0)
1428 oheader
->sh_link
= iheader
->sh_link
;
1429 if (oheader
->sh_info
== 0)
1430 oheader
->sh_info
= iheader
->sh_info
;
1434 /* Allow the target a chance to decide how these fields should be set. */
1435 if (bed
->elf_backend_copy_special_section_fields
!= NULL
1436 && bed
->elf_backend_copy_special_section_fields
1437 (ibfd
, obfd
, iheader
, oheader
))
1440 /* We have an iheader which might match oheader, and which has non-zero
1441 sh_info and/or sh_link fields. Attempt to follow those links and find
1442 the section in the output bfd which corresponds to the linked section
1443 in the input bfd. */
1444 if (iheader
->sh_link
!= SHN_UNDEF
)
1446 /* See PR 20931 for a reproducer. */
1447 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1450 /* xgettext:c-format */
1451 (_("%pB: invalid sh_link field (%d) in section number %d"),
1452 ibfd
, iheader
->sh_link
, secnum
);
1456 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1457 if (sh_link
!= SHN_UNDEF
)
1459 oheader
->sh_link
= sh_link
;
1463 /* FIXME: Should we install iheader->sh_link
1464 if we could not find a match ? */
1466 /* xgettext:c-format */
1467 (_("%pB: failed to find link section for section %d"), obfd
, secnum
);
1470 if (iheader
->sh_info
)
1472 /* The sh_info field can hold arbitrary information, but if the
1473 SHF_LINK_INFO flag is set then it should be interpreted as a
1475 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1477 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1479 if (sh_link
!= SHN_UNDEF
)
1480 oheader
->sh_flags
|= SHF_INFO_LINK
;
1483 /* No idea what it means - just copy it. */
1484 sh_link
= iheader
->sh_info
;
1486 if (sh_link
!= SHN_UNDEF
)
1488 oheader
->sh_info
= sh_link
;
1493 /* xgettext:c-format */
1494 (_("%pB: failed to find info section for section %d"), obfd
, secnum
);
1500 /* Copy the program header and other data from one object module to
1504 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1506 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1507 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1508 const struct elf_backend_data
*bed
;
1511 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1512 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1515 if (!elf_flags_init (obfd
))
1517 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1518 elf_flags_init (obfd
) = TRUE
;
1521 elf_gp (obfd
) = elf_gp (ibfd
);
1523 /* Also copy the EI_OSABI field. */
1524 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1525 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1527 /* If set, copy the EI_ABIVERSION field. */
1528 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1529 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1530 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1532 /* Copy object attributes. */
1533 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1535 if (iheaders
== NULL
|| oheaders
== NULL
)
1538 bed
= get_elf_backend_data (obfd
);
1540 /* Possibly copy other fields in the section header. */
1541 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1544 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1546 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1547 because of a special case need for generating separate debug info
1548 files. See below for more details. */
1550 || (oheader
->sh_type
!= SHT_NOBITS
1551 && oheader
->sh_type
< SHT_LOOS
))
1554 /* Ignore empty sections, and sections whose
1555 fields have already been initialised. */
1556 if (oheader
->sh_size
== 0
1557 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1560 /* Scan for the matching section in the input bfd.
1561 First we try for a direct mapping between the input and output sections. */
1562 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1564 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1566 if (iheader
== NULL
)
1569 if (oheader
->bfd_section
!= NULL
1570 && iheader
->bfd_section
!= NULL
1571 && iheader
->bfd_section
->output_section
!= NULL
1572 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1574 /* We have found a connection from the input section to the
1575 output section. Attempt to copy the header fields. If
1576 this fails then do not try any further sections - there
1577 should only be a one-to-one mapping between input and output. */
1578 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1579 j
= elf_numsections (ibfd
);
1584 if (j
< elf_numsections (ibfd
))
1587 /* That failed. So try to deduce the corresponding input section.
1588 Unfortunately we cannot compare names as the output string table
1589 is empty, so instead we check size, address and type. */
1590 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1592 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1594 if (iheader
== NULL
)
1597 /* Try matching fields in the input section's header.
1598 Since --only-keep-debug turns all non-debug sections into
1599 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1601 if ((oheader
->sh_type
== SHT_NOBITS
1602 || iheader
->sh_type
== oheader
->sh_type
)
1603 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1604 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1605 && iheader
->sh_addralign
== oheader
->sh_addralign
1606 && iheader
->sh_entsize
== oheader
->sh_entsize
1607 && iheader
->sh_size
== oheader
->sh_size
1608 && iheader
->sh_addr
== oheader
->sh_addr
1609 && (iheader
->sh_info
!= oheader
->sh_info
1610 || iheader
->sh_link
!= oheader
->sh_link
))
1612 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1617 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1619 /* Final attempt. Call the backend copy function
1620 with a NULL input section. */
1621 if (bed
->elf_backend_copy_special_section_fields
!= NULL
)
1622 bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
, NULL
, oheader
);
1630 get_segment_type (unsigned int p_type
)
1635 case PT_NULL
: pt
= "NULL"; break;
1636 case PT_LOAD
: pt
= "LOAD"; break;
1637 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1638 case PT_INTERP
: pt
= "INTERP"; break;
1639 case PT_NOTE
: pt
= "NOTE"; break;
1640 case PT_SHLIB
: pt
= "SHLIB"; break;
1641 case PT_PHDR
: pt
= "PHDR"; break;
1642 case PT_TLS
: pt
= "TLS"; break;
1643 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1644 case PT_GNU_STACK
: pt
= "STACK"; break;
1645 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1646 default: pt
= NULL
; break;
1651 /* Print out the program headers. */
1654 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1656 FILE *f
= (FILE *) farg
;
1657 Elf_Internal_Phdr
*p
;
1659 bfd_byte
*dynbuf
= NULL
;
1661 p
= elf_tdata (abfd
)->phdr
;
1666 fprintf (f
, _("\nProgram Header:\n"));
1667 c
= elf_elfheader (abfd
)->e_phnum
;
1668 for (i
= 0; i
< c
; i
++, p
++)
1670 const char *pt
= get_segment_type (p
->p_type
);
1675 sprintf (buf
, "0x%lx", p
->p_type
);
1678 fprintf (f
, "%8s off 0x", pt
);
1679 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1680 fprintf (f
, " vaddr 0x");
1681 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1682 fprintf (f
, " paddr 0x");
1683 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1684 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1685 fprintf (f
, " filesz 0x");
1686 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1687 fprintf (f
, " memsz 0x");
1688 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1689 fprintf (f
, " flags %c%c%c",
1690 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1691 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1692 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1693 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1694 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1699 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1702 unsigned int elfsec
;
1703 unsigned long shlink
;
1704 bfd_byte
*extdyn
, *extdynend
;
1706 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1708 fprintf (f
, _("\nDynamic Section:\n"));
1710 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1713 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1714 if (elfsec
== SHN_BAD
)
1716 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1718 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1719 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1722 /* PR 17512: file: 6f427532. */
1723 if (s
->size
< extdynsize
)
1725 extdynend
= extdyn
+ s
->size
;
1726 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1728 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1730 Elf_Internal_Dyn dyn
;
1731 const char *name
= "";
1733 bfd_boolean stringp
;
1734 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1736 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1738 if (dyn
.d_tag
== DT_NULL
)
1745 if (bed
->elf_backend_get_target_dtag
)
1746 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1748 if (!strcmp (name
, ""))
1750 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1755 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1756 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1757 case DT_PLTGOT
: name
= "PLTGOT"; break;
1758 case DT_HASH
: name
= "HASH"; break;
1759 case DT_STRTAB
: name
= "STRTAB"; break;
1760 case DT_SYMTAB
: name
= "SYMTAB"; break;
1761 case DT_RELA
: name
= "RELA"; break;
1762 case DT_RELASZ
: name
= "RELASZ"; break;
1763 case DT_RELAENT
: name
= "RELAENT"; break;
1764 case DT_STRSZ
: name
= "STRSZ"; break;
1765 case DT_SYMENT
: name
= "SYMENT"; break;
1766 case DT_INIT
: name
= "INIT"; break;
1767 case DT_FINI
: name
= "FINI"; break;
1768 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1769 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1770 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1771 case DT_REL
: name
= "REL"; break;
1772 case DT_RELSZ
: name
= "RELSZ"; break;
1773 case DT_RELENT
: name
= "RELENT"; break;
1774 case DT_PLTREL
: name
= "PLTREL"; break;
1775 case DT_DEBUG
: name
= "DEBUG"; break;
1776 case DT_TEXTREL
: name
= "TEXTREL"; break;
1777 case DT_JMPREL
: name
= "JMPREL"; break;
1778 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1779 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1780 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1781 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1782 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1783 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1784 case DT_FLAGS
: name
= "FLAGS"; break;
1785 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1786 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1787 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1788 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1789 case DT_MOVEENT
: name
= "MOVEENT"; break;
1790 case DT_MOVESZ
: name
= "MOVESZ"; break;
1791 case DT_FEATURE
: name
= "FEATURE"; break;
1792 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1793 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1794 case DT_SYMINENT
: name
= "SYMINENT"; break;
1795 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1796 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1797 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1798 case DT_PLTPAD
: name
= "PLTPAD"; break;
1799 case DT_MOVETAB
: name
= "MOVETAB"; break;
1800 case DT_SYMINFO
: name
= "SYMINFO"; break;
1801 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1802 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1803 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1804 case DT_VERSYM
: name
= "VERSYM"; break;
1805 case DT_VERDEF
: name
= "VERDEF"; break;
1806 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1807 case DT_VERNEED
: name
= "VERNEED"; break;
1808 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1809 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1810 case DT_USED
: name
= "USED"; break;
1811 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1812 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1815 fprintf (f
, " %-20s ", name
);
1819 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1824 unsigned int tagv
= dyn
.d_un
.d_val
;
1826 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1829 fprintf (f
, "%s", string
);
1838 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1839 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1841 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1845 if (elf_dynverdef (abfd
) != 0)
1847 Elf_Internal_Verdef
*t
;
1849 fprintf (f
, _("\nVersion definitions:\n"));
1850 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1852 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1853 t
->vd_flags
, t
->vd_hash
,
1854 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1855 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1857 Elf_Internal_Verdaux
*a
;
1860 for (a
= t
->vd_auxptr
->vda_nextptr
;
1864 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1870 if (elf_dynverref (abfd
) != 0)
1872 Elf_Internal_Verneed
*t
;
1874 fprintf (f
, _("\nVersion References:\n"));
1875 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1877 Elf_Internal_Vernaux
*a
;
1879 fprintf (f
, _(" required from %s:\n"),
1880 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1881 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1882 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1883 a
->vna_flags
, a
->vna_other
,
1884 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1896 /* Get version string. */
1899 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1900 bfd_boolean
*hidden
)
1902 const char *version_string
= NULL
;
1903 if (elf_dynversym (abfd
) != 0
1904 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1906 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1908 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1909 vernum
&= VERSYM_VERSION
;
1912 version_string
= "";
1913 else if (vernum
== 1
1914 && (vernum
> elf_tdata (abfd
)->cverdefs
1915 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1917 version_string
= "Base";
1918 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1920 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1923 Elf_Internal_Verneed
*t
;
1925 version_string
= _("<corrupt>");
1926 for (t
= elf_tdata (abfd
)->verref
;
1930 Elf_Internal_Vernaux
*a
;
1932 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1934 if (a
->vna_other
== vernum
)
1936 version_string
= a
->vna_nodename
;
1943 return version_string
;
1946 /* Display ELF-specific fields of a symbol. */
1949 bfd_elf_print_symbol (bfd
*abfd
,
1952 bfd_print_symbol_type how
)
1954 FILE *file
= (FILE *) filep
;
1957 case bfd_print_symbol_name
:
1958 fprintf (file
, "%s", symbol
->name
);
1960 case bfd_print_symbol_more
:
1961 fprintf (file
, "elf ");
1962 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1963 fprintf (file
, " %x", symbol
->flags
);
1965 case bfd_print_symbol_all
:
1967 const char *section_name
;
1968 const char *name
= NULL
;
1969 const struct elf_backend_data
*bed
;
1970 unsigned char st_other
;
1972 const char *version_string
;
1975 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1977 bed
= get_elf_backend_data (abfd
);
1978 if (bed
->elf_backend_print_symbol_all
)
1979 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1983 name
= symbol
->name
;
1984 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1987 fprintf (file
, " %s\t", section_name
);
1988 /* Print the "other" value for a symbol. For common symbols,
1989 we've already printed the size; now print the alignment.
1990 For other symbols, we have no specified alignment, and
1991 we've printed the address; now print the size. */
1992 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1993 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1995 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1996 bfd_fprintf_vma (abfd
, file
, val
);
1998 /* If we have version information, print it. */
1999 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
2005 fprintf (file
, " %-11s", version_string
);
2010 fprintf (file
, " (%s)", version_string
);
2011 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
2016 /* If the st_other field is not zero, print it. */
2017 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
2022 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
2023 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
2024 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
2026 /* Some other non-defined flags are also present, so print
2028 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
2031 fprintf (file
, " %s", name
);
2037 /* ELF .o/exec file reading */
2039 /* Create a new bfd section from an ELF section header. */
2042 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2044 Elf_Internal_Shdr
*hdr
;
2045 Elf_Internal_Ehdr
*ehdr
;
2046 const struct elf_backend_data
*bed
;
2048 bfd_boolean ret
= TRUE
;
2049 static bfd_boolean
* sections_being_created
= NULL
;
2050 static bfd
* sections_being_created_abfd
= NULL
;
2051 static unsigned int nesting
= 0;
2053 if (shindex
>= elf_numsections (abfd
))
2058 /* PR17512: A corrupt ELF binary might contain a recursive group of
2059 sections, with each the string indices pointing to the next in the
2060 loop. Detect this here, by refusing to load a section that we are
2061 already in the process of loading. We only trigger this test if
2062 we have nested at least three sections deep as normal ELF binaries
2063 can expect to recurse at least once.
2065 FIXME: It would be better if this array was attached to the bfd,
2066 rather than being held in a static pointer. */
2068 if (sections_being_created_abfd
!= abfd
)
2069 sections_being_created
= NULL
;
2070 if (sections_being_created
== NULL
)
2072 sections_being_created
= (bfd_boolean
*)
2073 bfd_zalloc2 (abfd
, elf_numsections (abfd
), sizeof (bfd_boolean
));
2074 if (sections_being_created
== NULL
)
2076 sections_being_created_abfd
= abfd
;
2078 if (sections_being_created
[shindex
])
2081 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2084 sections_being_created
[shindex
] = TRUE
;
2087 hdr
= elf_elfsections (abfd
)[shindex
];
2088 ehdr
= elf_elfheader (abfd
);
2089 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2094 bed
= get_elf_backend_data (abfd
);
2095 switch (hdr
->sh_type
)
2098 /* Inactive section. Throw it away. */
2101 case SHT_PROGBITS
: /* Normal section with contents. */
2102 case SHT_NOBITS
: /* .bss section. */
2103 case SHT_HASH
: /* .hash section. */
2104 case SHT_NOTE
: /* .note section. */
2105 case SHT_INIT_ARRAY
: /* .init_array section. */
2106 case SHT_FINI_ARRAY
: /* .fini_array section. */
2107 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2108 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2109 case SHT_GNU_HASH
: /* .gnu.hash section. */
2110 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2113 case SHT_DYNAMIC
: /* Dynamic linking information. */
2114 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2117 if (hdr
->sh_link
> elf_numsections (abfd
))
2119 /* PR 10478: Accept Solaris binaries with a sh_link
2120 field set to SHN_BEFORE or SHN_AFTER. */
2121 switch (bfd_get_arch (abfd
))
2124 case bfd_arch_sparc
:
2125 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2126 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2128 /* Otherwise fall through. */
2133 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2135 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2137 Elf_Internal_Shdr
*dynsymhdr
;
2139 /* The shared libraries distributed with hpux11 have a bogus
2140 sh_link field for the ".dynamic" section. Find the
2141 string table for the ".dynsym" section instead. */
2142 if (elf_dynsymtab (abfd
) != 0)
2144 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2145 hdr
->sh_link
= dynsymhdr
->sh_link
;
2149 unsigned int i
, num_sec
;
2151 num_sec
= elf_numsections (abfd
);
2152 for (i
= 1; i
< num_sec
; i
++)
2154 dynsymhdr
= elf_elfsections (abfd
)[i
];
2155 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2157 hdr
->sh_link
= dynsymhdr
->sh_link
;
2165 case SHT_SYMTAB
: /* A symbol table. */
2166 if (elf_onesymtab (abfd
) == shindex
)
2169 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2172 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2174 if (hdr
->sh_size
!= 0)
2176 /* Some assemblers erroneously set sh_info to one with a
2177 zero sh_size. ld sees this as a global symbol count
2178 of (unsigned) -1. Fix it here. */
2183 /* PR 18854: A binary might contain more than one symbol table.
2184 Unusual, but possible. Warn, but continue. */
2185 if (elf_onesymtab (abfd
) != 0)
2188 /* xgettext:c-format */
2189 (_("%pB: warning: multiple symbol tables detected"
2190 " - ignoring the table in section %u"),
2194 elf_onesymtab (abfd
) = shindex
;
2195 elf_symtab_hdr (abfd
) = *hdr
;
2196 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2197 abfd
->flags
|= HAS_SYMS
;
2199 /* Sometimes a shared object will map in the symbol table. If
2200 SHF_ALLOC is set, and this is a shared object, then we also
2201 treat this section as a BFD section. We can not base the
2202 decision purely on SHF_ALLOC, because that flag is sometimes
2203 set in a relocatable object file, which would confuse the
2205 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2206 && (abfd
->flags
& DYNAMIC
) != 0
2207 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2211 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2212 can't read symbols without that section loaded as well. It
2213 is most likely specified by the next section header. */
2215 elf_section_list
* entry
;
2216 unsigned int i
, num_sec
;
2218 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2219 if (entry
->hdr
.sh_link
== shindex
)
2222 num_sec
= elf_numsections (abfd
);
2223 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2225 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2227 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2228 && hdr2
->sh_link
== shindex
)
2233 for (i
= 1; i
< shindex
; i
++)
2235 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2237 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2238 && hdr2
->sh_link
== shindex
)
2243 ret
= bfd_section_from_shdr (abfd
, i
);
2244 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2248 case SHT_DYNSYM
: /* A dynamic symbol table. */
2249 if (elf_dynsymtab (abfd
) == shindex
)
2252 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2255 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2257 if (hdr
->sh_size
!= 0)
2260 /* Some linkers erroneously set sh_info to one with a
2261 zero sh_size. ld sees this as a global symbol count
2262 of (unsigned) -1. Fix it here. */
2267 /* PR 18854: A binary might contain more than one dynamic symbol table.
2268 Unusual, but possible. Warn, but continue. */
2269 if (elf_dynsymtab (abfd
) != 0)
2272 /* xgettext:c-format */
2273 (_("%pB: warning: multiple dynamic symbol tables detected"
2274 " - ignoring the table in section %u"),
2278 elf_dynsymtab (abfd
) = shindex
;
2279 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2280 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2281 abfd
->flags
|= HAS_SYMS
;
2283 /* Besides being a symbol table, we also treat this as a regular
2284 section, so that objcopy can handle it. */
2285 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2288 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2290 elf_section_list
* entry
;
2292 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2293 if (entry
->ndx
== shindex
)
2296 entry
= bfd_alloc (abfd
, sizeof (*entry
));
2299 entry
->ndx
= shindex
;
2301 entry
->next
= elf_symtab_shndx_list (abfd
);
2302 elf_symtab_shndx_list (abfd
) = entry
;
2303 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2307 case SHT_STRTAB
: /* A string table. */
2308 if (hdr
->bfd_section
!= NULL
)
2311 if (ehdr
->e_shstrndx
== shindex
)
2313 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2314 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2318 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2321 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2322 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2326 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2329 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2330 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2331 elf_elfsections (abfd
)[shindex
] = hdr
;
2332 /* We also treat this as a regular section, so that objcopy
2334 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2339 /* If the string table isn't one of the above, then treat it as a
2340 regular section. We need to scan all the headers to be sure,
2341 just in case this strtab section appeared before the above. */
2342 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2344 unsigned int i
, num_sec
;
2346 num_sec
= elf_numsections (abfd
);
2347 for (i
= 1; i
< num_sec
; i
++)
2349 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2350 if (hdr2
->sh_link
== shindex
)
2352 /* Prevent endless recursion on broken objects. */
2355 if (! bfd_section_from_shdr (abfd
, i
))
2357 if (elf_onesymtab (abfd
) == i
)
2359 if (elf_dynsymtab (abfd
) == i
)
2360 goto dynsymtab_strtab
;
2364 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2369 /* *These* do a lot of work -- but build no sections! */
2371 asection
*target_sect
;
2372 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2373 unsigned int num_sec
= elf_numsections (abfd
);
2374 struct bfd_elf_section_data
*esdt
;
2377 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2378 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2381 /* Check for a bogus link to avoid crashing. */
2382 if (hdr
->sh_link
>= num_sec
)
2385 /* xgettext:c-format */
2386 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2387 abfd
, hdr
->sh_link
, name
, shindex
);
2388 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2393 /* For some incomprehensible reason Oracle distributes
2394 libraries for Solaris in which some of the objects have
2395 bogus sh_link fields. It would be nice if we could just
2396 reject them, but, unfortunately, some people need to use
2397 them. We scan through the section headers; if we find only
2398 one suitable symbol table, we clobber the sh_link to point
2399 to it. I hope this doesn't break anything.
2401 Don't do it on executable nor shared library. */
2402 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2403 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2404 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2410 for (scan
= 1; scan
< num_sec
; scan
++)
2412 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2413 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2424 hdr
->sh_link
= found
;
2427 /* Get the symbol table. */
2428 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2429 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2430 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2433 /* If this is an alloc section in an executable or shared
2434 library, or the reloc section does not use the main symbol
2435 table we don't treat it as a reloc section. BFD can't
2436 adequately represent such a section, so at least for now,
2437 we don't try. We just present it as a normal section. We
2438 also can't use it as a reloc section if it points to the
2439 null section, an invalid section, another reloc section, or
2440 its sh_link points to the null section. */
2441 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2442 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2443 || hdr
->sh_link
== SHN_UNDEF
2444 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2445 || hdr
->sh_info
== SHN_UNDEF
2446 || hdr
->sh_info
>= num_sec
2447 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2448 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2450 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2455 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2458 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2459 if (target_sect
== NULL
)
2462 esdt
= elf_section_data (target_sect
);
2463 if (hdr
->sh_type
== SHT_RELA
)
2464 p_hdr
= &esdt
->rela
.hdr
;
2466 p_hdr
= &esdt
->rel
.hdr
;
2468 /* PR 17512: file: 0b4f81b7.
2469 Also see PR 24456, for a file which deliberately has two reloc
2474 /* xgettext:c-format */
2475 (_("%pB: warning: multiple relocation sections for section %pA \
2476 found - ignoring all but the first"),
2480 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2485 elf_elfsections (abfd
)[shindex
] = hdr2
;
2486 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2487 * bed
->s
->int_rels_per_ext_rel
);
2488 target_sect
->flags
|= SEC_RELOC
;
2489 target_sect
->relocation
= NULL
;
2490 target_sect
->rel_filepos
= hdr
->sh_offset
;
2491 /* In the section to which the relocations apply, mark whether
2492 its relocations are of the REL or RELA variety. */
2493 if (hdr
->sh_size
!= 0)
2495 if (hdr
->sh_type
== SHT_RELA
)
2496 target_sect
->use_rela_p
= 1;
2498 abfd
->flags
|= HAS_RELOC
;
2502 case SHT_GNU_verdef
:
2503 elf_dynverdef (abfd
) = shindex
;
2504 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2505 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2508 case SHT_GNU_versym
:
2509 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2512 elf_dynversym (abfd
) = shindex
;
2513 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2514 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2517 case SHT_GNU_verneed
:
2518 elf_dynverref (abfd
) = shindex
;
2519 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2520 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2527 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2530 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2536 /* Possibly an attributes section. */
2537 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2538 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2540 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2542 _bfd_elf_parse_attributes (abfd
, hdr
);
2546 /* Check for any processor-specific section types. */
2547 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2550 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2552 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2553 /* FIXME: How to properly handle allocated section reserved
2554 for applications? */
2556 /* xgettext:c-format */
2557 (_("%pB: unknown type [%#x] section `%s'"),
2558 abfd
, hdr
->sh_type
, name
);
2561 /* Allow sections reserved for applications. */
2562 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2567 else if (hdr
->sh_type
>= SHT_LOPROC
2568 && hdr
->sh_type
<= SHT_HIPROC
)
2569 /* FIXME: We should handle this section. */
2571 /* xgettext:c-format */
2572 (_("%pB: unknown type [%#x] section `%s'"),
2573 abfd
, hdr
->sh_type
, name
);
2574 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2576 /* Unrecognised OS-specific sections. */
2577 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2578 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2579 required to correctly process the section and the file should
2580 be rejected with an error message. */
2582 /* xgettext:c-format */
2583 (_("%pB: unknown type [%#x] section `%s'"),
2584 abfd
, hdr
->sh_type
, name
);
2587 /* Otherwise it should be processed. */
2588 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2593 /* FIXME: We should handle this section. */
2595 /* xgettext:c-format */
2596 (_("%pB: unknown type [%#x] section `%s'"),
2597 abfd
, hdr
->sh_type
, name
);
2605 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2606 sections_being_created
[shindex
] = FALSE
;
2607 if (-- nesting
== 0)
2609 sections_being_created
= NULL
;
2610 sections_being_created_abfd
= abfd
;
2615 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2618 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2620 unsigned long r_symndx
)
2622 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2624 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2626 Elf_Internal_Shdr
*symtab_hdr
;
2627 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2628 Elf_External_Sym_Shndx eshndx
;
2630 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2631 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2632 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2635 if (cache
->abfd
!= abfd
)
2637 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2640 cache
->indx
[ent
] = r_symndx
;
2643 return &cache
->sym
[ent
];
2646 /* Given an ELF section number, retrieve the corresponding BFD
2650 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2652 if (sec_index
>= elf_numsections (abfd
))
2654 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2657 static const struct bfd_elf_special_section special_sections_b
[] =
2659 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2660 { NULL
, 0, 0, 0, 0 }
2663 static const struct bfd_elf_special_section special_sections_c
[] =
2665 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2666 { STRING_COMMA_LEN (".ctf"), 0, SHT_PROGBITS
, 0 },
2667 { NULL
, 0, 0, 0, 0 }
2670 static const struct bfd_elf_special_section special_sections_d
[] =
2672 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2673 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2674 /* There are more DWARF sections than these, but they needn't be added here
2675 unless you have to cope with broken compilers that don't emit section
2676 attributes or you want to help the user writing assembler. */
2677 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2678 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2679 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2680 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2681 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2682 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2683 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2684 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2685 { NULL
, 0, 0, 0, 0 }
2688 static const struct bfd_elf_special_section special_sections_f
[] =
2690 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2691 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2692 { NULL
, 0 , 0, 0, 0 }
2695 static const struct bfd_elf_special_section special_sections_g
[] =
2697 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2698 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2699 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2700 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2701 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2702 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2703 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2704 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2705 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2706 { NULL
, 0, 0, 0, 0 }
2709 static const struct bfd_elf_special_section special_sections_h
[] =
2711 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2712 { NULL
, 0, 0, 0, 0 }
2715 static const struct bfd_elf_special_section special_sections_i
[] =
2717 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2718 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2719 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2720 { NULL
, 0, 0, 0, 0 }
2723 static const struct bfd_elf_special_section special_sections_l
[] =
2725 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2726 { NULL
, 0, 0, 0, 0 }
2729 static const struct bfd_elf_special_section special_sections_n
[] =
2731 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2732 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2733 { NULL
, 0, 0, 0, 0 }
2736 static const struct bfd_elf_special_section special_sections_p
[] =
2738 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2739 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2740 { NULL
, 0, 0, 0, 0 }
2743 static const struct bfd_elf_special_section special_sections_r
[] =
2745 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2746 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2747 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2748 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2749 { NULL
, 0, 0, 0, 0 }
2752 static const struct bfd_elf_special_section special_sections_s
[] =
2754 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2755 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2756 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2757 /* See struct bfd_elf_special_section declaration for the semantics of
2758 this special case where .prefix_length != strlen (.prefix). */
2759 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2760 { NULL
, 0, 0, 0, 0 }
2763 static const struct bfd_elf_special_section special_sections_t
[] =
2765 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2766 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2767 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2768 { NULL
, 0, 0, 0, 0 }
2771 static const struct bfd_elf_special_section special_sections_z
[] =
2773 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2774 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2775 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2776 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2777 { NULL
, 0, 0, 0, 0 }
2780 static const struct bfd_elf_special_section
* const special_sections
[] =
2782 special_sections_b
, /* 'b' */
2783 special_sections_c
, /* 'c' */
2784 special_sections_d
, /* 'd' */
2786 special_sections_f
, /* 'f' */
2787 special_sections_g
, /* 'g' */
2788 special_sections_h
, /* 'h' */
2789 special_sections_i
, /* 'i' */
2792 special_sections_l
, /* 'l' */
2794 special_sections_n
, /* 'n' */
2796 special_sections_p
, /* 'p' */
2798 special_sections_r
, /* 'r' */
2799 special_sections_s
, /* 's' */
2800 special_sections_t
, /* 't' */
2806 special_sections_z
/* 'z' */
2809 const struct bfd_elf_special_section
*
2810 _bfd_elf_get_special_section (const char *name
,
2811 const struct bfd_elf_special_section
*spec
,
2817 len
= strlen (name
);
2819 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2822 int prefix_len
= spec
[i
].prefix_length
;
2824 if (len
< prefix_len
)
2826 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2829 suffix_len
= spec
[i
].suffix_length
;
2830 if (suffix_len
<= 0)
2832 if (name
[prefix_len
] != 0)
2834 if (suffix_len
== 0)
2836 if (name
[prefix_len
] != '.'
2837 && (suffix_len
== -2
2838 || (rela
&& spec
[i
].type
== SHT_REL
)))
2844 if (len
< prefix_len
+ suffix_len
)
2846 if (memcmp (name
+ len
- suffix_len
,
2847 spec
[i
].prefix
+ prefix_len
,
2857 const struct bfd_elf_special_section
*
2858 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2861 const struct bfd_elf_special_section
*spec
;
2862 const struct elf_backend_data
*bed
;
2864 /* See if this is one of the special sections. */
2865 if (sec
->name
== NULL
)
2868 bed
= get_elf_backend_data (abfd
);
2869 spec
= bed
->special_sections
;
2872 spec
= _bfd_elf_get_special_section (sec
->name
,
2873 bed
->special_sections
,
2879 if (sec
->name
[0] != '.')
2882 i
= sec
->name
[1] - 'b';
2883 if (i
< 0 || i
> 'z' - 'b')
2886 spec
= special_sections
[i
];
2891 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2895 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2897 struct bfd_elf_section_data
*sdata
;
2898 const struct elf_backend_data
*bed
;
2899 const struct bfd_elf_special_section
*ssect
;
2901 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2904 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2908 sec
->used_by_bfd
= sdata
;
2911 /* Indicate whether or not this section should use RELA relocations. */
2912 bed
= get_elf_backend_data (abfd
);
2913 sec
->use_rela_p
= bed
->default_use_rela_p
;
2915 /* When we read a file, we don't need to set ELF section type and
2916 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2917 anyway. We will set ELF section type and flags for all linker
2918 created sections. If user specifies BFD section flags, we will
2919 set ELF section type and flags based on BFD section flags in
2920 elf_fake_sections. Special handling for .init_array/.fini_array
2921 output sections since they may contain .ctors/.dtors input
2922 sections. We don't want _bfd_elf_init_private_section_data to
2923 copy ELF section type from .ctors/.dtors input sections. */
2924 if (abfd
->direction
!= read_direction
2925 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2927 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2930 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2931 || ssect
->type
== SHT_INIT_ARRAY
2932 || ssect
->type
== SHT_FINI_ARRAY
))
2934 elf_section_type (sec
) = ssect
->type
;
2935 elf_section_flags (sec
) = ssect
->attr
;
2939 return _bfd_generic_new_section_hook (abfd
, sec
);
2942 /* Create a new bfd section from an ELF program header.
2944 Since program segments have no names, we generate a synthetic name
2945 of the form segment<NUM>, where NUM is generally the index in the
2946 program header table. For segments that are split (see below) we
2947 generate the names segment<NUM>a and segment<NUM>b.
2949 Note that some program segments may have a file size that is different than
2950 (less than) the memory size. All this means is that at execution the
2951 system must allocate the amount of memory specified by the memory size,
2952 but only initialize it with the first "file size" bytes read from the
2953 file. This would occur for example, with program segments consisting
2954 of combined data+bss.
2956 To handle the above situation, this routine generates TWO bfd sections
2957 for the single program segment. The first has the length specified by
2958 the file size of the segment, and the second has the length specified
2959 by the difference between the two sizes. In effect, the segment is split
2960 into its initialized and uninitialized parts.
2965 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2966 Elf_Internal_Phdr
*hdr
,
2968 const char *type_name
)
2976 split
= ((hdr
->p_memsz
> 0)
2977 && (hdr
->p_filesz
> 0)
2978 && (hdr
->p_memsz
> hdr
->p_filesz
));
2980 if (hdr
->p_filesz
> 0)
2982 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2983 len
= strlen (namebuf
) + 1;
2984 name
= (char *) bfd_alloc (abfd
, len
);
2987 memcpy (name
, namebuf
, len
);
2988 newsect
= bfd_make_section (abfd
, name
);
2989 if (newsect
== NULL
)
2991 newsect
->vma
= hdr
->p_vaddr
;
2992 newsect
->lma
= hdr
->p_paddr
;
2993 newsect
->size
= hdr
->p_filesz
;
2994 newsect
->filepos
= hdr
->p_offset
;
2995 newsect
->flags
|= SEC_HAS_CONTENTS
;
2996 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2997 if (hdr
->p_type
== PT_LOAD
)
2999 newsect
->flags
|= SEC_ALLOC
;
3000 newsect
->flags
|= SEC_LOAD
;
3001 if (hdr
->p_flags
& PF_X
)
3003 /* FIXME: all we known is that it has execute PERMISSION,
3005 newsect
->flags
|= SEC_CODE
;
3008 if (!(hdr
->p_flags
& PF_W
))
3010 newsect
->flags
|= SEC_READONLY
;
3014 if (hdr
->p_memsz
> hdr
->p_filesz
)
3018 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
3019 len
= strlen (namebuf
) + 1;
3020 name
= (char *) bfd_alloc (abfd
, len
);
3023 memcpy (name
, namebuf
, len
);
3024 newsect
= bfd_make_section (abfd
, name
);
3025 if (newsect
== NULL
)
3027 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
3028 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
3029 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
3030 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
3031 align
= newsect
->vma
& -newsect
->vma
;
3032 if (align
== 0 || align
> hdr
->p_align
)
3033 align
= hdr
->p_align
;
3034 newsect
->alignment_power
= bfd_log2 (align
);
3035 if (hdr
->p_type
== PT_LOAD
)
3037 /* Hack for gdb. Segments that have not been modified do
3038 not have their contents written to a core file, on the
3039 assumption that a debugger can find the contents in the
3040 executable. We flag this case by setting the fake
3041 section size to zero. Note that "real" bss sections will
3042 always have their contents dumped to the core file. */
3043 if (bfd_get_format (abfd
) == bfd_core
)
3045 newsect
->flags
|= SEC_ALLOC
;
3046 if (hdr
->p_flags
& PF_X
)
3047 newsect
->flags
|= SEC_CODE
;
3049 if (!(hdr
->p_flags
& PF_W
))
3050 newsect
->flags
|= SEC_READONLY
;
3057 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3059 /* The return value is ignored. Build-ids are considered optional. */
3060 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3061 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3067 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3069 const struct elf_backend_data
*bed
;
3071 switch (hdr
->p_type
)
3074 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3077 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3079 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3080 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3084 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3087 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3090 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3092 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3098 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3101 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3103 case PT_GNU_EH_FRAME
:
3104 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3108 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3111 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3114 /* Check for any processor-specific program segment types. */
3115 bed
= get_elf_backend_data (abfd
);
3116 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3120 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3124 _bfd_elf_single_rel_hdr (asection
*sec
)
3126 if (elf_section_data (sec
)->rel
.hdr
)
3128 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3129 return elf_section_data (sec
)->rel
.hdr
;
3132 return elf_section_data (sec
)->rela
.hdr
;
3136 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3137 Elf_Internal_Shdr
*rel_hdr
,
3138 const char *sec_name
,
3139 bfd_boolean use_rela_p
)
3141 char *name
= (char *) bfd_alloc (abfd
,
3142 sizeof ".rela" + strlen (sec_name
));
3146 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3148 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3150 if (rel_hdr
->sh_name
== (unsigned int) -1)
3156 /* Allocate and initialize a section-header for a new reloc section,
3157 containing relocations against ASECT. It is stored in RELDATA. If
3158 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3162 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3163 struct bfd_elf_section_reloc_data
*reldata
,
3164 const char *sec_name
,
3165 bfd_boolean use_rela_p
,
3166 bfd_boolean delay_st_name_p
)
3168 Elf_Internal_Shdr
*rel_hdr
;
3169 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3171 BFD_ASSERT (reldata
->hdr
== NULL
);
3172 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3173 reldata
->hdr
= rel_hdr
;
3175 if (delay_st_name_p
)
3176 rel_hdr
->sh_name
= (unsigned int) -1;
3177 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3180 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3181 rel_hdr
->sh_entsize
= (use_rela_p
3182 ? bed
->s
->sizeof_rela
3183 : bed
->s
->sizeof_rel
);
3184 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3185 rel_hdr
->sh_flags
= 0;
3186 rel_hdr
->sh_addr
= 0;
3187 rel_hdr
->sh_size
= 0;
3188 rel_hdr
->sh_offset
= 0;
3193 /* Return the default section type based on the passed in section flags. */
3196 bfd_elf_get_default_section_type (flagword flags
)
3198 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3199 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3201 return SHT_PROGBITS
;
3204 struct fake_section_arg
3206 struct bfd_link_info
*link_info
;
3210 /* Set up an ELF internal section header for a section. */
3213 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3215 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3216 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3217 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3218 Elf_Internal_Shdr
*this_hdr
;
3219 unsigned int sh_type
;
3220 const char *name
= asect
->name
;
3221 bfd_boolean delay_st_name_p
= FALSE
;
3225 /* We already failed; just get out of the bfd_map_over_sections
3230 this_hdr
= &esd
->this_hdr
;
3234 /* ld: compress DWARF debug sections with names: .debug_*. */
3235 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3236 && (asect
->flags
& SEC_DEBUGGING
)
3240 /* Set SEC_ELF_COMPRESS to indicate this section should be
3242 asect
->flags
|= SEC_ELF_COMPRESS
;
3244 /* If this section will be compressed, delay adding section
3245 name to section name section after it is compressed in
3246 _bfd_elf_assign_file_positions_for_non_load. */
3247 delay_st_name_p
= TRUE
;
3250 else if ((asect
->flags
& SEC_ELF_RENAME
))
3252 /* objcopy: rename output DWARF debug section. */
3253 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3255 /* When we decompress or compress with SHF_COMPRESSED,
3256 convert section name from .zdebug_* to .debug_* if
3260 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3261 if (new_name
== NULL
)
3269 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3271 /* PR binutils/18087: Compression does not always make a
3272 section smaller. So only rename the section when
3273 compression has actually taken place. If input section
3274 name is .zdebug_*, we should never compress it again. */
3275 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3276 if (new_name
== NULL
)
3281 BFD_ASSERT (name
[1] != 'z');
3286 if (delay_st_name_p
)
3287 this_hdr
->sh_name
= (unsigned int) -1;
3291 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3293 if (this_hdr
->sh_name
== (unsigned int) -1)
3300 /* Don't clear sh_flags. Assembler may set additional bits. */
3302 if ((asect
->flags
& SEC_ALLOC
) != 0
3303 || asect
->user_set_vma
)
3304 this_hdr
->sh_addr
= asect
->vma
;
3306 this_hdr
->sh_addr
= 0;
3308 this_hdr
->sh_offset
= 0;
3309 this_hdr
->sh_size
= asect
->size
;
3310 this_hdr
->sh_link
= 0;
3311 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3312 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3315 /* xgettext:c-format */
3316 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3317 abfd
, asect
->alignment_power
, asect
);
3321 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
3322 /* The sh_entsize and sh_info fields may have been set already by
3323 copy_private_section_data. */
3325 this_hdr
->bfd_section
= asect
;
3326 this_hdr
->contents
= NULL
;
3328 /* If the section type is unspecified, we set it based on
3330 if ((asect
->flags
& SEC_GROUP
) != 0)
3331 sh_type
= SHT_GROUP
;
3333 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3335 if (this_hdr
->sh_type
== SHT_NULL
)
3336 this_hdr
->sh_type
= sh_type
;
3337 else if (this_hdr
->sh_type
== SHT_NOBITS
3338 && sh_type
== SHT_PROGBITS
3339 && (asect
->flags
& SEC_ALLOC
) != 0)
3341 /* Warn if we are changing a NOBITS section to PROGBITS, but
3342 allow the link to proceed. This can happen when users link
3343 non-bss input sections to bss output sections, or emit data
3344 to a bss output section via a linker script. */
3346 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3347 this_hdr
->sh_type
= sh_type
;
3350 switch (this_hdr
->sh_type
)
3361 case SHT_INIT_ARRAY
:
3362 case SHT_FINI_ARRAY
:
3363 case SHT_PREINIT_ARRAY
:
3364 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3368 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3372 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3376 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3380 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3381 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3385 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3386 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3389 case SHT_GNU_versym
:
3390 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3393 case SHT_GNU_verdef
:
3394 this_hdr
->sh_entsize
= 0;
3395 /* objcopy or strip will copy over sh_info, but may not set
3396 cverdefs. The linker will set cverdefs, but sh_info will be
3398 if (this_hdr
->sh_info
== 0)
3399 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3401 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3402 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3405 case SHT_GNU_verneed
:
3406 this_hdr
->sh_entsize
= 0;
3407 /* objcopy or strip will copy over sh_info, but may not set
3408 cverrefs. The linker will set cverrefs, but sh_info will be
3410 if (this_hdr
->sh_info
== 0)
3411 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3413 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3414 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3418 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3422 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3426 if ((asect
->flags
& SEC_ALLOC
) != 0)
3427 this_hdr
->sh_flags
|= SHF_ALLOC
;
3428 if ((asect
->flags
& SEC_READONLY
) == 0)
3429 this_hdr
->sh_flags
|= SHF_WRITE
;
3430 if ((asect
->flags
& SEC_CODE
) != 0)
3431 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3432 if ((asect
->flags
& SEC_MERGE
) != 0)
3434 this_hdr
->sh_flags
|= SHF_MERGE
;
3435 this_hdr
->sh_entsize
= asect
->entsize
;
3437 if ((asect
->flags
& SEC_STRINGS
) != 0)
3438 this_hdr
->sh_flags
|= SHF_STRINGS
;
3439 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3440 this_hdr
->sh_flags
|= SHF_GROUP
;
3441 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3443 this_hdr
->sh_flags
|= SHF_TLS
;
3444 if (asect
->size
== 0
3445 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3447 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3449 this_hdr
->sh_size
= 0;
3452 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3453 if (this_hdr
->sh_size
!= 0)
3454 this_hdr
->sh_type
= SHT_NOBITS
;
3458 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3459 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3461 /* If the section has relocs, set up a section header for the
3462 SHT_REL[A] section. If two relocation sections are required for
3463 this section, it is up to the processor-specific back-end to
3464 create the other. */
3465 if ((asect
->flags
& SEC_RELOC
) != 0)
3467 /* When doing a relocatable link, create both REL and RELA sections if
3470 /* Do the normal setup if we wouldn't create any sections here. */
3471 && esd
->rel
.count
+ esd
->rela
.count
> 0
3472 && (bfd_link_relocatable (arg
->link_info
)
3473 || arg
->link_info
->emitrelocations
))
3475 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3476 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3477 FALSE
, delay_st_name_p
))
3482 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3483 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3484 TRUE
, delay_st_name_p
))
3490 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3492 ? &esd
->rela
: &esd
->rel
),
3502 /* Check for processor-specific section types. */
3503 sh_type
= this_hdr
->sh_type
;
3504 if (bed
->elf_backend_fake_sections
3505 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3511 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3513 /* Don't change the header type from NOBITS if we are being
3514 called for objcopy --only-keep-debug. */
3515 this_hdr
->sh_type
= sh_type
;
3519 /* Fill in the contents of a SHT_GROUP section. Called from
3520 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3521 when ELF targets use the generic linker, ld. Called for ld -r
3522 from bfd_elf_final_link. */
3525 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3527 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3528 asection
*elt
, *first
;
3532 /* Ignore linker created group section. See elfNN_ia64_object_p in
3534 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3539 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3541 unsigned long symindx
= 0;
3543 /* elf_group_id will have been set up by objcopy and the
3545 if (elf_group_id (sec
) != NULL
)
3546 symindx
= elf_group_id (sec
)->udata
.i
;
3550 /* If called from the assembler, swap_out_syms will have set up
3551 elf_section_syms. */
3552 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3553 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3555 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3557 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3559 /* The ELF backend linker sets sh_info to -2 when the group
3560 signature symbol is global, and thus the index can't be
3561 set until all local symbols are output. */
3563 struct bfd_elf_section_data
*sec_data
;
3564 unsigned long symndx
;
3565 unsigned long extsymoff
;
3566 struct elf_link_hash_entry
*h
;
3568 /* The point of this little dance to the first SHF_GROUP section
3569 then back to the SHT_GROUP section is that this gets us to
3570 the SHT_GROUP in the input object. */
3571 igroup
= elf_sec_group (elf_next_in_group (sec
));
3572 sec_data
= elf_section_data (igroup
);
3573 symndx
= sec_data
->this_hdr
.sh_info
;
3575 if (!elf_bad_symtab (igroup
->owner
))
3577 Elf_Internal_Shdr
*symtab_hdr
;
3579 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3580 extsymoff
= symtab_hdr
->sh_info
;
3582 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3583 while (h
->root
.type
== bfd_link_hash_indirect
3584 || h
->root
.type
== bfd_link_hash_warning
)
3585 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3587 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3590 /* The contents won't be allocated for "ld -r" or objcopy. */
3592 if (sec
->contents
== NULL
)
3595 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3597 /* Arrange for the section to be written out. */
3598 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3599 if (sec
->contents
== NULL
)
3606 loc
= sec
->contents
+ sec
->size
;
3608 /* Get the pointer to the first section in the group that gas
3609 squirreled away here. objcopy arranges for this to be set to the
3610 start of the input section group. */
3611 first
= elt
= elf_next_in_group (sec
);
3613 /* First element is a flag word. Rest of section is elf section
3614 indices for all the sections of the group. Write them backwards
3615 just to keep the group in the same order as given in .section
3616 directives, not that it matters. */
3623 s
= s
->output_section
;
3625 && !bfd_is_abs_section (s
))
3627 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3628 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3630 if (elf_sec
->rel
.hdr
!= NULL
3632 || (input_elf_sec
->rel
.hdr
!= NULL
3633 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3635 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3637 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3639 if (elf_sec
->rela
.hdr
!= NULL
3641 || (input_elf_sec
->rela
.hdr
!= NULL
3642 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3644 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3646 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3649 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3651 elt
= elf_next_in_group (elt
);
3657 BFD_ASSERT (loc
== sec
->contents
);
3659 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3662 /* Given NAME, the name of a relocation section stripped of its
3663 .rel/.rela prefix, return the section in ABFD to which the
3664 relocations apply. */
3667 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3669 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3670 section likely apply to .got.plt or .got section. */
3671 if (get_elf_backend_data (abfd
)->want_got_plt
3672 && strcmp (name
, ".plt") == 0)
3677 sec
= bfd_get_section_by_name (abfd
, name
);
3683 return bfd_get_section_by_name (abfd
, name
);
3686 /* Return the section to which RELOC_SEC applies. */
3689 elf_get_reloc_section (asection
*reloc_sec
)
3694 const struct elf_backend_data
*bed
;
3696 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3697 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3700 /* We look up the section the relocs apply to by name. */
3701 name
= reloc_sec
->name
;
3702 if (strncmp (name
, ".rel", 4) != 0)
3705 if (type
== SHT_RELA
&& *name
++ != 'a')
3708 abfd
= reloc_sec
->owner
;
3709 bed
= get_elf_backend_data (abfd
);
3710 return bed
->get_reloc_section (abfd
, name
);
3713 /* Assign all ELF section numbers. The dummy first section is handled here
3714 too. The link/info pointers for the standard section types are filled
3715 in here too, while we're at it. */
3718 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3720 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3722 unsigned int section_number
;
3723 Elf_Internal_Shdr
**i_shdrp
;
3724 struct bfd_elf_section_data
*d
;
3725 bfd_boolean need_symtab
;
3729 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3731 /* SHT_GROUP sections are in relocatable files only. */
3732 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3734 size_t reloc_count
= 0;
3736 /* Put SHT_GROUP sections first. */
3737 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3739 d
= elf_section_data (sec
);
3741 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3743 if (sec
->flags
& SEC_LINKER_CREATED
)
3745 /* Remove the linker created SHT_GROUP sections. */
3746 bfd_section_list_remove (abfd
, sec
);
3747 abfd
->section_count
--;
3750 d
->this_idx
= section_number
++;
3753 /* Count relocations. */
3754 reloc_count
+= sec
->reloc_count
;
3757 /* Clear HAS_RELOC if there are no relocations. */
3758 if (reloc_count
== 0)
3759 abfd
->flags
&= ~HAS_RELOC
;
3762 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3764 d
= elf_section_data (sec
);
3766 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3767 d
->this_idx
= section_number
++;
3768 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3769 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3772 d
->rel
.idx
= section_number
++;
3773 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3774 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3781 d
->rela
.idx
= section_number
++;
3782 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3783 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3789 need_symtab
= (bfd_get_symcount (abfd
) > 0
3790 || (link_info
== NULL
3791 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3795 elf_onesymtab (abfd
) = section_number
++;
3796 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3797 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3799 elf_section_list
*entry
;
3801 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3803 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3804 entry
->ndx
= section_number
++;
3805 elf_symtab_shndx_list (abfd
) = entry
;
3807 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3808 ".symtab_shndx", FALSE
);
3809 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3812 elf_strtab_sec (abfd
) = section_number
++;
3813 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3816 elf_shstrtab_sec (abfd
) = section_number
++;
3817 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3818 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3820 if (section_number
>= SHN_LORESERVE
)
3822 /* xgettext:c-format */
3823 _bfd_error_handler (_("%pB: too many sections: %u"),
3824 abfd
, section_number
);
3828 elf_numsections (abfd
) = section_number
;
3829 elf_elfheader (abfd
)->e_shnum
= section_number
;
3831 /* Set up the list of section header pointers, in agreement with the
3833 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3834 sizeof (Elf_Internal_Shdr
*));
3835 if (i_shdrp
== NULL
)
3838 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3839 sizeof (Elf_Internal_Shdr
));
3840 if (i_shdrp
[0] == NULL
)
3842 bfd_release (abfd
, i_shdrp
);
3846 elf_elfsections (abfd
) = i_shdrp
;
3848 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3851 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3852 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3854 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3855 BFD_ASSERT (entry
!= NULL
);
3856 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3857 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3859 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3860 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3863 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3867 d
= elf_section_data (sec
);
3869 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3870 if (d
->rel
.idx
!= 0)
3871 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3872 if (d
->rela
.idx
!= 0)
3873 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3875 /* Fill in the sh_link and sh_info fields while we're at it. */
3877 /* sh_link of a reloc section is the section index of the symbol
3878 table. sh_info is the section index of the section to which
3879 the relocation entries apply. */
3880 if (d
->rel
.idx
!= 0)
3882 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3883 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3884 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3886 if (d
->rela
.idx
!= 0)
3888 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3889 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3890 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3893 /* We need to set up sh_link for SHF_LINK_ORDER. */
3894 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3896 s
= elf_linked_to_section (sec
);
3899 /* elf_linked_to_section points to the input section. */
3900 if (link_info
!= NULL
)
3902 /* Check discarded linkonce section. */
3903 if (discarded_section (s
))
3907 /* xgettext:c-format */
3908 (_("%pB: sh_link of section `%pA' points to"
3909 " discarded section `%pA' of `%pB'"),
3910 abfd
, d
->this_hdr
.bfd_section
,
3912 /* Point to the kept section if it has the same
3913 size as the discarded one. */
3914 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3917 bfd_set_error (bfd_error_bad_value
);
3923 s
= s
->output_section
;
3924 BFD_ASSERT (s
!= NULL
);
3928 /* Handle objcopy. */
3929 if (s
->output_section
== NULL
)
3932 /* xgettext:c-format */
3933 (_("%pB: sh_link of section `%pA' points to"
3934 " removed section `%pA' of `%pB'"),
3935 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3936 bfd_set_error (bfd_error_bad_value
);
3939 s
= s
->output_section
;
3941 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3946 The Intel C compiler generates SHT_IA_64_UNWIND with
3947 SHF_LINK_ORDER. But it doesn't set the sh_link or
3948 sh_info fields. Hence we could get the situation
3950 const struct elf_backend_data
*bed
3951 = get_elf_backend_data (abfd
);
3952 if (bed
->link_order_error_handler
)
3953 bed
->link_order_error_handler
3954 /* xgettext:c-format */
3955 (_("%pB: warning: sh_link not set for section `%pA'"),
3960 switch (d
->this_hdr
.sh_type
)
3964 /* A reloc section which we are treating as a normal BFD
3965 section. sh_link is the section index of the symbol
3966 table. sh_info is the section index of the section to
3967 which the relocation entries apply. We assume that an
3968 allocated reloc section uses the dynamic symbol table.
3969 FIXME: How can we be sure? */
3970 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3972 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3974 s
= elf_get_reloc_section (sec
);
3977 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3978 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3983 /* We assume that a section named .stab*str is a stabs
3984 string section. We look for a section with the same name
3985 but without the trailing ``str'', and set its sh_link
3986 field to point to this section. */
3987 if (CONST_STRNEQ (sec
->name
, ".stab")
3988 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3993 len
= strlen (sec
->name
);
3994 alc
= (char *) bfd_malloc (len
- 2);
3997 memcpy (alc
, sec
->name
, len
- 3);
3998 alc
[len
- 3] = '\0';
3999 s
= bfd_get_section_by_name (abfd
, alc
);
4003 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
4005 /* This is a .stab section. */
4006 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
4007 elf_section_data (s
)->this_hdr
.sh_entsize
4008 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
4015 case SHT_GNU_verneed
:
4016 case SHT_GNU_verdef
:
4017 /* sh_link is the section header index of the string table
4018 used for the dynamic entries, or the symbol table, or the
4020 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4022 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4025 case SHT_GNU_LIBLIST
:
4026 /* sh_link is the section header index of the prelink library
4027 list used for the dynamic entries, or the symbol table, or
4028 the version strings. */
4029 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
4030 ? ".dynstr" : ".gnu.libstr");
4032 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4037 case SHT_GNU_versym
:
4038 /* sh_link is the section header index of the symbol table
4039 this hash table or version table is for. */
4040 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4042 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4046 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
4050 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
4051 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
4052 debug section name from .debug_* to .zdebug_* if needed. */
4058 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4060 /* If the backend has a special mapping, use it. */
4061 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4062 if (bed
->elf_backend_sym_is_global
)
4063 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4065 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4066 || bfd_is_und_section (bfd_asymbol_section (sym
))
4067 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4070 /* Filter global symbols of ABFD to include in the import library. All
4071 SYMCOUNT symbols of ABFD can be examined from their pointers in
4072 SYMS. Pointers of symbols to keep should be stored contiguously at
4073 the beginning of that array.
4075 Returns the number of symbols to keep. */
4078 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4079 asymbol
**syms
, long symcount
)
4081 long src_count
, dst_count
= 0;
4083 for (src_count
= 0; src_count
< symcount
; src_count
++)
4085 asymbol
*sym
= syms
[src_count
];
4086 char *name
= (char *) bfd_asymbol_name (sym
);
4087 struct bfd_link_hash_entry
*h
;
4089 if (!sym_is_global (abfd
, sym
))
4092 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
4095 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4097 if (h
->linker_def
|| h
->ldscript_def
)
4100 syms
[dst_count
++] = sym
;
4103 syms
[dst_count
] = NULL
;
4108 /* Don't output section symbols for sections that are not going to be
4109 output, that are duplicates or there is no BFD section. */
4112 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4114 elf_symbol_type
*type_ptr
;
4119 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4122 if (sym
->section
== NULL
)
4125 type_ptr
= elf_symbol_from (abfd
, sym
);
4126 return ((type_ptr
!= NULL
4127 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4128 && bfd_is_abs_section (sym
->section
))
4129 || !(sym
->section
->owner
== abfd
4130 || (sym
->section
->output_section
!= NULL
4131 && sym
->section
->output_section
->owner
== abfd
4132 && sym
->section
->output_offset
== 0)
4133 || bfd_is_abs_section (sym
->section
)));
4136 /* Map symbol from it's internal number to the external number, moving
4137 all local symbols to be at the head of the list. */
4140 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4142 unsigned int symcount
= bfd_get_symcount (abfd
);
4143 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4144 asymbol
**sect_syms
;
4145 unsigned int num_locals
= 0;
4146 unsigned int num_globals
= 0;
4147 unsigned int num_locals2
= 0;
4148 unsigned int num_globals2
= 0;
4149 unsigned int max_index
= 0;
4155 fprintf (stderr
, "elf_map_symbols\n");
4159 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4161 if (max_index
< asect
->index
)
4162 max_index
= asect
->index
;
4166 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
4167 if (sect_syms
== NULL
)
4169 elf_section_syms (abfd
) = sect_syms
;
4170 elf_num_section_syms (abfd
) = max_index
;
4172 /* Init sect_syms entries for any section symbols we have already
4173 decided to output. */
4174 for (idx
= 0; idx
< symcount
; idx
++)
4176 asymbol
*sym
= syms
[idx
];
4178 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4180 && !ignore_section_sym (abfd
, sym
)
4181 && !bfd_is_abs_section (sym
->section
))
4183 asection
*sec
= sym
->section
;
4185 if (sec
->owner
!= abfd
)
4186 sec
= sec
->output_section
;
4188 sect_syms
[sec
->index
] = syms
[idx
];
4192 /* Classify all of the symbols. */
4193 for (idx
= 0; idx
< symcount
; idx
++)
4195 if (sym_is_global (abfd
, syms
[idx
]))
4197 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4201 /* We will be adding a section symbol for each normal BFD section. Most
4202 sections will already have a section symbol in outsymbols, but
4203 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4204 at least in that case. */
4205 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4207 if (sect_syms
[asect
->index
] == NULL
)
4209 if (!sym_is_global (abfd
, asect
->symbol
))
4216 /* Now sort the symbols so the local symbols are first. */
4217 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
4218 sizeof (asymbol
*));
4220 if (new_syms
== NULL
)
4223 for (idx
= 0; idx
< symcount
; idx
++)
4225 asymbol
*sym
= syms
[idx
];
4228 if (sym_is_global (abfd
, sym
))
4229 i
= num_locals
+ num_globals2
++;
4230 else if (!ignore_section_sym (abfd
, sym
))
4235 sym
->udata
.i
= i
+ 1;
4237 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4239 if (sect_syms
[asect
->index
] == NULL
)
4241 asymbol
*sym
= asect
->symbol
;
4244 sect_syms
[asect
->index
] = sym
;
4245 if (!sym_is_global (abfd
, sym
))
4248 i
= num_locals
+ num_globals2
++;
4250 sym
->udata
.i
= i
+ 1;
4254 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4256 *pnum_locals
= num_locals
;
4260 /* Align to the maximum file alignment that could be required for any
4261 ELF data structure. */
4263 static inline file_ptr
4264 align_file_position (file_ptr off
, int align
)
4266 return (off
+ align
- 1) & ~(align
- 1);
4269 /* Assign a file position to a section, optionally aligning to the
4270 required section alignment. */
4273 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4277 if (align
&& i_shdrp
->sh_addralign
> 1)
4278 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4279 i_shdrp
->sh_offset
= offset
;
4280 if (i_shdrp
->bfd_section
!= NULL
)
4281 i_shdrp
->bfd_section
->filepos
= offset
;
4282 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4283 offset
+= i_shdrp
->sh_size
;
4287 /* Compute the file positions we are going to put the sections at, and
4288 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4289 is not NULL, this is being called by the ELF backend linker. */
4292 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4293 struct bfd_link_info
*link_info
)
4295 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4296 struct fake_section_arg fsargs
;
4298 struct elf_strtab_hash
*strtab
= NULL
;
4299 Elf_Internal_Shdr
*shstrtab_hdr
;
4300 bfd_boolean need_symtab
;
4302 if (abfd
->output_has_begun
)
4305 /* Do any elf backend specific processing first. */
4306 if (bed
->elf_backend_begin_write_processing
)
4307 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4309 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4312 fsargs
.failed
= FALSE
;
4313 fsargs
.link_info
= link_info
;
4314 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4318 if (!assign_section_numbers (abfd
, link_info
))
4321 /* The backend linker builds symbol table information itself. */
4322 need_symtab
= (link_info
== NULL
4323 && (bfd_get_symcount (abfd
) > 0
4324 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4328 /* Non-zero if doing a relocatable link. */
4329 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4331 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
4336 if (link_info
== NULL
)
4338 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4343 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4344 /* sh_name was set in init_file_header. */
4345 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4346 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4347 shstrtab_hdr
->sh_addr
= 0;
4348 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4349 shstrtab_hdr
->sh_entsize
= 0;
4350 shstrtab_hdr
->sh_link
= 0;
4351 shstrtab_hdr
->sh_info
= 0;
4352 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4353 shstrtab_hdr
->sh_addralign
= 1;
4355 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4361 Elf_Internal_Shdr
*hdr
;
4363 off
= elf_next_file_pos (abfd
);
4365 hdr
= & elf_symtab_hdr (abfd
);
4366 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4368 if (elf_symtab_shndx_list (abfd
) != NULL
)
4370 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4371 if (hdr
->sh_size
!= 0)
4372 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4373 /* FIXME: What about other symtab_shndx sections in the list ? */
4376 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4377 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4379 elf_next_file_pos (abfd
) = off
;
4381 /* Now that we know where the .strtab section goes, write it
4383 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4384 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4386 _bfd_elf_strtab_free (strtab
);
4389 abfd
->output_has_begun
= TRUE
;
4394 /* Make an initial estimate of the size of the program header. If we
4395 get the number wrong here, we'll redo section placement. */
4397 static bfd_size_type
4398 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4402 const struct elf_backend_data
*bed
;
4404 /* Assume we will need exactly two PT_LOAD segments: one for text
4405 and one for data. */
4408 s
= bfd_get_section_by_name (abfd
, ".interp");
4409 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4411 /* If we have a loadable interpreter section, we need a
4412 PT_INTERP segment. In this case, assume we also need a
4413 PT_PHDR segment, although that may not be true for all
4418 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4420 /* We need a PT_DYNAMIC segment. */
4424 if (info
!= NULL
&& info
->relro
)
4426 /* We need a PT_GNU_RELRO segment. */
4430 if (elf_eh_frame_hdr (abfd
))
4432 /* We need a PT_GNU_EH_FRAME segment. */
4436 if (elf_stack_flags (abfd
))
4438 /* We need a PT_GNU_STACK segment. */
4442 s
= bfd_get_section_by_name (abfd
,
4443 NOTE_GNU_PROPERTY_SECTION_NAME
);
4444 if (s
!= NULL
&& s
->size
!= 0)
4446 /* We need a PT_GNU_PROPERTY segment. */
4450 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4452 if ((s
->flags
& SEC_LOAD
) != 0
4453 && elf_section_type (s
) == SHT_NOTE
)
4455 unsigned int alignment_power
;
4456 /* We need a PT_NOTE segment. */
4458 /* Try to create just one PT_NOTE segment for all adjacent
4459 loadable SHT_NOTE sections. gABI requires that within a
4460 PT_NOTE segment (and also inside of each SHT_NOTE section)
4461 each note should have the same alignment. So we check
4462 whether the sections are correctly aligned. */
4463 alignment_power
= s
->alignment_power
;
4464 while (s
->next
!= NULL
4465 && s
->next
->alignment_power
== alignment_power
4466 && (s
->next
->flags
& SEC_LOAD
) != 0
4467 && elf_section_type (s
->next
) == SHT_NOTE
)
4472 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4474 if (s
->flags
& SEC_THREAD_LOCAL
)
4476 /* We need a PT_TLS segment. */
4482 bed
= get_elf_backend_data (abfd
);
4484 if ((abfd
->flags
& D_PAGED
) != 0
4485 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4487 /* Add a PT_GNU_MBIND segment for each mbind section. */
4488 unsigned int page_align_power
= bfd_log2 (bed
->commonpagesize
);
4489 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4490 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4492 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4495 /* xgettext:c-format */
4496 (_("%pB: GNU_MBIND section `%pA' has invalid "
4497 "sh_info field: %d"),
4498 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4501 /* Align mbind section to page size. */
4502 if (s
->alignment_power
< page_align_power
)
4503 s
->alignment_power
= page_align_power
;
4508 /* Let the backend count up any program headers it might need. */
4509 if (bed
->elf_backend_additional_program_headers
)
4513 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4519 return segs
* bed
->s
->sizeof_phdr
;
4522 /* Find the segment that contains the output_section of section. */
4525 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4527 struct elf_segment_map
*m
;
4528 Elf_Internal_Phdr
*p
;
4530 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4536 for (i
= m
->count
- 1; i
>= 0; i
--)
4537 if (m
->sections
[i
] == section
)
4544 /* Create a mapping from a set of sections to a program segment. */
4546 static struct elf_segment_map
*
4547 make_mapping (bfd
*abfd
,
4548 asection
**sections
,
4553 struct elf_segment_map
*m
;
4558 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4559 amt
+= (to
- from
) * sizeof (asection
*);
4560 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4564 m
->p_type
= PT_LOAD
;
4565 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4566 m
->sections
[i
- from
] = *hdrpp
;
4567 m
->count
= to
- from
;
4569 if (from
== 0 && phdr
)
4571 /* Include the headers in the first PT_LOAD segment. */
4572 m
->includes_filehdr
= 1;
4573 m
->includes_phdrs
= 1;
4579 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4582 struct elf_segment_map
*
4583 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4585 struct elf_segment_map
*m
;
4587 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4588 sizeof (struct elf_segment_map
));
4592 m
->p_type
= PT_DYNAMIC
;
4594 m
->sections
[0] = dynsec
;
4599 /* Possibly add or remove segments from the segment map. */
4602 elf_modify_segment_map (bfd
*abfd
,
4603 struct bfd_link_info
*info
,
4604 bfd_boolean remove_empty_load
)
4606 struct elf_segment_map
**m
;
4607 const struct elf_backend_data
*bed
;
4609 /* The placement algorithm assumes that non allocated sections are
4610 not in PT_LOAD segments. We ensure this here by removing such
4611 sections from the segment map. We also remove excluded
4612 sections. Finally, any PT_LOAD segment without sections is
4614 m
= &elf_seg_map (abfd
);
4617 unsigned int i
, new_count
;
4619 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4621 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4622 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4623 || (*m
)->p_type
!= PT_LOAD
))
4625 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4629 (*m
)->count
= new_count
;
4631 if (remove_empty_load
4632 && (*m
)->p_type
== PT_LOAD
4634 && !(*m
)->includes_phdrs
)
4640 bed
= get_elf_backend_data (abfd
);
4641 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4643 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4650 #define IS_TBSS(s) \
4651 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4653 /* Set up a mapping from BFD sections to program segments. */
4656 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4659 struct elf_segment_map
*m
;
4660 asection
**sections
= NULL
;
4661 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4662 bfd_boolean no_user_phdrs
;
4664 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4667 info
->user_phdrs
= !no_user_phdrs
;
4669 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4673 struct elf_segment_map
*mfirst
;
4674 struct elf_segment_map
**pm
;
4677 unsigned int hdr_index
;
4678 bfd_vma maxpagesize
;
4680 bfd_boolean phdr_in_segment
;
4681 bfd_boolean writable
;
4682 bfd_boolean executable
;
4684 asection
*first_tls
= NULL
;
4685 asection
*first_mbind
= NULL
;
4686 asection
*dynsec
, *eh_frame_hdr
;
4688 bfd_vma addr_mask
, wrap_to
= 0;
4689 bfd_size_type phdr_size
;
4691 /* Select the allocated sections, and sort them. */
4693 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4694 sizeof (asection
*));
4695 if (sections
== NULL
)
4698 /* Calculate top address, avoiding undefined behaviour of shift
4699 left operator when shift count is equal to size of type
4701 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4702 addr_mask
= (addr_mask
<< 1) + 1;
4705 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4707 if ((s
->flags
& SEC_ALLOC
) != 0)
4709 /* target_index is unused until bfd_elf_final_link
4710 starts output of section symbols. Use it to make
4712 s
->target_index
= i
;
4715 /* A wrapping section potentially clashes with header. */
4716 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4717 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4720 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4723 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4725 phdr_size
= elf_program_header_size (abfd
);
4726 if (phdr_size
== (bfd_size_type
) -1)
4727 phdr_size
= get_program_header_size (abfd
, info
);
4728 phdr_size
+= bed
->s
->sizeof_ehdr
;
4729 maxpagesize
= bed
->maxpagesize
;
4730 if (maxpagesize
== 0)
4732 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4734 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4735 >= (phdr_size
& (maxpagesize
- 1))))
4736 /* For compatibility with old scripts that may not be using
4737 SIZEOF_HEADERS, add headers when it looks like space has
4738 been left for them. */
4739 phdr_in_segment
= TRUE
;
4741 /* Build the mapping. */
4745 /* If we have a .interp section, then create a PT_PHDR segment for
4746 the program headers and a PT_INTERP segment for the .interp
4748 s
= bfd_get_section_by_name (abfd
, ".interp");
4749 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4751 amt
= sizeof (struct elf_segment_map
);
4752 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4756 m
->p_type
= PT_PHDR
;
4758 m
->p_flags_valid
= 1;
4759 m
->includes_phdrs
= 1;
4760 phdr_in_segment
= TRUE
;
4764 amt
= sizeof (struct elf_segment_map
);
4765 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4769 m
->p_type
= PT_INTERP
;
4777 /* Look through the sections. We put sections in the same program
4778 segment when the start of the second section can be placed within
4779 a few bytes of the end of the first section. */
4785 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4787 && (dynsec
->flags
& SEC_LOAD
) == 0)
4790 if ((abfd
->flags
& D_PAGED
) == 0)
4791 phdr_in_segment
= FALSE
;
4793 /* Deal with -Ttext or something similar such that the first section
4794 is not adjacent to the program headers. This is an
4795 approximation, since at this point we don't know exactly how many
4796 program headers we will need. */
4797 if (phdr_in_segment
&& count
> 0)
4800 bfd_boolean separate_phdr
= FALSE
;
4802 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4804 && info
->separate_code
4805 && (sections
[0]->flags
& SEC_CODE
) != 0)
4807 /* If data sections should be separate from code and
4808 thus not executable, and the first section is
4809 executable then put the file and program headers in
4810 their own PT_LOAD. */
4811 separate_phdr
= TRUE
;
4812 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4813 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4815 /* The file and program headers are currently on the
4816 same page as the first section. Put them on the
4817 previous page if we can. */
4818 if (phdr_lma
>= maxpagesize
)
4819 phdr_lma
-= maxpagesize
;
4821 separate_phdr
= FALSE
;
4824 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4825 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4826 /* If file and program headers would be placed at the end
4827 of memory then it's probably better to omit them. */
4828 phdr_in_segment
= FALSE
;
4829 else if (phdr_lma
< wrap_to
)
4830 /* If a section wraps around to where we'll be placing
4831 file and program headers, then the headers will be
4833 phdr_in_segment
= FALSE
;
4834 else if (separate_phdr
)
4836 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4839 m
->p_paddr
= phdr_lma
;
4841 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4842 m
->p_paddr_valid
= 1;
4845 phdr_in_segment
= FALSE
;
4849 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4852 bfd_boolean new_segment
;
4856 /* See if this section and the last one will fit in the same
4859 if (last_hdr
== NULL
)
4861 /* If we don't have a segment yet, then we don't need a new
4862 one (we build the last one after this loop). */
4863 new_segment
= FALSE
;
4865 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4867 /* If this section has a different relation between the
4868 virtual address and the load address, then we need a new
4872 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4873 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4875 /* If this section has a load address that makes it overlap
4876 the previous section, then we need a new segment. */
4879 else if ((abfd
->flags
& D_PAGED
) != 0
4880 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4881 == (hdr
->lma
& -maxpagesize
)))
4883 /* If we are demand paged then we can't map two disk
4884 pages onto the same memory page. */
4885 new_segment
= FALSE
;
4887 /* In the next test we have to be careful when last_hdr->lma is close
4888 to the end of the address space. If the aligned address wraps
4889 around to the start of the address space, then there are no more
4890 pages left in memory and it is OK to assume that the current
4891 section can be included in the current segment. */
4892 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4893 + maxpagesize
> last_hdr
->lma
)
4894 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4895 + maxpagesize
<= hdr
->lma
))
4897 /* If putting this section in this segment would force us to
4898 skip a page in the segment, then we need a new segment. */
4901 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4902 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4904 /* We don't want to put a loaded section after a
4905 nonloaded (ie. bss style) section in the same segment
4906 as that will force the non-loaded section to be loaded.
4907 Consider .tbss sections as loaded for this purpose. */
4910 else if ((abfd
->flags
& D_PAGED
) == 0)
4912 /* If the file is not demand paged, which means that we
4913 don't require the sections to be correctly aligned in the
4914 file, then there is no other reason for a new segment. */
4915 new_segment
= FALSE
;
4917 else if (info
!= NULL
4918 && info
->separate_code
4919 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4924 && (hdr
->flags
& SEC_READONLY
) == 0)
4926 /* We don't want to put a writable section in a read only
4932 /* Otherwise, we can use the same segment. */
4933 new_segment
= FALSE
;
4936 /* Allow interested parties a chance to override our decision. */
4937 if (last_hdr
!= NULL
4939 && info
->callbacks
->override_segment_assignment
!= NULL
)
4941 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4947 if ((hdr
->flags
& SEC_READONLY
) == 0)
4949 if ((hdr
->flags
& SEC_CODE
) != 0)
4952 /* .tbss sections effectively have zero size. */
4953 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4957 /* We need a new program segment. We must create a new program
4958 header holding all the sections from hdr_index until hdr. */
4960 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4967 if ((hdr
->flags
& SEC_READONLY
) == 0)
4972 if ((hdr
->flags
& SEC_CODE
) == 0)
4978 /* .tbss sections effectively have zero size. */
4979 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4981 phdr_in_segment
= FALSE
;
4984 /* Create a final PT_LOAD program segment, but not if it's just
4986 if (last_hdr
!= NULL
4987 && (i
- hdr_index
!= 1
4988 || !IS_TBSS (last_hdr
)))
4990 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4998 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
5001 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
5008 /* For each batch of consecutive loadable SHT_NOTE sections,
5009 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
5010 because if we link together nonloadable .note sections and
5011 loadable .note sections, we will generate two .note sections
5012 in the output file. */
5013 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5015 if ((s
->flags
& SEC_LOAD
) != 0
5016 && elf_section_type (s
) == SHT_NOTE
)
5019 unsigned int alignment_power
= s
->alignment_power
;
5022 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
5024 if (s2
->next
->alignment_power
== alignment_power
5025 && (s2
->next
->flags
& SEC_LOAD
) != 0
5026 && elf_section_type (s2
->next
) == SHT_NOTE
5027 && align_power (s2
->lma
+ s2
->size
,
5034 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5035 amt
+= count
* sizeof (asection
*);
5036 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5040 m
->p_type
= PT_NOTE
;
5044 m
->sections
[m
->count
- count
--] = s
;
5045 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5048 m
->sections
[m
->count
- 1] = s
;
5049 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5053 if (s
->flags
& SEC_THREAD_LOCAL
)
5059 if (first_mbind
== NULL
5060 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5064 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5067 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5068 amt
+= tls_count
* sizeof (asection
*);
5069 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5074 m
->count
= tls_count
;
5075 /* Mandated PF_R. */
5077 m
->p_flags_valid
= 1;
5079 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
5081 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5084 (_("%pB: TLS sections are not adjacent:"), abfd
);
5087 while (i
< (unsigned int) tls_count
)
5089 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5091 _bfd_error_handler (_(" TLS: %pA"), s
);
5095 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5098 bfd_set_error (bfd_error_bad_value
);
5110 && (abfd
->flags
& D_PAGED
) != 0
5111 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5112 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5113 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5114 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5116 /* Mandated PF_R. */
5117 unsigned long p_flags
= PF_R
;
5118 if ((s
->flags
& SEC_READONLY
) == 0)
5120 if ((s
->flags
& SEC_CODE
) != 0)
5123 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5124 m
= bfd_zalloc (abfd
, amt
);
5128 m
->p_type
= (PT_GNU_MBIND_LO
5129 + elf_section_data (s
)->this_hdr
.sh_info
);
5131 m
->p_flags_valid
= 1;
5133 m
->p_flags
= p_flags
;
5139 s
= bfd_get_section_by_name (abfd
,
5140 NOTE_GNU_PROPERTY_SECTION_NAME
);
5141 if (s
!= NULL
&& s
->size
!= 0)
5143 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5144 m
= bfd_zalloc (abfd
, amt
);
5148 m
->p_type
= PT_GNU_PROPERTY
;
5150 m
->p_flags_valid
= 1;
5157 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5159 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5160 if (eh_frame_hdr
!= NULL
5161 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5163 amt
= sizeof (struct elf_segment_map
);
5164 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5168 m
->p_type
= PT_GNU_EH_FRAME
;
5170 m
->sections
[0] = eh_frame_hdr
->output_section
;
5176 if (elf_stack_flags (abfd
))
5178 amt
= sizeof (struct elf_segment_map
);
5179 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5183 m
->p_type
= PT_GNU_STACK
;
5184 m
->p_flags
= elf_stack_flags (abfd
);
5185 m
->p_align
= bed
->stack_align
;
5186 m
->p_flags_valid
= 1;
5187 m
->p_align_valid
= m
->p_align
!= 0;
5188 if (info
->stacksize
> 0)
5190 m
->p_size
= info
->stacksize
;
5191 m
->p_size_valid
= 1;
5198 if (info
!= NULL
&& info
->relro
)
5200 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5202 if (m
->p_type
== PT_LOAD
5204 && m
->sections
[0]->vma
>= info
->relro_start
5205 && m
->sections
[0]->vma
< info
->relro_end
)
5208 while (--i
!= (unsigned) -1)
5209 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5210 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5213 if (i
!= (unsigned) -1)
5218 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5221 amt
= sizeof (struct elf_segment_map
);
5222 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5226 m
->p_type
= PT_GNU_RELRO
;
5233 elf_seg_map (abfd
) = mfirst
;
5236 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5239 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5241 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5246 if (sections
!= NULL
)
5251 /* Sort sections by address. */
5254 elf_sort_sections (const void *arg1
, const void *arg2
)
5256 const asection
*sec1
= *(const asection
**) arg1
;
5257 const asection
*sec2
= *(const asection
**) arg2
;
5258 bfd_size_type size1
, size2
;
5260 /* Sort by LMA first, since this is the address used to
5261 place the section into a segment. */
5262 if (sec1
->lma
< sec2
->lma
)
5264 else if (sec1
->lma
> sec2
->lma
)
5267 /* Then sort by VMA. Normally the LMA and the VMA will be
5268 the same, and this will do nothing. */
5269 if (sec1
->vma
< sec2
->vma
)
5271 else if (sec1
->vma
> sec2
->vma
)
5274 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5276 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5283 else if (TOEND (sec2
))
5288 /* Sort by size, to put zero sized sections
5289 before others at the same address. */
5291 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5292 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5299 return sec1
->target_index
- sec2
->target_index
;
5302 /* This qsort comparison functions sorts PT_LOAD segments first and
5303 by p_paddr, for assign_file_positions_for_load_sections. */
5306 elf_sort_segments (const void *arg1
, const void *arg2
)
5308 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5309 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5311 if (m1
->p_type
!= m2
->p_type
)
5313 if (m1
->p_type
== PT_NULL
)
5315 if (m2
->p_type
== PT_NULL
)
5317 return m1
->p_type
< m2
->p_type
? -1 : 1;
5319 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5320 return m1
->includes_filehdr
? -1 : 1;
5321 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5322 return m1
->no_sort_lma
? -1 : 1;
5323 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5327 if (m1
->p_paddr_valid
)
5329 else if (m1
->count
!= 0)
5330 lma1
= m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
;
5332 if (m2
->p_paddr_valid
)
5334 else if (m2
->count
!= 0)
5335 lma2
= m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
;
5337 return lma1
< lma2
? -1 : 1;
5339 if (m1
->idx
!= m2
->idx
)
5340 return m1
->idx
< m2
->idx
? -1 : 1;
5344 /* Ian Lance Taylor writes:
5346 We shouldn't be using % with a negative signed number. That's just
5347 not good. We have to make sure either that the number is not
5348 negative, or that the number has an unsigned type. When the types
5349 are all the same size they wind up as unsigned. When file_ptr is a
5350 larger signed type, the arithmetic winds up as signed long long,
5353 What we're trying to say here is something like ``increase OFF by
5354 the least amount that will cause it to be equal to the VMA modulo
5356 /* In other words, something like:
5358 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5359 off_offset = off % bed->maxpagesize;
5360 if (vma_offset < off_offset)
5361 adjustment = vma_offset + bed->maxpagesize - off_offset;
5363 adjustment = vma_offset - off_offset;
5365 which can be collapsed into the expression below. */
5368 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5370 /* PR binutils/16199: Handle an alignment of zero. */
5371 if (maxpagesize
== 0)
5373 return ((vma
- off
) % maxpagesize
);
5377 print_segment_map (const struct elf_segment_map
*m
)
5380 const char *pt
= get_segment_type (m
->p_type
);
5385 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5386 sprintf (buf
, "LOPROC+%7.7x",
5387 (unsigned int) (m
->p_type
- PT_LOPROC
));
5388 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5389 sprintf (buf
, "LOOS+%7.7x",
5390 (unsigned int) (m
->p_type
- PT_LOOS
));
5392 snprintf (buf
, sizeof (buf
), "%8.8x",
5393 (unsigned int) m
->p_type
);
5397 fprintf (stderr
, "%s:", pt
);
5398 for (j
= 0; j
< m
->count
; j
++)
5399 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5405 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5410 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5412 buf
= bfd_zmalloc (len
);
5415 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5420 /* Assign file positions to the sections based on the mapping from
5421 sections to segments. This function also sets up some fields in
5425 assign_file_positions_for_load_sections (bfd
*abfd
,
5426 struct bfd_link_info
*link_info
)
5428 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5429 struct elf_segment_map
*m
;
5430 struct elf_segment_map
*phdr_load_seg
;
5431 Elf_Internal_Phdr
*phdrs
;
5432 Elf_Internal_Phdr
*p
;
5434 bfd_size_type maxpagesize
;
5435 unsigned int alloc
, actual
;
5437 struct elf_segment_map
**sorted_seg_map
;
5439 if (link_info
== NULL
5440 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5444 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5449 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5450 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5454 /* PR binutils/12467. */
5455 elf_elfheader (abfd
)->e_phoff
= 0;
5456 elf_elfheader (abfd
)->e_phentsize
= 0;
5459 elf_elfheader (abfd
)->e_phnum
= alloc
;
5461 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5464 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5468 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5469 BFD_ASSERT (elf_program_header_size (abfd
)
5470 == actual
* bed
->s
->sizeof_phdr
);
5471 BFD_ASSERT (actual
>= alloc
);
5476 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5480 /* We're writing the size in elf_program_header_size (abfd),
5481 see assign_file_positions_except_relocs, so make sure we have
5482 that amount allocated, with trailing space cleared.
5483 The variable alloc contains the computed need, while
5484 elf_program_header_size (abfd) contains the size used for the
5486 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5487 where the layout is forced to according to a larger size in the
5488 last iterations for the testcase ld-elf/header. */
5489 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5490 + alloc
* sizeof (*sorted_seg_map
)));
5491 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5492 elf_tdata (abfd
)->phdr
= phdrs
;
5496 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5498 sorted_seg_map
[j
] = m
;
5499 /* If elf_segment_map is not from map_sections_to_segments, the
5500 sections may not be correctly ordered. NOTE: sorting should
5501 not be done to the PT_NOTE section of a corefile, which may
5502 contain several pseudo-sections artificially created by bfd.
5503 Sorting these pseudo-sections breaks things badly. */
5505 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5506 && m
->p_type
== PT_NOTE
))
5508 for (i
= 0; i
< m
->count
; i
++)
5509 m
->sections
[i
]->target_index
= i
;
5510 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5515 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5519 if ((abfd
->flags
& D_PAGED
) != 0)
5520 maxpagesize
= bed
->maxpagesize
;
5522 /* Sections must map to file offsets past the ELF file header. */
5523 off
= bed
->s
->sizeof_ehdr
;
5524 /* And if one of the PT_LOAD headers doesn't include the program
5525 headers then we'll be mapping program headers in the usual
5526 position after the ELF file header. */
5527 phdr_load_seg
= NULL
;
5528 for (j
= 0; j
< alloc
; j
++)
5530 m
= sorted_seg_map
[j
];
5531 if (m
->p_type
!= PT_LOAD
)
5533 if (m
->includes_phdrs
)
5539 if (phdr_load_seg
== NULL
)
5540 off
+= actual
* bed
->s
->sizeof_phdr
;
5542 for (j
= 0; j
< alloc
; j
++)
5546 bfd_boolean no_contents
;
5548 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5549 number of sections with contents contributing to both p_filesz
5550 and p_memsz, followed by a number of sections with no contents
5551 that just contribute to p_memsz. In this loop, OFF tracks next
5552 available file offset for PT_LOAD and PT_NOTE segments. */
5553 m
= sorted_seg_map
[j
];
5555 p
->p_type
= m
->p_type
;
5556 p
->p_flags
= m
->p_flags
;
5559 p
->p_vaddr
= m
->p_vaddr_offset
;
5561 p
->p_vaddr
= m
->sections
[0]->vma
+ m
->p_vaddr_offset
;
5563 if (m
->p_paddr_valid
)
5564 p
->p_paddr
= m
->p_paddr
;
5565 else if (m
->count
== 0)
5568 p
->p_paddr
= m
->sections
[0]->lma
+ m
->p_vaddr_offset
;
5570 if (p
->p_type
== PT_LOAD
5571 && (abfd
->flags
& D_PAGED
) != 0)
5573 /* p_align in demand paged PT_LOAD segments effectively stores
5574 the maximum page size. When copying an executable with
5575 objcopy, we set m->p_align from the input file. Use this
5576 value for maxpagesize rather than bed->maxpagesize, which
5577 may be different. Note that we use maxpagesize for PT_TLS
5578 segment alignment later in this function, so we are relying
5579 on at least one PT_LOAD segment appearing before a PT_TLS
5581 if (m
->p_align_valid
)
5582 maxpagesize
= m
->p_align
;
5584 p
->p_align
= maxpagesize
;
5586 else if (m
->p_align_valid
)
5587 p
->p_align
= m
->p_align
;
5588 else if (m
->count
== 0)
5589 p
->p_align
= 1 << bed
->s
->log_file_align
;
5591 if (m
== phdr_load_seg
)
5593 if (!m
->includes_filehdr
)
5595 off
+= actual
* bed
->s
->sizeof_phdr
;
5598 no_contents
= FALSE
;
5600 if (p
->p_type
== PT_LOAD
5603 bfd_size_type align
;
5604 unsigned int align_power
= 0;
5606 if (m
->p_align_valid
)
5610 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5612 unsigned int secalign
;
5614 secalign
= bfd_section_alignment (*secpp
);
5615 if (secalign
> align_power
)
5616 align_power
= secalign
;
5618 align
= (bfd_size_type
) 1 << align_power
;
5619 if (align
< maxpagesize
)
5620 align
= maxpagesize
;
5623 for (i
= 0; i
< m
->count
; i
++)
5624 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5625 /* If we aren't making room for this section, then
5626 it must be SHT_NOBITS regardless of what we've
5627 set via struct bfd_elf_special_section. */
5628 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5630 /* Find out whether this segment contains any loadable
5633 for (i
= 0; i
< m
->count
; i
++)
5634 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5636 no_contents
= FALSE
;
5640 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5642 /* Broken hardware and/or kernel require that files do not
5643 map the same page with different permissions on some hppa
5646 && (abfd
->flags
& D_PAGED
) != 0
5647 && bed
->no_page_alias
5648 && (off
& (maxpagesize
- 1)) != 0
5649 && (off
& -maxpagesize
) == ((off
+ off_adjust
) & -maxpagesize
))
5650 off_adjust
+= maxpagesize
;
5654 /* We shouldn't need to align the segment on disk since
5655 the segment doesn't need file space, but the gABI
5656 arguably requires the alignment and glibc ld.so
5657 checks it. So to comply with the alignment
5658 requirement but not waste file space, we adjust
5659 p_offset for just this segment. (OFF_ADJUST is
5660 subtracted from OFF later.) This may put p_offset
5661 past the end of file, but that shouldn't matter. */
5666 /* Make sure the .dynamic section is the first section in the
5667 PT_DYNAMIC segment. */
5668 else if (p
->p_type
== PT_DYNAMIC
5670 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5673 (_("%pB: The first section in the PT_DYNAMIC segment"
5674 " is not the .dynamic section"),
5676 bfd_set_error (bfd_error_bad_value
);
5679 /* Set the note section type to SHT_NOTE. */
5680 else if (p
->p_type
== PT_NOTE
)
5681 for (i
= 0; i
< m
->count
; i
++)
5682 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5684 if (m
->includes_filehdr
)
5686 if (!m
->p_flags_valid
)
5688 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5689 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5690 if (p
->p_type
== PT_LOAD
)
5694 if (p
->p_vaddr
< (bfd_vma
) off
5695 || (!m
->p_paddr_valid
5696 && p
->p_paddr
< (bfd_vma
) off
))
5699 (_("%pB: not enough room for program headers,"
5700 " try linking with -N"),
5702 bfd_set_error (bfd_error_bad_value
);
5706 if (!m
->p_paddr_valid
)
5710 else if (sorted_seg_map
[0]->includes_filehdr
)
5712 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5713 p
->p_vaddr
= filehdr
->p_vaddr
;
5714 if (!m
->p_paddr_valid
)
5715 p
->p_paddr
= filehdr
->p_paddr
;
5719 if (m
->includes_phdrs
)
5721 if (!m
->p_flags_valid
)
5723 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5724 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5725 if (!m
->includes_filehdr
)
5727 if (p
->p_type
== PT_LOAD
)
5729 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5732 p
->p_vaddr
-= off
- p
->p_offset
;
5733 if (!m
->p_paddr_valid
)
5734 p
->p_paddr
-= off
- p
->p_offset
;
5737 else if (phdr_load_seg
!= NULL
)
5739 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5740 bfd_vma phdr_off
= 0;
5741 if (phdr_load_seg
->includes_filehdr
)
5742 phdr_off
= bed
->s
->sizeof_ehdr
;
5743 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5744 if (!m
->p_paddr_valid
)
5745 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5746 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5749 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5753 if (p
->p_type
== PT_LOAD
5754 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5756 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5761 /* Put meaningless p_offset for PT_LOAD segments
5762 without file contents somewhere within the first
5763 page, in an attempt to not point past EOF. */
5764 bfd_size_type align
= maxpagesize
;
5765 if (align
< p
->p_align
)
5769 p
->p_offset
= off
% align
;
5776 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5778 p
->p_filesz
+= adjust
;
5779 p
->p_memsz
+= adjust
;
5783 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5784 maps. Set filepos for sections in PT_LOAD segments, and in
5785 core files, for sections in PT_NOTE segments.
5786 assign_file_positions_for_non_load_sections will set filepos
5787 for other sections and update p_filesz for other segments. */
5788 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5791 bfd_size_type align
;
5792 Elf_Internal_Shdr
*this_hdr
;
5795 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5796 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5798 if ((p
->p_type
== PT_LOAD
5799 || p
->p_type
== PT_TLS
)
5800 && (this_hdr
->sh_type
!= SHT_NOBITS
5801 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5802 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5803 || p
->p_type
== PT_TLS
))))
5805 bfd_vma p_start
= p
->p_paddr
;
5806 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5807 bfd_vma s_start
= sec
->lma
;
5808 bfd_vma adjust
= s_start
- p_end
;
5812 || p_end
< p_start
))
5815 /* xgettext:c-format */
5816 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5817 abfd
, sec
, (uint64_t) s_start
, (uint64_t) p_end
);
5821 p
->p_memsz
+= adjust
;
5823 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5825 if (p
->p_type
== PT_LOAD
)
5827 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5829 /* We have a PROGBITS section following NOBITS ones.
5830 Allocate file space for the NOBITS section(s) and
5832 adjust
= p
->p_memsz
- p
->p_filesz
;
5833 if (!write_zeros (abfd
, off
, adjust
))
5838 p
->p_filesz
+= adjust
;
5842 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5844 /* The section at i == 0 is the one that actually contains
5848 this_hdr
->sh_offset
= sec
->filepos
= off
;
5849 off
+= this_hdr
->sh_size
;
5850 p
->p_filesz
= this_hdr
->sh_size
;
5856 /* The rest are fake sections that shouldn't be written. */
5865 if (p
->p_type
== PT_LOAD
)
5867 this_hdr
->sh_offset
= sec
->filepos
= off
;
5868 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5869 off
+= this_hdr
->sh_size
;
5871 else if (this_hdr
->sh_type
== SHT_NOBITS
5872 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5873 && this_hdr
->sh_offset
== 0)
5875 /* This is a .tbss section that didn't get a PT_LOAD.
5876 (See _bfd_elf_map_sections_to_segments "Create a
5877 final PT_LOAD".) Set sh_offset to the value it
5878 would have if we had created a zero p_filesz and
5879 p_memsz PT_LOAD header for the section. This
5880 also makes the PT_TLS header have the same
5882 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5884 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5887 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5889 p
->p_filesz
+= this_hdr
->sh_size
;
5890 /* A load section without SHF_ALLOC is something like
5891 a note section in a PT_NOTE segment. These take
5892 file space but are not loaded into memory. */
5893 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5894 p
->p_memsz
+= this_hdr
->sh_size
;
5896 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5898 if (p
->p_type
== PT_TLS
)
5899 p
->p_memsz
+= this_hdr
->sh_size
;
5901 /* .tbss is special. It doesn't contribute to p_memsz of
5903 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5904 p
->p_memsz
+= this_hdr
->sh_size
;
5907 if (align
> p
->p_align
5908 && !m
->p_align_valid
5909 && (p
->p_type
!= PT_LOAD
5910 || (abfd
->flags
& D_PAGED
) == 0))
5914 if (!m
->p_flags_valid
)
5917 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5919 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5926 /* PR ld/20815 - Check that the program header segment, if
5927 present, will be loaded into memory. */
5928 if (p
->p_type
== PT_PHDR
5929 && phdr_load_seg
== NULL
5930 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5931 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5933 /* The fix for this error is usually to edit the linker script being
5934 used and set up the program headers manually. Either that or
5935 leave room for the headers at the start of the SECTIONS. */
5936 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5937 " by LOAD segment"),
5942 /* Check that all sections are in a PT_LOAD segment.
5943 Don't check funky gdb generated core files. */
5944 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5946 bfd_boolean check_vma
= TRUE
;
5948 for (i
= 1; i
< m
->count
; i
++)
5949 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5950 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5951 ->this_hdr
), p
) != 0
5952 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5953 ->this_hdr
), p
) != 0)
5955 /* Looks like we have overlays packed into the segment. */
5960 for (i
= 0; i
< m
->count
; i
++)
5962 Elf_Internal_Shdr
*this_hdr
;
5965 sec
= m
->sections
[i
];
5966 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5967 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5968 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5971 /* xgettext:c-format */
5972 (_("%pB: section `%pA' can't be allocated in segment %d"),
5974 print_segment_map (m
);
5980 elf_next_file_pos (abfd
) = off
;
5982 if (link_info
!= NULL
5983 && phdr_load_seg
!= NULL
5984 && phdr_load_seg
->includes_filehdr
)
5986 /* There is a segment that contains both the file headers and the
5987 program headers, so provide a symbol __ehdr_start pointing there.
5988 A program can use this to examine itself robustly. */
5990 struct elf_link_hash_entry
*hash
5991 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5992 FALSE
, FALSE
, TRUE
);
5993 /* If the symbol was referenced and not defined, define it. */
5995 && (hash
->root
.type
== bfd_link_hash_new
5996 || hash
->root
.type
== bfd_link_hash_undefined
5997 || hash
->root
.type
== bfd_link_hash_undefweak
5998 || hash
->root
.type
== bfd_link_hash_common
))
6001 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
;
6003 if (phdr_load_seg
->count
!= 0)
6004 /* The segment contains sections, so use the first one. */
6005 s
= phdr_load_seg
->sections
[0];
6007 /* Use the first (i.e. lowest-addressed) section in any segment. */
6008 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6009 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6017 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6018 hash
->root
.u
.def
.section
= s
;
6022 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6023 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6026 hash
->root
.type
= bfd_link_hash_defined
;
6027 hash
->def_regular
= 1;
6035 /* Determine if a bfd is a debuginfo file. Unfortunately there
6036 is no defined method for detecting such files, so we have to
6037 use heuristics instead. */
6040 is_debuginfo_file (bfd
*abfd
)
6042 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6045 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6046 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6047 Elf_Internal_Shdr
**headerp
;
6049 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6051 Elf_Internal_Shdr
*header
= * headerp
;
6053 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6054 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6055 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6056 && header
->sh_type
!= SHT_NOBITS
6057 && header
->sh_type
!= SHT_NOTE
)
6064 /* Assign file positions for the other sections, except for compressed debugging
6065 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6068 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6069 struct bfd_link_info
*link_info
)
6071 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6072 Elf_Internal_Shdr
**i_shdrpp
;
6073 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6074 Elf_Internal_Phdr
*phdrs
;
6075 Elf_Internal_Phdr
*p
;
6076 struct elf_segment_map
*m
;
6079 i_shdrpp
= elf_elfsections (abfd
);
6080 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6081 off
= elf_next_file_pos (abfd
);
6082 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6084 Elf_Internal_Shdr
*hdr
;
6087 if (hdr
->bfd_section
!= NULL
6088 && (hdr
->bfd_section
->filepos
!= 0
6089 || (hdr
->sh_type
== SHT_NOBITS
6090 && hdr
->contents
== NULL
)))
6091 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6092 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6094 if (hdr
->sh_size
!= 0
6095 /* PR 24717 - debuginfo files are known to be not strictly
6096 compliant with the ELF standard. In particular they often
6097 have .note.gnu.property sections that are outside of any
6098 loadable segment. This is not a problem for such files,
6099 so do not warn about them. */
6100 && ! is_debuginfo_file (abfd
))
6102 /* xgettext:c-format */
6103 (_("%pB: warning: allocated section `%s' not in segment"),
6105 (hdr
->bfd_section
== NULL
6107 : hdr
->bfd_section
->name
));
6108 /* We don't need to page align empty sections. */
6109 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6110 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6113 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6115 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6118 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6119 && hdr
->bfd_section
== NULL
)
6120 /* We don't know the offset of these sections yet: their size has
6121 not been decided. */
6122 || (hdr
->bfd_section
!= NULL
6123 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6124 || (bfd_section_is_ctf (hdr
->bfd_section
)
6125 && abfd
->is_linker_output
)))
6126 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6127 || (elf_symtab_shndx_list (abfd
) != NULL
6128 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6129 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6130 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6131 hdr
->sh_offset
= -1;
6133 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6135 elf_next_file_pos (abfd
) = off
;
6137 /* Now that we have set the section file positions, we can set up
6138 the file positions for the non PT_LOAD segments. */
6139 phdrs
= elf_tdata (abfd
)->phdr
;
6140 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6142 if (p
->p_type
== PT_GNU_RELRO
)
6147 if (link_info
!= NULL
)
6149 /* During linking the range of the RELRO segment is passed
6150 in link_info. Note that there may be padding between
6151 relro_start and the first RELRO section. */
6152 start
= link_info
->relro_start
;
6153 end
= link_info
->relro_end
;
6155 else if (m
->count
!= 0)
6157 if (!m
->p_size_valid
)
6159 start
= m
->sections
[0]->vma
;
6160 end
= start
+ m
->p_size
;
6171 struct elf_segment_map
*lm
;
6172 const Elf_Internal_Phdr
*lp
;
6175 /* Find a LOAD segment containing a section in the RELRO
6177 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6179 lm
= lm
->next
, lp
++)
6181 if (lp
->p_type
== PT_LOAD
6183 && (lm
->sections
[lm
->count
- 1]->vma
6184 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6185 ? lm
->sections
[lm
->count
- 1]->size
6187 && lm
->sections
[0]->vma
< end
)
6193 /* Find the section starting the RELRO segment. */
6194 for (i
= 0; i
< lm
->count
; i
++)
6196 asection
*s
= lm
->sections
[i
];
6205 p
->p_vaddr
= lm
->sections
[i
]->vma
;
6206 p
->p_paddr
= lm
->sections
[i
]->lma
;
6207 p
->p_offset
= lm
->sections
[i
]->filepos
;
6208 p
->p_memsz
= end
- p
->p_vaddr
;
6209 p
->p_filesz
= p
->p_memsz
;
6211 /* The RELRO segment typically ends a few bytes
6212 into .got.plt but other layouts are possible.
6213 In cases where the end does not match any
6214 loaded section (for instance is in file
6215 padding), trim p_filesz back to correspond to
6216 the end of loaded section contents. */
6217 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6218 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6220 /* Preserve the alignment and flags if they are
6221 valid. The gold linker generates RW/4 for
6222 the PT_GNU_RELRO section. It is better for
6223 objcopy/strip to honor these attributes
6224 otherwise gdb will choke when using separate
6226 if (!m
->p_align_valid
)
6228 if (!m
->p_flags_valid
)
6234 if (link_info
!= NULL
)
6237 memset (p
, 0, sizeof *p
);
6239 else if (p
->p_type
== PT_GNU_STACK
)
6241 if (m
->p_size_valid
)
6242 p
->p_memsz
= m
->p_size
;
6244 else if (m
->count
!= 0)
6248 if (p
->p_type
!= PT_LOAD
6249 && (p
->p_type
!= PT_NOTE
6250 || bfd_get_format (abfd
) != bfd_core
))
6252 /* A user specified segment layout may include a PHDR
6253 segment that overlaps with a LOAD segment... */
6254 if (p
->p_type
== PT_PHDR
)
6260 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6262 /* PR 17512: file: 2195325e. */
6264 (_("%pB: error: non-load segment %d includes file header "
6265 "and/or program header"),
6266 abfd
, (int) (p
- phdrs
));
6271 p
->p_offset
= m
->sections
[0]->filepos
;
6272 for (i
= m
->count
; i
-- != 0;)
6274 asection
*sect
= m
->sections
[i
];
6275 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6276 if (hdr
->sh_type
!= SHT_NOBITS
)
6278 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6290 static elf_section_list
*
6291 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6293 for (;list
!= NULL
; list
= list
->next
)
6299 /* Work out the file positions of all the sections. This is called by
6300 _bfd_elf_compute_section_file_positions. All the section sizes and
6301 VMAs must be known before this is called.
6303 Reloc sections come in two flavours: Those processed specially as
6304 "side-channel" data attached to a section to which they apply, and those that
6305 bfd doesn't process as relocations. The latter sort are stored in a normal
6306 bfd section by bfd_section_from_shdr. We don't consider the former sort
6307 here, unless they form part of the loadable image. Reloc sections not
6308 assigned here (and compressed debugging sections and CTF sections which
6309 nothing else in the file can rely upon) will be handled later by
6310 assign_file_positions_for_relocs.
6312 We also don't set the positions of the .symtab and .strtab here. */
6315 assign_file_positions_except_relocs (bfd
*abfd
,
6316 struct bfd_link_info
*link_info
)
6318 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6319 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6320 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6323 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6324 && bfd_get_format (abfd
) != bfd_core
)
6326 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6327 unsigned int num_sec
= elf_numsections (abfd
);
6328 Elf_Internal_Shdr
**hdrpp
;
6332 /* Start after the ELF header. */
6333 off
= i_ehdrp
->e_ehsize
;
6335 /* We are not creating an executable, which means that we are
6336 not creating a program header, and that the actual order of
6337 the sections in the file is unimportant. */
6338 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6340 Elf_Internal_Shdr
*hdr
;
6343 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6344 && hdr
->bfd_section
== NULL
)
6345 /* Do not assign offsets for these sections yet: we don't know
6347 || (hdr
->bfd_section
!= NULL
6348 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6349 || (bfd_section_is_ctf (hdr
->bfd_section
)
6350 && abfd
->is_linker_output
)))
6351 || i
== elf_onesymtab (abfd
)
6352 || (elf_symtab_shndx_list (abfd
) != NULL
6353 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6354 || i
== elf_strtab_sec (abfd
)
6355 || i
== elf_shstrtab_sec (abfd
))
6357 hdr
->sh_offset
= -1;
6360 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6363 elf_next_file_pos (abfd
) = off
;
6364 elf_program_header_size (abfd
) = 0;
6368 /* Assign file positions for the loaded sections based on the
6369 assignment of sections to segments. */
6370 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6373 /* And for non-load sections. */
6374 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6378 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6381 /* Write out the program headers. */
6382 alloc
= i_ehdrp
->e_phnum
;
6385 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6386 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6394 _bfd_elf_init_file_header (bfd
*abfd
,
6395 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6397 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6398 struct elf_strtab_hash
*shstrtab
;
6399 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6401 i_ehdrp
= elf_elfheader (abfd
);
6403 shstrtab
= _bfd_elf_strtab_init ();
6404 if (shstrtab
== NULL
)
6407 elf_shstrtab (abfd
) = shstrtab
;
6409 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6410 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6411 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6412 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6414 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6415 i_ehdrp
->e_ident
[EI_DATA
] =
6416 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6417 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6419 if ((abfd
->flags
& DYNAMIC
) != 0)
6420 i_ehdrp
->e_type
= ET_DYN
;
6421 else if ((abfd
->flags
& EXEC_P
) != 0)
6422 i_ehdrp
->e_type
= ET_EXEC
;
6423 else if (bfd_get_format (abfd
) == bfd_core
)
6424 i_ehdrp
->e_type
= ET_CORE
;
6426 i_ehdrp
->e_type
= ET_REL
;
6428 switch (bfd_get_arch (abfd
))
6430 case bfd_arch_unknown
:
6431 i_ehdrp
->e_machine
= EM_NONE
;
6434 /* There used to be a long list of cases here, each one setting
6435 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6436 in the corresponding bfd definition. To avoid duplication,
6437 the switch was removed. Machines that need special handling
6438 can generally do it in elf_backend_final_write_processing(),
6439 unless they need the information earlier than the final write.
6440 Such need can generally be supplied by replacing the tests for
6441 e_machine with the conditions used to determine it. */
6443 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6446 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6447 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6449 /* No program header, for now. */
6450 i_ehdrp
->e_phoff
= 0;
6451 i_ehdrp
->e_phentsize
= 0;
6452 i_ehdrp
->e_phnum
= 0;
6454 /* Each bfd section is section header entry. */
6455 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6456 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6458 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6459 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6460 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6461 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6462 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6463 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6464 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6465 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6466 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6472 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6474 FIXME: We used to have code here to sort the PT_LOAD segments into
6475 ascending order, as per the ELF spec. But this breaks some programs,
6476 including the Linux kernel. But really either the spec should be
6477 changed or the programs updated. */
6480 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6482 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6484 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6485 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6486 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6487 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6488 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6490 /* Find the lowest p_vaddr in PT_LOAD segments. */
6491 bfd_vma p_vaddr
= (bfd_vma
) -1;
6492 for (; segment
< end_segment
; segment
++)
6493 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6494 p_vaddr
= segment
->p_vaddr
;
6496 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6497 segments is non-zero. */
6499 i_ehdrp
->e_type
= ET_EXEC
;
6504 /* Assign file positions for all the reloc sections which are not part
6505 of the loadable file image, and the file position of section headers. */
6508 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6511 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6512 Elf_Internal_Shdr
*shdrp
;
6513 Elf_Internal_Ehdr
*i_ehdrp
;
6514 const struct elf_backend_data
*bed
;
6516 off
= elf_next_file_pos (abfd
);
6518 shdrpp
= elf_elfsections (abfd
);
6519 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6520 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6523 if (shdrp
->sh_offset
== -1)
6525 asection
*sec
= shdrp
->bfd_section
;
6526 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6527 || shdrp
->sh_type
== SHT_RELA
);
6528 bfd_boolean is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6531 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6533 if (!is_rel
&& !is_ctf
)
6535 const char *name
= sec
->name
;
6536 struct bfd_elf_section_data
*d
;
6538 /* Compress DWARF debug sections. */
6539 if (!bfd_compress_section (abfd
, sec
,
6543 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6544 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6546 /* If section is compressed with zlib-gnu, convert
6547 section name from .debug_* to .zdebug_*. */
6549 = convert_debug_to_zdebug (abfd
, name
);
6550 if (new_name
== NULL
)
6554 /* Add section name to section name section. */
6555 if (shdrp
->sh_name
!= (unsigned int) -1)
6558 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6560 d
= elf_section_data (sec
);
6562 /* Add reloc section name to section name section. */
6564 && !_bfd_elf_set_reloc_sh_name (abfd
,
6569 && !_bfd_elf_set_reloc_sh_name (abfd
,
6574 /* Update section size and contents. */
6575 shdrp
->sh_size
= sec
->size
;
6576 shdrp
->contents
= sec
->contents
;
6577 shdrp
->bfd_section
->contents
= NULL
;
6581 /* Update section size and contents. */
6582 shdrp
->sh_size
= sec
->size
;
6583 shdrp
->contents
= sec
->contents
;
6586 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6593 /* Place section name section after DWARF debug sections have been
6595 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6596 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6597 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6598 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6600 /* Place the section headers. */
6601 i_ehdrp
= elf_elfheader (abfd
);
6602 bed
= get_elf_backend_data (abfd
);
6603 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6604 i_ehdrp
->e_shoff
= off
;
6605 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6606 elf_next_file_pos (abfd
) = off
;
6612 _bfd_elf_write_object_contents (bfd
*abfd
)
6614 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6615 Elf_Internal_Shdr
**i_shdrp
;
6617 unsigned int count
, num_sec
;
6618 struct elf_obj_tdata
*t
;
6620 if (! abfd
->output_has_begun
6621 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6623 /* Do not rewrite ELF data when the BFD has been opened for update.
6624 abfd->output_has_begun was set to TRUE on opening, so creation of new
6625 sections, and modification of existing section sizes was restricted.
6626 This means the ELF header, program headers and section headers can't have
6628 If the contents of any sections has been modified, then those changes have
6629 already been written to the BFD. */
6630 else if (abfd
->direction
== both_direction
)
6632 BFD_ASSERT (abfd
->output_has_begun
);
6636 i_shdrp
= elf_elfsections (abfd
);
6639 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6643 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6646 /* After writing the headers, we need to write the sections too... */
6647 num_sec
= elf_numsections (abfd
);
6648 for (count
= 1; count
< num_sec
; count
++)
6650 i_shdrp
[count
]->sh_name
6651 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6652 i_shdrp
[count
]->sh_name
);
6653 if (bed
->elf_backend_section_processing
)
6654 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6656 if (i_shdrp
[count
]->contents
)
6658 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6660 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6661 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6666 /* Write out the section header names. */
6667 t
= elf_tdata (abfd
);
6668 if (elf_shstrtab (abfd
) != NULL
6669 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6670 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6673 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6676 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6679 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6680 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6681 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6687 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6689 /* Hopefully this can be done just like an object file. */
6690 return _bfd_elf_write_object_contents (abfd
);
6693 /* Given a section, search the header to find them. */
6696 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6698 const struct elf_backend_data
*bed
;
6699 unsigned int sec_index
;
6701 if (elf_section_data (asect
) != NULL
6702 && elf_section_data (asect
)->this_idx
!= 0)
6703 return elf_section_data (asect
)->this_idx
;
6705 if (bfd_is_abs_section (asect
))
6706 sec_index
= SHN_ABS
;
6707 else if (bfd_is_com_section (asect
))
6708 sec_index
= SHN_COMMON
;
6709 else if (bfd_is_und_section (asect
))
6710 sec_index
= SHN_UNDEF
;
6712 sec_index
= SHN_BAD
;
6714 bed
= get_elf_backend_data (abfd
);
6715 if (bed
->elf_backend_section_from_bfd_section
)
6717 int retval
= sec_index
;
6719 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6723 if (sec_index
== SHN_BAD
)
6724 bfd_set_error (bfd_error_nonrepresentable_section
);
6729 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6733 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6735 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6737 flagword flags
= asym_ptr
->flags
;
6739 /* When gas creates relocations against local labels, it creates its
6740 own symbol for the section, but does put the symbol into the
6741 symbol chain, so udata is 0. When the linker is generating
6742 relocatable output, this section symbol may be for one of the
6743 input sections rather than the output section. */
6744 if (asym_ptr
->udata
.i
== 0
6745 && (flags
& BSF_SECTION_SYM
)
6746 && asym_ptr
->section
)
6751 sec
= asym_ptr
->section
;
6752 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6753 sec
= sec
->output_section
;
6754 if (sec
->owner
== abfd
6755 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6756 && elf_section_syms (abfd
)[indx
] != NULL
)
6757 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6760 idx
= asym_ptr
->udata
.i
;
6764 /* This case can occur when using --strip-symbol on a symbol
6765 which is used in a relocation entry. */
6767 /* xgettext:c-format */
6768 (_("%pB: symbol `%s' required but not present"),
6769 abfd
, bfd_asymbol_name (asym_ptr
));
6770 bfd_set_error (bfd_error_no_symbols
);
6777 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6778 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6786 /* Rewrite program header information. */
6789 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6791 Elf_Internal_Ehdr
*iehdr
;
6792 struct elf_segment_map
*map
;
6793 struct elf_segment_map
*map_first
;
6794 struct elf_segment_map
**pointer_to_map
;
6795 Elf_Internal_Phdr
*segment
;
6798 unsigned int num_segments
;
6799 bfd_boolean phdr_included
= FALSE
;
6800 bfd_boolean p_paddr_valid
;
6801 bfd_vma maxpagesize
;
6802 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6803 unsigned int phdr_adjust_num
= 0;
6804 const struct elf_backend_data
*bed
;
6806 bed
= get_elf_backend_data (ibfd
);
6807 iehdr
= elf_elfheader (ibfd
);
6810 pointer_to_map
= &map_first
;
6812 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6813 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6815 /* Returns the end address of the segment + 1. */
6816 #define SEGMENT_END(segment, start) \
6817 (start + (segment->p_memsz > segment->p_filesz \
6818 ? segment->p_memsz : segment->p_filesz))
6820 #define SECTION_SIZE(section, segment) \
6821 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6822 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6823 ? section->size : 0)
6825 /* Returns TRUE if the given section is contained within
6826 the given segment. VMA addresses are compared. */
6827 #define IS_CONTAINED_BY_VMA(section, segment) \
6828 (section->vma >= segment->p_vaddr \
6829 && (section->vma + SECTION_SIZE (section, segment) \
6830 <= (SEGMENT_END (segment, segment->p_vaddr))))
6832 /* Returns TRUE if the given section is contained within
6833 the given segment. LMA addresses are compared. */
6834 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6835 (section->lma >= base \
6836 && (section->lma + SECTION_SIZE (section, segment) >= section->lma) \
6837 && (section->lma + SECTION_SIZE (section, segment) \
6838 <= SEGMENT_END (segment, base)))
6840 /* Handle PT_NOTE segment. */
6841 #define IS_NOTE(p, s) \
6842 (p->p_type == PT_NOTE \
6843 && elf_section_type (s) == SHT_NOTE \
6844 && (bfd_vma) s->filepos >= p->p_offset \
6845 && ((bfd_vma) s->filepos + s->size \
6846 <= p->p_offset + p->p_filesz))
6848 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6850 #define IS_COREFILE_NOTE(p, s) \
6852 && bfd_get_format (ibfd) == bfd_core \
6856 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6857 linker, which generates a PT_INTERP section with p_vaddr and
6858 p_memsz set to 0. */
6859 #define IS_SOLARIS_PT_INTERP(p, s) \
6861 && p->p_paddr == 0 \
6862 && p->p_memsz == 0 \
6863 && p->p_filesz > 0 \
6864 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6866 && (bfd_vma) s->filepos >= p->p_offset \
6867 && ((bfd_vma) s->filepos + s->size \
6868 <= p->p_offset + p->p_filesz))
6870 /* Decide if the given section should be included in the given segment.
6871 A section will be included if:
6872 1. It is within the address space of the segment -- we use the LMA
6873 if that is set for the segment and the VMA otherwise,
6874 2. It is an allocated section or a NOTE section in a PT_NOTE
6876 3. There is an output section associated with it,
6877 4. The section has not already been allocated to a previous segment.
6878 5. PT_GNU_STACK segments do not include any sections.
6879 6. PT_TLS segment includes only SHF_TLS sections.
6880 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6881 8. PT_DYNAMIC should not contain empty sections at the beginning
6882 (with the possible exception of .dynamic). */
6883 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6884 ((((segment->p_paddr \
6885 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6886 : IS_CONTAINED_BY_VMA (section, segment)) \
6887 && (section->flags & SEC_ALLOC) != 0) \
6888 || IS_NOTE (segment, section)) \
6889 && segment->p_type != PT_GNU_STACK \
6890 && (segment->p_type != PT_TLS \
6891 || (section->flags & SEC_THREAD_LOCAL)) \
6892 && (segment->p_type == PT_LOAD \
6893 || segment->p_type == PT_TLS \
6894 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6895 && (segment->p_type != PT_DYNAMIC \
6896 || SECTION_SIZE (section, segment) > 0 \
6897 || (segment->p_paddr \
6898 ? segment->p_paddr != section->lma \
6899 : segment->p_vaddr != section->vma) \
6900 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6901 && (segment->p_type != PT_LOAD || !section->segment_mark))
6903 /* If the output section of a section in the input segment is NULL,
6904 it is removed from the corresponding output segment. */
6905 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6906 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6907 && section->output_section != NULL)
6909 /* Returns TRUE iff seg1 starts after the end of seg2. */
6910 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6911 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6913 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6914 their VMA address ranges and their LMA address ranges overlap.
6915 It is possible to have overlapping VMA ranges without overlapping LMA
6916 ranges. RedBoot images for example can have both .data and .bss mapped
6917 to the same VMA range, but with the .data section mapped to a different
6919 #define SEGMENT_OVERLAPS(seg1, seg2) \
6920 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6921 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6922 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6923 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6925 /* Initialise the segment mark field. */
6926 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6927 section
->segment_mark
= FALSE
;
6929 /* The Solaris linker creates program headers in which all the
6930 p_paddr fields are zero. When we try to objcopy or strip such a
6931 file, we get confused. Check for this case, and if we find it
6932 don't set the p_paddr_valid fields. */
6933 p_paddr_valid
= FALSE
;
6934 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6937 if (segment
->p_paddr
!= 0)
6939 p_paddr_valid
= TRUE
;
6943 /* Scan through the segments specified in the program header
6944 of the input BFD. For this first scan we look for overlaps
6945 in the loadable segments. These can be created by weird
6946 parameters to objcopy. Also, fix some solaris weirdness. */
6947 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6952 Elf_Internal_Phdr
*segment2
;
6954 if (segment
->p_type
== PT_INTERP
)
6955 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6956 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6958 /* Mininal change so that the normal section to segment
6959 assignment code will work. */
6960 segment
->p_vaddr
= section
->vma
;
6964 if (segment
->p_type
!= PT_LOAD
)
6966 /* Remove PT_GNU_RELRO segment. */
6967 if (segment
->p_type
== PT_GNU_RELRO
)
6968 segment
->p_type
= PT_NULL
;
6972 /* Determine if this segment overlaps any previous segments. */
6973 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6975 bfd_signed_vma extra_length
;
6977 if (segment2
->p_type
!= PT_LOAD
6978 || !SEGMENT_OVERLAPS (segment
, segment2
))
6981 /* Merge the two segments together. */
6982 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6984 /* Extend SEGMENT2 to include SEGMENT and then delete
6986 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6987 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6989 if (extra_length
> 0)
6991 segment2
->p_memsz
+= extra_length
;
6992 segment2
->p_filesz
+= extra_length
;
6995 segment
->p_type
= PT_NULL
;
6997 /* Since we have deleted P we must restart the outer loop. */
6999 segment
= elf_tdata (ibfd
)->phdr
;
7004 /* Extend SEGMENT to include SEGMENT2 and then delete
7006 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7007 - SEGMENT_END (segment
, segment
->p_vaddr
));
7009 if (extra_length
> 0)
7011 segment
->p_memsz
+= extra_length
;
7012 segment
->p_filesz
+= extra_length
;
7015 segment2
->p_type
= PT_NULL
;
7020 /* The second scan attempts to assign sections to segments. */
7021 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7025 unsigned int section_count
;
7026 asection
**sections
;
7027 asection
*output_section
;
7029 asection
*matching_lma
;
7030 asection
*suggested_lma
;
7033 asection
*first_section
;
7035 if (segment
->p_type
== PT_NULL
)
7038 first_section
= NULL
;
7039 /* Compute how many sections might be placed into this segment. */
7040 for (section
= ibfd
->sections
, section_count
= 0;
7042 section
= section
->next
)
7044 /* Find the first section in the input segment, which may be
7045 removed from the corresponding output segment. */
7046 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
7048 if (first_section
== NULL
)
7049 first_section
= section
;
7050 if (section
->output_section
!= NULL
)
7055 /* Allocate a segment map big enough to contain
7056 all of the sections we have selected. */
7057 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7058 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7059 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7063 /* Initialise the fields of the segment map. Default to
7064 using the physical address of the segment in the input BFD. */
7066 map
->p_type
= segment
->p_type
;
7067 map
->p_flags
= segment
->p_flags
;
7068 map
->p_flags_valid
= 1;
7070 /* If the first section in the input segment is removed, there is
7071 no need to preserve segment physical address in the corresponding
7073 if (!first_section
|| first_section
->output_section
!= NULL
)
7075 map
->p_paddr
= segment
->p_paddr
;
7076 map
->p_paddr_valid
= p_paddr_valid
;
7079 /* Determine if this segment contains the ELF file header
7080 and if it contains the program headers themselves. */
7081 map
->includes_filehdr
= (segment
->p_offset
== 0
7082 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7083 map
->includes_phdrs
= 0;
7085 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7087 map
->includes_phdrs
=
7088 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7089 && (segment
->p_offset
+ segment
->p_filesz
7090 >= ((bfd_vma
) iehdr
->e_phoff
7091 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7093 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7094 phdr_included
= TRUE
;
7097 if (section_count
== 0)
7099 /* Special segments, such as the PT_PHDR segment, may contain
7100 no sections, but ordinary, loadable segments should contain
7101 something. They are allowed by the ELF spec however, so only
7102 a warning is produced.
7103 There is however the valid use case of embedded systems which
7104 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7105 flash memory with zeros. No warning is shown for that case. */
7106 if (segment
->p_type
== PT_LOAD
7107 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7108 /* xgettext:c-format */
7110 (_("%pB: warning: empty loadable segment detected"
7111 " at vaddr=%#" PRIx64
", is this intentional?"),
7112 ibfd
, (uint64_t) segment
->p_vaddr
);
7114 map
->p_vaddr_offset
= segment
->p_vaddr
;
7116 *pointer_to_map
= map
;
7117 pointer_to_map
= &map
->next
;
7122 /* Now scan the sections in the input BFD again and attempt
7123 to add their corresponding output sections to the segment map.
7124 The problem here is how to handle an output section which has
7125 been moved (ie had its LMA changed). There are four possibilities:
7127 1. None of the sections have been moved.
7128 In this case we can continue to use the segment LMA from the
7131 2. All of the sections have been moved by the same amount.
7132 In this case we can change the segment's LMA to match the LMA
7133 of the first section.
7135 3. Some of the sections have been moved, others have not.
7136 In this case those sections which have not been moved can be
7137 placed in the current segment which will have to have its size,
7138 and possibly its LMA changed, and a new segment or segments will
7139 have to be created to contain the other sections.
7141 4. The sections have been moved, but not by the same amount.
7142 In this case we can change the segment's LMA to match the LMA
7143 of the first section and we will have to create a new segment
7144 or segments to contain the other sections.
7146 In order to save time, we allocate an array to hold the section
7147 pointers that we are interested in. As these sections get assigned
7148 to a segment, they are removed from this array. */
7150 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
7151 if (sections
== NULL
)
7154 /* Step One: Scan for segment vs section LMA conflicts.
7155 Also add the sections to the section array allocated above.
7156 Also add the sections to the current segment. In the common
7157 case, where the sections have not been moved, this means that
7158 we have completely filled the segment, and there is nothing
7161 matching_lma
= NULL
;
7162 suggested_lma
= NULL
;
7164 for (section
= first_section
, j
= 0;
7166 section
= section
->next
)
7168 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
7170 output_section
= section
->output_section
;
7172 sections
[j
++] = section
;
7174 /* The Solaris native linker always sets p_paddr to 0.
7175 We try to catch that case here, and set it to the
7176 correct value. Note - some backends require that
7177 p_paddr be left as zero. */
7179 && segment
->p_vaddr
!= 0
7180 && !bed
->want_p_paddr_set_to_zero
7182 && output_section
->lma
!= 0
7183 && (align_power (segment
->p_vaddr
7184 + (map
->includes_filehdr
7185 ? iehdr
->e_ehsize
: 0)
7186 + (map
->includes_phdrs
7187 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7189 output_section
->alignment_power
)
7190 == output_section
->vma
))
7191 map
->p_paddr
= segment
->p_vaddr
;
7193 /* Match up the physical address of the segment with the
7194 LMA address of the output section. */
7195 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7196 || IS_COREFILE_NOTE (segment
, section
)
7197 || (bed
->want_p_paddr_set_to_zero
7198 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
7200 if (matching_lma
== NULL
7201 || output_section
->lma
< matching_lma
->lma
)
7202 matching_lma
= output_section
;
7204 /* We assume that if the section fits within the segment
7205 then it does not overlap any other section within that
7207 map
->sections
[isec
++] = output_section
;
7209 else if (suggested_lma
== NULL
)
7210 suggested_lma
= output_section
;
7212 if (j
== section_count
)
7217 BFD_ASSERT (j
== section_count
);
7219 /* Step Two: Adjust the physical address of the current segment,
7221 if (isec
== section_count
)
7223 /* All of the sections fitted within the segment as currently
7224 specified. This is the default case. Add the segment to
7225 the list of built segments and carry on to process the next
7226 program header in the input BFD. */
7227 map
->count
= section_count
;
7228 *pointer_to_map
= map
;
7229 pointer_to_map
= &map
->next
;
7232 && !bed
->want_p_paddr_set_to_zero
)
7234 bfd_vma hdr_size
= 0;
7235 if (map
->includes_filehdr
)
7236 hdr_size
= iehdr
->e_ehsize
;
7237 if (map
->includes_phdrs
)
7238 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7240 /* Account for padding before the first section in the
7242 map
->p_vaddr_offset
= map
->p_paddr
+ hdr_size
- matching_lma
->lma
;
7250 /* Change the current segment's physical address to match
7251 the LMA of the first section that fitted, or if no
7252 section fitted, the first section. */
7253 if (matching_lma
== NULL
)
7254 matching_lma
= suggested_lma
;
7256 map
->p_paddr
= matching_lma
->lma
;
7258 /* Offset the segment physical address from the lma
7259 to allow for space taken up by elf headers. */
7260 if (map
->includes_phdrs
)
7262 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7264 /* iehdr->e_phnum is just an estimate of the number
7265 of program headers that we will need. Make a note
7266 here of the number we used and the segment we chose
7267 to hold these headers, so that we can adjust the
7268 offset when we know the correct value. */
7269 phdr_adjust_num
= iehdr
->e_phnum
;
7270 phdr_adjust_seg
= map
;
7273 if (map
->includes_filehdr
)
7275 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7276 map
->p_paddr
-= iehdr
->e_ehsize
;
7277 /* We've subtracted off the size of headers from the
7278 first section lma, but there may have been some
7279 alignment padding before that section too. Try to
7280 account for that by adjusting the segment lma down to
7281 the same alignment. */
7282 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7283 align
= segment
->p_align
;
7284 map
->p_paddr
&= -align
;
7288 /* Step Three: Loop over the sections again, this time assigning
7289 those that fit to the current segment and removing them from the
7290 sections array; but making sure not to leave large gaps. Once all
7291 possible sections have been assigned to the current segment it is
7292 added to the list of built segments and if sections still remain
7293 to be assigned, a new segment is constructed before repeating
7299 suggested_lma
= NULL
;
7301 /* Fill the current segment with sections that fit. */
7302 for (j
= 0; j
< section_count
; j
++)
7304 section
= sections
[j
];
7306 if (section
== NULL
)
7309 output_section
= section
->output_section
;
7311 BFD_ASSERT (output_section
!= NULL
);
7313 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7314 || IS_COREFILE_NOTE (segment
, section
))
7316 if (map
->count
== 0)
7318 /* If the first section in a segment does not start at
7319 the beginning of the segment, then something is
7321 if (align_power (map
->p_paddr
7322 + (map
->includes_filehdr
7323 ? iehdr
->e_ehsize
: 0)
7324 + (map
->includes_phdrs
7325 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7327 output_section
->alignment_power
)
7328 != output_section
->lma
)
7335 prev_sec
= map
->sections
[map
->count
- 1];
7337 /* If the gap between the end of the previous section
7338 and the start of this section is more than
7339 maxpagesize then we need to start a new segment. */
7340 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7342 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7343 || (prev_sec
->lma
+ prev_sec
->size
7344 > output_section
->lma
))
7346 if (suggested_lma
== NULL
)
7347 suggested_lma
= output_section
;
7353 map
->sections
[map
->count
++] = output_section
;
7356 if (segment
->p_type
== PT_LOAD
)
7357 section
->segment_mark
= TRUE
;
7359 else if (suggested_lma
== NULL
)
7360 suggested_lma
= output_section
;
7363 /* PR 23932. A corrupt input file may contain sections that cannot
7364 be assigned to any segment - because for example they have a
7365 negative size - or segments that do not contain any sections.
7366 But there are also valid reasons why a segment can be empty.
7367 So allow a count of zero. */
7369 /* Add the current segment to the list of built segments. */
7370 *pointer_to_map
= map
;
7371 pointer_to_map
= &map
->next
;
7373 if (isec
< section_count
)
7375 /* We still have not allocated all of the sections to
7376 segments. Create a new segment here, initialise it
7377 and carry on looping. */
7378 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7379 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7380 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7387 /* Initialise the fields of the segment map. Set the physical
7388 physical address to the LMA of the first section that has
7389 not yet been assigned. */
7391 map
->p_type
= segment
->p_type
;
7392 map
->p_flags
= segment
->p_flags
;
7393 map
->p_flags_valid
= 1;
7394 map
->p_paddr
= suggested_lma
->lma
;
7395 map
->p_paddr_valid
= p_paddr_valid
;
7396 map
->includes_filehdr
= 0;
7397 map
->includes_phdrs
= 0;
7402 bfd_set_error (bfd_error_sorry
);
7406 while (isec
< section_count
);
7411 elf_seg_map (obfd
) = map_first
;
7413 /* If we had to estimate the number of program headers that were
7414 going to be needed, then check our estimate now and adjust
7415 the offset if necessary. */
7416 if (phdr_adjust_seg
!= NULL
)
7420 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7423 if (count
> phdr_adjust_num
)
7424 phdr_adjust_seg
->p_paddr
7425 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7427 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7428 if (map
->p_type
== PT_PHDR
)
7431 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7432 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7439 #undef IS_CONTAINED_BY_VMA
7440 #undef IS_CONTAINED_BY_LMA
7442 #undef IS_COREFILE_NOTE
7443 #undef IS_SOLARIS_PT_INTERP
7444 #undef IS_SECTION_IN_INPUT_SEGMENT
7445 #undef INCLUDE_SECTION_IN_SEGMENT
7446 #undef SEGMENT_AFTER_SEGMENT
7447 #undef SEGMENT_OVERLAPS
7451 /* Copy ELF program header information. */
7454 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7456 Elf_Internal_Ehdr
*iehdr
;
7457 struct elf_segment_map
*map
;
7458 struct elf_segment_map
*map_first
;
7459 struct elf_segment_map
**pointer_to_map
;
7460 Elf_Internal_Phdr
*segment
;
7462 unsigned int num_segments
;
7463 bfd_boolean phdr_included
= FALSE
;
7464 bfd_boolean p_paddr_valid
;
7466 iehdr
= elf_elfheader (ibfd
);
7469 pointer_to_map
= &map_first
;
7471 /* If all the segment p_paddr fields are zero, don't set
7472 map->p_paddr_valid. */
7473 p_paddr_valid
= FALSE
;
7474 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7475 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7478 if (segment
->p_paddr
!= 0)
7480 p_paddr_valid
= TRUE
;
7484 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7489 unsigned int section_count
;
7491 Elf_Internal_Shdr
*this_hdr
;
7492 asection
*first_section
= NULL
;
7493 asection
*lowest_section
;
7495 /* Compute how many sections are in this segment. */
7496 for (section
= ibfd
->sections
, section_count
= 0;
7498 section
= section
->next
)
7500 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7501 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7503 if (first_section
== NULL
)
7504 first_section
= section
;
7509 /* Allocate a segment map big enough to contain
7510 all of the sections we have selected. */
7511 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7512 amt
+= section_count
* sizeof (asection
*);
7513 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7517 /* Initialize the fields of the output segment map with the
7520 map
->p_type
= segment
->p_type
;
7521 map
->p_flags
= segment
->p_flags
;
7522 map
->p_flags_valid
= 1;
7523 map
->p_paddr
= segment
->p_paddr
;
7524 map
->p_paddr_valid
= p_paddr_valid
;
7525 map
->p_align
= segment
->p_align
;
7526 map
->p_align_valid
= 1;
7527 map
->p_vaddr_offset
= 0;
7529 if (map
->p_type
== PT_GNU_RELRO
7530 || map
->p_type
== PT_GNU_STACK
)
7532 /* The PT_GNU_RELRO segment may contain the first a few
7533 bytes in the .got.plt section even if the whole .got.plt
7534 section isn't in the PT_GNU_RELRO segment. We won't
7535 change the size of the PT_GNU_RELRO segment.
7536 Similarly, PT_GNU_STACK size is significant on uclinux
7538 map
->p_size
= segment
->p_memsz
;
7539 map
->p_size_valid
= 1;
7542 /* Determine if this segment contains the ELF file header
7543 and if it contains the program headers themselves. */
7544 map
->includes_filehdr
= (segment
->p_offset
== 0
7545 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7547 map
->includes_phdrs
= 0;
7548 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7550 map
->includes_phdrs
=
7551 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7552 && (segment
->p_offset
+ segment
->p_filesz
7553 >= ((bfd_vma
) iehdr
->e_phoff
7554 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7556 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7557 phdr_included
= TRUE
;
7560 lowest_section
= NULL
;
7561 if (section_count
!= 0)
7563 unsigned int isec
= 0;
7565 for (section
= first_section
;
7567 section
= section
->next
)
7569 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7570 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7572 map
->sections
[isec
++] = section
->output_section
;
7573 if ((section
->flags
& SEC_ALLOC
) != 0)
7577 if (lowest_section
== NULL
7578 || section
->lma
< lowest_section
->lma
)
7579 lowest_section
= section
;
7581 /* Section lmas are set up from PT_LOAD header
7582 p_paddr in _bfd_elf_make_section_from_shdr.
7583 If this header has a p_paddr that disagrees
7584 with the section lma, flag the p_paddr as
7586 if ((section
->flags
& SEC_LOAD
) != 0)
7587 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7589 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7590 if (section
->lma
- segment
->p_paddr
!= seg_off
)
7591 map
->p_paddr_valid
= FALSE
;
7593 if (isec
== section_count
)
7599 if (section_count
== 0)
7600 map
->p_vaddr_offset
= segment
->p_vaddr
;
7601 else if (map
->p_paddr_valid
)
7603 /* Account for padding before the first section in the segment. */
7604 bfd_vma hdr_size
= 0;
7605 if (map
->includes_filehdr
)
7606 hdr_size
= iehdr
->e_ehsize
;
7607 if (map
->includes_phdrs
)
7608 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7610 map
->p_vaddr_offset
= (map
->p_paddr
+ hdr_size
7611 - (lowest_section
? lowest_section
->lma
: 0));
7614 map
->count
= section_count
;
7615 *pointer_to_map
= map
;
7616 pointer_to_map
= &map
->next
;
7619 elf_seg_map (obfd
) = map_first
;
7623 /* Copy private BFD data. This copies or rewrites ELF program header
7627 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7629 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7630 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7633 if (elf_tdata (ibfd
)->phdr
== NULL
)
7636 if (ibfd
->xvec
== obfd
->xvec
)
7638 /* Check to see if any sections in the input BFD
7639 covered by ELF program header have changed. */
7640 Elf_Internal_Phdr
*segment
;
7641 asection
*section
, *osec
;
7642 unsigned int i
, num_segments
;
7643 Elf_Internal_Shdr
*this_hdr
;
7644 const struct elf_backend_data
*bed
;
7646 bed
= get_elf_backend_data (ibfd
);
7648 /* Regenerate the segment map if p_paddr is set to 0. */
7649 if (bed
->want_p_paddr_set_to_zero
)
7652 /* Initialize the segment mark field. */
7653 for (section
= obfd
->sections
; section
!= NULL
;
7654 section
= section
->next
)
7655 section
->segment_mark
= FALSE
;
7657 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7658 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7662 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7663 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7664 which severly confuses things, so always regenerate the segment
7665 map in this case. */
7666 if (segment
->p_paddr
== 0
7667 && segment
->p_memsz
== 0
7668 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7671 for (section
= ibfd
->sections
;
7672 section
!= NULL
; section
= section
->next
)
7674 /* We mark the output section so that we know it comes
7675 from the input BFD. */
7676 osec
= section
->output_section
;
7678 osec
->segment_mark
= TRUE
;
7680 /* Check if this section is covered by the segment. */
7681 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7682 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7684 /* FIXME: Check if its output section is changed or
7685 removed. What else do we need to check? */
7687 || section
->flags
!= osec
->flags
7688 || section
->lma
!= osec
->lma
7689 || section
->vma
!= osec
->vma
7690 || section
->size
!= osec
->size
7691 || section
->rawsize
!= osec
->rawsize
7692 || section
->alignment_power
!= osec
->alignment_power
)
7698 /* Check to see if any output section do not come from the
7700 for (section
= obfd
->sections
; section
!= NULL
;
7701 section
= section
->next
)
7703 if (!section
->segment_mark
)
7706 section
->segment_mark
= FALSE
;
7709 return copy_elf_program_header (ibfd
, obfd
);
7713 if (ibfd
->xvec
== obfd
->xvec
)
7715 /* When rewriting program header, set the output maxpagesize to
7716 the maximum alignment of input PT_LOAD segments. */
7717 Elf_Internal_Phdr
*segment
;
7719 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7720 bfd_vma maxpagesize
= 0;
7722 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7725 if (segment
->p_type
== PT_LOAD
7726 && maxpagesize
< segment
->p_align
)
7728 /* PR 17512: file: f17299af. */
7729 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7730 /* xgettext:c-format */
7731 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7732 PRIx64
" is too large"),
7733 ibfd
, (uint64_t) segment
->p_align
);
7735 maxpagesize
= segment
->p_align
;
7738 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7739 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7742 return rewrite_elf_program_header (ibfd
, obfd
);
7745 /* Initialize private output section information from input section. */
7748 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7752 struct bfd_link_info
*link_info
)
7755 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7756 bfd_boolean final_link
= (link_info
!= NULL
7757 && !bfd_link_relocatable (link_info
));
7759 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7760 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7763 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7765 /* For objcopy and relocatable link, don't copy the output ELF
7766 section type from input if the output BFD section flags have been
7767 set to something different. For a final link allow some flags
7768 that the linker clears to differ. */
7769 if (elf_section_type (osec
) == SHT_NULL
7770 && (osec
->flags
== isec
->flags
7772 && ((osec
->flags
^ isec
->flags
)
7773 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7774 elf_section_type (osec
) = elf_section_type (isec
);
7776 /* FIXME: Is this correct for all OS/PROC specific flags? */
7777 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7778 & (SHF_MASKOS
| SHF_MASKPROC
));
7780 /* Copy sh_info from input for mbind section. */
7781 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7782 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7783 elf_section_data (osec
)->this_hdr
.sh_info
7784 = elf_section_data (isec
)->this_hdr
.sh_info
;
7786 /* Set things up for objcopy and relocatable link. The output
7787 SHT_GROUP section will have its elf_next_in_group pointing back
7788 to the input group members. Ignore linker created group section.
7789 See elfNN_ia64_object_p in elfxx-ia64.c. */
7790 if ((link_info
== NULL
7791 || !link_info
->resolve_section_groups
)
7792 && (elf_sec_group (isec
) == NULL
7793 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7795 if (elf_section_flags (isec
) & SHF_GROUP
)
7796 elf_section_flags (osec
) |= SHF_GROUP
;
7797 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7798 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7801 /* If not decompress, preserve SHF_COMPRESSED. */
7802 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7803 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7806 ihdr
= &elf_section_data (isec
)->this_hdr
;
7808 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7809 don't use the output section of the linked-to section since it
7810 may be NULL at this point. */
7811 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7813 ohdr
= &elf_section_data (osec
)->this_hdr
;
7814 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7815 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7818 osec
->use_rela_p
= isec
->use_rela_p
;
7823 /* Copy private section information. This copies over the entsize
7824 field, and sometimes the info field. */
7827 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7832 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7834 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7835 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7838 ihdr
= &elf_section_data (isec
)->this_hdr
;
7839 ohdr
= &elf_section_data (osec
)->this_hdr
;
7841 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7843 if (ihdr
->sh_type
== SHT_SYMTAB
7844 || ihdr
->sh_type
== SHT_DYNSYM
7845 || ihdr
->sh_type
== SHT_GNU_verneed
7846 || ihdr
->sh_type
== SHT_GNU_verdef
)
7847 ohdr
->sh_info
= ihdr
->sh_info
;
7849 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7853 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7854 necessary if we are removing either the SHT_GROUP section or any of
7855 the group member sections. DISCARDED is the value that a section's
7856 output_section has if the section will be discarded, NULL when this
7857 function is called from objcopy, bfd_abs_section_ptr when called
7861 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7865 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7866 if (elf_section_type (isec
) == SHT_GROUP
)
7868 asection
*first
= elf_next_in_group (isec
);
7869 asection
*s
= first
;
7870 bfd_size_type removed
= 0;
7874 /* If this member section is being output but the
7875 SHT_GROUP section is not, then clear the group info
7876 set up by _bfd_elf_copy_private_section_data. */
7877 if (s
->output_section
!= discarded
7878 && isec
->output_section
== discarded
)
7880 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7881 elf_group_name (s
->output_section
) = NULL
;
7883 /* Conversely, if the member section is not being output
7884 but the SHT_GROUP section is, then adjust its size. */
7885 else if (s
->output_section
== discarded
7886 && isec
->output_section
!= discarded
)
7888 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7890 if (elf_sec
->rel
.hdr
!= NULL
7891 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7893 if (elf_sec
->rela
.hdr
!= NULL
7894 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7897 s
= elf_next_in_group (s
);
7903 if (discarded
!= NULL
)
7905 /* If we've been called for ld -r, then we need to
7906 adjust the input section size. */
7907 if (isec
->rawsize
== 0)
7908 isec
->rawsize
= isec
->size
;
7909 isec
->size
= isec
->rawsize
- removed
;
7910 if (isec
->size
<= 4)
7913 isec
->flags
|= SEC_EXCLUDE
;
7918 /* Adjust the output section size when called from
7920 isec
->output_section
->size
-= removed
;
7921 if (isec
->output_section
->size
<= 4)
7923 isec
->output_section
->size
= 0;
7924 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7933 /* Copy private header information. */
7936 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7938 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7939 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7942 /* Copy over private BFD data if it has not already been copied.
7943 This must be done here, rather than in the copy_private_bfd_data
7944 entry point, because the latter is called after the section
7945 contents have been set, which means that the program headers have
7946 already been worked out. */
7947 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7949 if (! copy_private_bfd_data (ibfd
, obfd
))
7953 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7956 /* Copy private symbol information. If this symbol is in a section
7957 which we did not map into a BFD section, try to map the section
7958 index correctly. We use special macro definitions for the mapped
7959 section indices; these definitions are interpreted by the
7960 swap_out_syms function. */
7962 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7963 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7964 #define MAP_STRTAB (SHN_HIOS + 3)
7965 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7966 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7969 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7974 elf_symbol_type
*isym
, *osym
;
7976 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7977 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7980 isym
= elf_symbol_from (ibfd
, isymarg
);
7981 osym
= elf_symbol_from (obfd
, osymarg
);
7984 && isym
->internal_elf_sym
.st_shndx
!= 0
7986 && bfd_is_abs_section (isym
->symbol
.section
))
7990 shndx
= isym
->internal_elf_sym
.st_shndx
;
7991 if (shndx
== elf_onesymtab (ibfd
))
7992 shndx
= MAP_ONESYMTAB
;
7993 else if (shndx
== elf_dynsymtab (ibfd
))
7994 shndx
= MAP_DYNSYMTAB
;
7995 else if (shndx
== elf_strtab_sec (ibfd
))
7997 else if (shndx
== elf_shstrtab_sec (ibfd
))
7998 shndx
= MAP_SHSTRTAB
;
7999 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
8000 shndx
= MAP_SYM_SHNDX
;
8001 osym
->internal_elf_sym
.st_shndx
= shndx
;
8007 /* Swap out the symbols. */
8010 swap_out_syms (bfd
*abfd
,
8011 struct elf_strtab_hash
**sttp
,
8014 const struct elf_backend_data
*bed
;
8017 struct elf_strtab_hash
*stt
;
8018 Elf_Internal_Shdr
*symtab_hdr
;
8019 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8020 Elf_Internal_Shdr
*symstrtab_hdr
;
8021 struct elf_sym_strtab
*symstrtab
;
8022 bfd_byte
*outbound_syms
;
8023 bfd_byte
*outbound_shndx
;
8024 unsigned long outbound_syms_index
;
8025 unsigned long outbound_shndx_index
;
8027 unsigned int num_locals
;
8029 bfd_boolean name_local_sections
;
8031 if (!elf_map_symbols (abfd
, &num_locals
))
8034 /* Dump out the symtabs. */
8035 stt
= _bfd_elf_strtab_init ();
8039 bed
= get_elf_backend_data (abfd
);
8040 symcount
= bfd_get_symcount (abfd
);
8041 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8042 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8043 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8044 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8045 symtab_hdr
->sh_info
= num_locals
+ 1;
8046 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8048 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8049 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8051 /* Allocate buffer to swap out the .strtab section. */
8052 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc2 (symcount
+ 1,
8053 sizeof (*symstrtab
));
8054 if (symstrtab
== NULL
)
8056 _bfd_elf_strtab_free (stt
);
8060 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
8061 bed
->s
->sizeof_sym
);
8062 if (outbound_syms
== NULL
)
8065 _bfd_elf_strtab_free (stt
);
8069 symtab_hdr
->contents
= outbound_syms
;
8070 outbound_syms_index
= 0;
8072 outbound_shndx
= NULL
;
8073 outbound_shndx_index
= 0;
8075 if (elf_symtab_shndx_list (abfd
))
8077 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8078 if (symtab_shndx_hdr
->sh_name
!= 0)
8080 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
8081 outbound_shndx
= (bfd_byte
*)
8082 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
8083 if (outbound_shndx
== NULL
)
8086 symtab_shndx_hdr
->contents
= outbound_shndx
;
8087 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8088 symtab_shndx_hdr
->sh_size
= amt
;
8089 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8090 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8092 /* FIXME: What about any other headers in the list ? */
8095 /* Now generate the data (for "contents"). */
8097 /* Fill in zeroth symbol and swap it out. */
8098 Elf_Internal_Sym sym
;
8104 sym
.st_shndx
= SHN_UNDEF
;
8105 sym
.st_target_internal
= 0;
8106 symstrtab
[0].sym
= sym
;
8107 symstrtab
[0].dest_index
= outbound_syms_index
;
8108 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8109 outbound_syms_index
++;
8110 if (outbound_shndx
!= NULL
)
8111 outbound_shndx_index
++;
8115 = (bed
->elf_backend_name_local_section_symbols
8116 && bed
->elf_backend_name_local_section_symbols (abfd
));
8118 syms
= bfd_get_outsymbols (abfd
);
8119 for (idx
= 0; idx
< symcount
;)
8121 Elf_Internal_Sym sym
;
8122 bfd_vma value
= syms
[idx
]->value
;
8123 elf_symbol_type
*type_ptr
;
8124 flagword flags
= syms
[idx
]->flags
;
8127 if (!name_local_sections
8128 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8130 /* Local section symbols have no name. */
8131 sym
.st_name
= (unsigned long) -1;
8135 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8136 to get the final offset for st_name. */
8138 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8140 if (sym
.st_name
== (unsigned long) -1)
8144 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
8146 if ((flags
& BSF_SECTION_SYM
) == 0
8147 && bfd_is_com_section (syms
[idx
]->section
))
8149 /* ELF common symbols put the alignment into the `value' field,
8150 and the size into the `size' field. This is backwards from
8151 how BFD handles it, so reverse it here. */
8152 sym
.st_size
= value
;
8153 if (type_ptr
== NULL
8154 || type_ptr
->internal_elf_sym
.st_value
== 0)
8155 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8157 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8158 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8159 (abfd
, syms
[idx
]->section
);
8163 asection
*sec
= syms
[idx
]->section
;
8166 if (sec
->output_section
)
8168 value
+= sec
->output_offset
;
8169 sec
= sec
->output_section
;
8172 /* Don't add in the section vma for relocatable output. */
8173 if (! relocatable_p
)
8175 sym
.st_value
= value
;
8176 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8178 if (bfd_is_abs_section (sec
)
8180 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8182 /* This symbol is in a real ELF section which we did
8183 not create as a BFD section. Undo the mapping done
8184 by copy_private_symbol_data. */
8185 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8189 shndx
= elf_onesymtab (abfd
);
8192 shndx
= elf_dynsymtab (abfd
);
8195 shndx
= elf_strtab_sec (abfd
);
8198 shndx
= elf_shstrtab_sec (abfd
);
8201 if (elf_symtab_shndx_list (abfd
))
8202 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8211 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8213 if (shndx
== SHN_BAD
)
8217 /* Writing this would be a hell of a lot easier if
8218 we had some decent documentation on bfd, and
8219 knew what to expect of the library, and what to
8220 demand of applications. For example, it
8221 appears that `objcopy' might not set the
8222 section of a symbol to be a section that is
8223 actually in the output file. */
8224 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8226 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8227 if (shndx
== SHN_BAD
)
8229 /* xgettext:c-format */
8231 (_("unable to find equivalent output section"
8232 " for symbol '%s' from section '%s'"),
8233 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8235 bfd_set_error (bfd_error_invalid_operation
);
8241 sym
.st_shndx
= shndx
;
8244 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8246 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8247 type
= STT_GNU_IFUNC
;
8248 else if ((flags
& BSF_FUNCTION
) != 0)
8250 else if ((flags
& BSF_OBJECT
) != 0)
8252 else if ((flags
& BSF_RELC
) != 0)
8254 else if ((flags
& BSF_SRELC
) != 0)
8259 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8262 /* Processor-specific types. */
8263 if (type_ptr
!= NULL
8264 && bed
->elf_backend_get_symbol_type
)
8265 type
= ((*bed
->elf_backend_get_symbol_type
)
8266 (&type_ptr
->internal_elf_sym
, type
));
8268 if (flags
& BSF_SECTION_SYM
)
8270 if (flags
& BSF_GLOBAL
)
8271 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8273 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8275 else if (bfd_is_com_section (syms
[idx
]->section
))
8277 if (type
!= STT_TLS
)
8279 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8280 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8281 ? STT_COMMON
: STT_OBJECT
);
8283 type
= ((flags
& BSF_ELF_COMMON
) != 0
8284 ? STT_COMMON
: STT_OBJECT
);
8286 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8288 else if (bfd_is_und_section (syms
[idx
]->section
))
8289 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8293 else if (flags
& BSF_FILE
)
8294 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8297 int bind
= STB_LOCAL
;
8299 if (flags
& BSF_LOCAL
)
8301 else if (flags
& BSF_GNU_UNIQUE
)
8302 bind
= STB_GNU_UNIQUE
;
8303 else if (flags
& BSF_WEAK
)
8305 else if (flags
& BSF_GLOBAL
)
8308 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8311 if (type_ptr
!= NULL
)
8313 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8314 sym
.st_target_internal
8315 = type_ptr
->internal_elf_sym
.st_target_internal
;
8320 sym
.st_target_internal
= 0;
8324 symstrtab
[idx
].sym
= sym
;
8325 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8326 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8328 outbound_syms_index
++;
8329 if (outbound_shndx
!= NULL
)
8330 outbound_shndx_index
++;
8333 /* Finalize the .strtab section. */
8334 _bfd_elf_strtab_finalize (stt
);
8336 /* Swap out the .strtab section. */
8337 for (idx
= 0; idx
<= symcount
; idx
++)
8339 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8340 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8341 elfsym
->sym
.st_name
= 0;
8343 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8344 elfsym
->sym
.st_name
);
8345 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8347 + (elfsym
->dest_index
8348 * bed
->s
->sizeof_sym
)),
8350 + (elfsym
->destshndx_index
8351 * sizeof (Elf_External_Sym_Shndx
))));
8356 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8357 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8358 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8359 symstrtab_hdr
->sh_addr
= 0;
8360 symstrtab_hdr
->sh_entsize
= 0;
8361 symstrtab_hdr
->sh_link
= 0;
8362 symstrtab_hdr
->sh_info
= 0;
8363 symstrtab_hdr
->sh_addralign
= 1;
8368 /* Return the number of bytes required to hold the symtab vector.
8370 Note that we base it on the count plus 1, since we will null terminate
8371 the vector allocated based on this size. However, the ELF symbol table
8372 always has a dummy entry as symbol #0, so it ends up even. */
8375 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8377 bfd_size_type symcount
;
8379 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8381 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8382 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8384 bfd_set_error (bfd_error_file_too_big
);
8387 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8389 symtab_size
-= sizeof (asymbol
*);
8395 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8397 bfd_size_type symcount
;
8399 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8401 if (elf_dynsymtab (abfd
) == 0)
8403 bfd_set_error (bfd_error_invalid_operation
);
8407 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8408 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8410 bfd_set_error (bfd_error_file_too_big
);
8413 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8415 symtab_size
-= sizeof (asymbol
*);
8421 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
8424 #if SIZEOF_LONG == SIZEOF_INT
8425 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8427 bfd_set_error (bfd_error_file_too_big
);
8431 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8434 /* Canonicalize the relocs. */
8437 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8444 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8446 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
8449 tblptr
= section
->relocation
;
8450 for (i
= 0; i
< section
->reloc_count
; i
++)
8451 *relptr
++ = tblptr
++;
8455 return section
->reloc_count
;
8459 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8461 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8462 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
8465 abfd
->symcount
= symcount
;
8470 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8471 asymbol
**allocation
)
8473 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8474 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
8477 abfd
->dynsymcount
= symcount
;
8481 /* Return the size required for the dynamic reloc entries. Any loadable
8482 section that was actually installed in the BFD, and has type SHT_REL
8483 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8484 dynamic reloc section. */
8487 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8489 bfd_size_type count
;
8492 if (elf_dynsymtab (abfd
) == 0)
8494 bfd_set_error (bfd_error_invalid_operation
);
8499 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8500 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8501 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8502 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8504 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8505 if (count
> LONG_MAX
/ sizeof (arelent
*))
8507 bfd_set_error (bfd_error_file_too_big
);
8511 return count
* sizeof (arelent
*);
8514 /* Canonicalize the dynamic relocation entries. Note that we return the
8515 dynamic relocations as a single block, although they are actually
8516 associated with particular sections; the interface, which was
8517 designed for SunOS style shared libraries, expects that there is only
8518 one set of dynamic relocs. Any loadable section that was actually
8519 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8520 dynamic symbol table, is considered to be a dynamic reloc section. */
8523 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8527 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8531 if (elf_dynsymtab (abfd
) == 0)
8533 bfd_set_error (bfd_error_invalid_operation
);
8537 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8539 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8541 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8542 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8543 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8548 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8550 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8552 for (i
= 0; i
< count
; i
++)
8563 /* Read in the version information. */
8566 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8568 bfd_byte
*contents
= NULL
;
8569 unsigned int freeidx
= 0;
8571 if (elf_dynverref (abfd
) != 0)
8573 Elf_Internal_Shdr
*hdr
;
8574 Elf_External_Verneed
*everneed
;
8575 Elf_Internal_Verneed
*iverneed
;
8577 bfd_byte
*contents_end
;
8579 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8581 if (hdr
->sh_info
== 0
8582 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8584 error_return_bad_verref
:
8586 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8587 bfd_set_error (bfd_error_bad_value
);
8588 error_return_verref
:
8589 elf_tdata (abfd
)->verref
= NULL
;
8590 elf_tdata (abfd
)->cverrefs
= 0;
8594 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8595 if (filesize
> 0 && filesize
< hdr
->sh_size
)
8597 /* PR 24708: Avoid attempts to allocate a ridiculous amount
8599 bfd_set_error (bfd_error_no_memory
);
8601 /* xgettext:c-format */
8602 (_("error: %pB version reference section is too large (%#" PRIx64
" bytes)"),
8603 abfd
, (uint64_t) hdr
->sh_size
);
8604 goto error_return_verref
;
8606 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8607 if (contents
== NULL
)
8608 goto error_return_verref
;
8610 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8611 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8612 goto error_return_verref
;
8614 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
8615 bfd_alloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
8617 if (elf_tdata (abfd
)->verref
== NULL
)
8618 goto error_return_verref
;
8620 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8621 == sizeof (Elf_External_Vernaux
));
8622 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8623 everneed
= (Elf_External_Verneed
*) contents
;
8624 iverneed
= elf_tdata (abfd
)->verref
;
8625 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8627 Elf_External_Vernaux
*evernaux
;
8628 Elf_Internal_Vernaux
*ivernaux
;
8631 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8633 iverneed
->vn_bfd
= abfd
;
8635 iverneed
->vn_filename
=
8636 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8638 if (iverneed
->vn_filename
== NULL
)
8639 goto error_return_bad_verref
;
8641 if (iverneed
->vn_cnt
== 0)
8642 iverneed
->vn_auxptr
= NULL
;
8645 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8646 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
8647 sizeof (Elf_Internal_Vernaux
));
8648 if (iverneed
->vn_auxptr
== NULL
)
8649 goto error_return_verref
;
8652 if (iverneed
->vn_aux
8653 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8654 goto error_return_bad_verref
;
8656 evernaux
= ((Elf_External_Vernaux
*)
8657 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8658 ivernaux
= iverneed
->vn_auxptr
;
8659 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8661 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8663 ivernaux
->vna_nodename
=
8664 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8665 ivernaux
->vna_name
);
8666 if (ivernaux
->vna_nodename
== NULL
)
8667 goto error_return_bad_verref
;
8669 if (ivernaux
->vna_other
> freeidx
)
8670 freeidx
= ivernaux
->vna_other
;
8672 ivernaux
->vna_nextptr
= NULL
;
8673 if (ivernaux
->vna_next
== 0)
8675 iverneed
->vn_cnt
= j
+ 1;
8678 if (j
+ 1 < iverneed
->vn_cnt
)
8679 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8681 if (ivernaux
->vna_next
8682 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8683 goto error_return_bad_verref
;
8685 evernaux
= ((Elf_External_Vernaux
*)
8686 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8689 iverneed
->vn_nextref
= NULL
;
8690 if (iverneed
->vn_next
== 0)
8692 if (i
+ 1 < hdr
->sh_info
)
8693 iverneed
->vn_nextref
= iverneed
+ 1;
8695 if (iverneed
->vn_next
8696 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8697 goto error_return_bad_verref
;
8699 everneed
= ((Elf_External_Verneed
*)
8700 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8702 elf_tdata (abfd
)->cverrefs
= i
;
8708 if (elf_dynverdef (abfd
) != 0)
8710 Elf_Internal_Shdr
*hdr
;
8711 Elf_External_Verdef
*everdef
;
8712 Elf_Internal_Verdef
*iverdef
;
8713 Elf_Internal_Verdef
*iverdefarr
;
8714 Elf_Internal_Verdef iverdefmem
;
8716 unsigned int maxidx
;
8717 bfd_byte
*contents_end_def
, *contents_end_aux
;
8719 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8721 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8723 error_return_bad_verdef
:
8725 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8726 bfd_set_error (bfd_error_bad_value
);
8727 error_return_verdef
:
8728 elf_tdata (abfd
)->verdef
= NULL
;
8729 elf_tdata (abfd
)->cverdefs
= 0;
8733 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8734 if (contents
== NULL
)
8735 goto error_return_verdef
;
8736 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8737 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8738 goto error_return_verdef
;
8740 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8741 >= sizeof (Elf_External_Verdaux
));
8742 contents_end_def
= contents
+ hdr
->sh_size
8743 - sizeof (Elf_External_Verdef
);
8744 contents_end_aux
= contents
+ hdr
->sh_size
8745 - sizeof (Elf_External_Verdaux
);
8747 /* We know the number of entries in the section but not the maximum
8748 index. Therefore we have to run through all entries and find
8750 everdef
= (Elf_External_Verdef
*) contents
;
8752 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8754 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8756 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8757 goto error_return_bad_verdef
;
8758 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8759 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8761 if (iverdefmem
.vd_next
== 0)
8764 if (iverdefmem
.vd_next
8765 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8766 goto error_return_bad_verdef
;
8768 everdef
= ((Elf_External_Verdef
*)
8769 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8772 if (default_imported_symver
)
8774 if (freeidx
> maxidx
)
8780 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8781 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
8782 if (elf_tdata (abfd
)->verdef
== NULL
)
8783 goto error_return_verdef
;
8785 elf_tdata (abfd
)->cverdefs
= maxidx
;
8787 everdef
= (Elf_External_Verdef
*) contents
;
8788 iverdefarr
= elf_tdata (abfd
)->verdef
;
8789 for (i
= 0; i
< hdr
->sh_info
; i
++)
8791 Elf_External_Verdaux
*everdaux
;
8792 Elf_Internal_Verdaux
*iverdaux
;
8795 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8797 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8798 goto error_return_bad_verdef
;
8800 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8801 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8803 iverdef
->vd_bfd
= abfd
;
8805 if (iverdef
->vd_cnt
== 0)
8806 iverdef
->vd_auxptr
= NULL
;
8809 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8810 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
8811 sizeof (Elf_Internal_Verdaux
));
8812 if (iverdef
->vd_auxptr
== NULL
)
8813 goto error_return_verdef
;
8817 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8818 goto error_return_bad_verdef
;
8820 everdaux
= ((Elf_External_Verdaux
*)
8821 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8822 iverdaux
= iverdef
->vd_auxptr
;
8823 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8825 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8827 iverdaux
->vda_nodename
=
8828 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8829 iverdaux
->vda_name
);
8830 if (iverdaux
->vda_nodename
== NULL
)
8831 goto error_return_bad_verdef
;
8833 iverdaux
->vda_nextptr
= NULL
;
8834 if (iverdaux
->vda_next
== 0)
8836 iverdef
->vd_cnt
= j
+ 1;
8839 if (j
+ 1 < iverdef
->vd_cnt
)
8840 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8842 if (iverdaux
->vda_next
8843 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8844 goto error_return_bad_verdef
;
8846 everdaux
= ((Elf_External_Verdaux
*)
8847 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8850 iverdef
->vd_nodename
= NULL
;
8851 if (iverdef
->vd_cnt
)
8852 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8854 iverdef
->vd_nextdef
= NULL
;
8855 if (iverdef
->vd_next
== 0)
8857 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8858 iverdef
->vd_nextdef
= iverdef
+ 1;
8860 everdef
= ((Elf_External_Verdef
*)
8861 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8867 else if (default_imported_symver
)
8874 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8875 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8876 if (elf_tdata (abfd
)->verdef
== NULL
)
8879 elf_tdata (abfd
)->cverdefs
= freeidx
;
8882 /* Create a default version based on the soname. */
8883 if (default_imported_symver
)
8885 Elf_Internal_Verdef
*iverdef
;
8886 Elf_Internal_Verdaux
*iverdaux
;
8888 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8890 iverdef
->vd_version
= VER_DEF_CURRENT
;
8891 iverdef
->vd_flags
= 0;
8892 iverdef
->vd_ndx
= freeidx
;
8893 iverdef
->vd_cnt
= 1;
8895 iverdef
->vd_bfd
= abfd
;
8897 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8898 if (iverdef
->vd_nodename
== NULL
)
8899 goto error_return_verdef
;
8900 iverdef
->vd_nextdef
= NULL
;
8901 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8902 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8903 if (iverdef
->vd_auxptr
== NULL
)
8904 goto error_return_verdef
;
8906 iverdaux
= iverdef
->vd_auxptr
;
8907 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8913 if (contents
!= NULL
)
8919 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8921 elf_symbol_type
*newsym
;
8923 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
8926 newsym
->symbol
.the_bfd
= abfd
;
8927 return &newsym
->symbol
;
8931 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8935 bfd_symbol_info (symbol
, ret
);
8938 /* Return whether a symbol name implies a local symbol. Most targets
8939 use this function for the is_local_label_name entry point, but some
8943 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8946 /* Normal local symbols start with ``.L''. */
8947 if (name
[0] == '.' && name
[1] == 'L')
8950 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8951 DWARF debugging symbols starting with ``..''. */
8952 if (name
[0] == '.' && name
[1] == '.')
8955 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8956 emitting DWARF debugging output. I suspect this is actually a
8957 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8958 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8959 underscore to be emitted on some ELF targets). For ease of use,
8960 we treat such symbols as local. */
8961 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8964 /* Treat assembler generated fake symbols, dollar local labels and
8965 forward-backward labels (aka local labels) as locals.
8966 These labels have the form:
8968 L0^A.* (fake symbols)
8970 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8972 Versions which start with .L will have already been matched above,
8973 so we only need to match the rest. */
8974 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8976 bfd_boolean ret
= FALSE
;
8980 for (p
= name
+ 2; (c
= *p
); p
++)
8982 if (c
== 1 || c
== 2)
8984 if (c
== 1 && p
== name
+ 2)
8985 /* A fake symbol. */
8988 /* FIXME: We are being paranoid here and treating symbols like
8989 L0^Bfoo as if there were non-local, on the grounds that the
8990 assembler will never generate them. But can any symbol
8991 containing an ASCII value in the range 1-31 ever be anything
8992 other than some kind of local ? */
9009 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9010 asymbol
*symbol ATTRIBUTE_UNUSED
)
9017 _bfd_elf_set_arch_mach (bfd
*abfd
,
9018 enum bfd_architecture arch
,
9019 unsigned long machine
)
9021 /* If this isn't the right architecture for this backend, and this
9022 isn't the generic backend, fail. */
9023 if (arch
!= get_elf_backend_data (abfd
)->arch
9024 && arch
!= bfd_arch_unknown
9025 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9028 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9031 /* Find the nearest line to a particular section and offset,
9032 for error reporting. */
9035 _bfd_elf_find_nearest_line (bfd
*abfd
,
9039 const char **filename_ptr
,
9040 const char **functionname_ptr
,
9041 unsigned int *line_ptr
,
9042 unsigned int *discriminator_ptr
)
9046 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9047 filename_ptr
, functionname_ptr
,
9048 line_ptr
, discriminator_ptr
,
9049 dwarf_debug_sections
,
9050 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9053 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9054 filename_ptr
, functionname_ptr
, line_ptr
))
9056 if (!*functionname_ptr
)
9057 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9058 *filename_ptr
? NULL
: filename_ptr
,
9063 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9064 &found
, filename_ptr
,
9065 functionname_ptr
, line_ptr
,
9066 &elf_tdata (abfd
)->line_info
))
9068 if (found
&& (*functionname_ptr
|| *line_ptr
))
9071 if (symbols
== NULL
)
9074 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9075 filename_ptr
, functionname_ptr
))
9082 /* Find the line for a symbol. */
9085 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9086 const char **filename_ptr
, unsigned int *line_ptr
)
9088 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9089 filename_ptr
, NULL
, line_ptr
, NULL
,
9090 dwarf_debug_sections
,
9091 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9094 /* After a call to bfd_find_nearest_line, successive calls to
9095 bfd_find_inliner_info can be used to get source information about
9096 each level of function inlining that terminated at the address
9097 passed to bfd_find_nearest_line. Currently this is only supported
9098 for DWARF2 with appropriate DWARF3 extensions. */
9101 _bfd_elf_find_inliner_info (bfd
*abfd
,
9102 const char **filename_ptr
,
9103 const char **functionname_ptr
,
9104 unsigned int *line_ptr
)
9107 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9108 functionname_ptr
, line_ptr
,
9109 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9114 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9116 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9117 int ret
= bed
->s
->sizeof_ehdr
;
9119 if (!bfd_link_relocatable (info
))
9121 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9123 if (phdr_size
== (bfd_size_type
) -1)
9125 struct elf_segment_map
*m
;
9128 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9129 phdr_size
+= bed
->s
->sizeof_phdr
;
9132 phdr_size
= get_program_header_size (abfd
, info
);
9135 elf_program_header_size (abfd
) = phdr_size
;
9143 _bfd_elf_set_section_contents (bfd
*abfd
,
9145 const void *location
,
9147 bfd_size_type count
)
9149 Elf_Internal_Shdr
*hdr
;
9152 if (! abfd
->output_has_begun
9153 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9159 hdr
= &elf_section_data (section
)->this_hdr
;
9160 if (hdr
->sh_offset
== (file_ptr
) -1)
9162 if (bfd_section_is_ctf (section
))
9163 /* Nothing to do with this section: the contents are generated
9167 /* We must compress this section. Write output to the buffer. */
9168 unsigned char *contents
= hdr
->contents
;
9169 if ((offset
+ count
) > hdr
->sh_size
9170 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
9171 || contents
== NULL
)
9173 memcpy (contents
+ offset
, location
, count
);
9176 pos
= hdr
->sh_offset
+ offset
;
9177 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9178 || bfd_bwrite (location
, count
, abfd
) != count
)
9185 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9186 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9187 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9193 /* Try to convert a non-ELF reloc into an ELF one. */
9196 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9198 /* Check whether we really have an ELF howto. */
9200 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9202 bfd_reloc_code_real_type code
;
9203 reloc_howto_type
*howto
;
9205 /* Alien reloc: Try to determine its type to replace it with an
9206 equivalent ELF reloc. */
9208 if (areloc
->howto
->pc_relative
)
9210 switch (areloc
->howto
->bitsize
)
9213 code
= BFD_RELOC_8_PCREL
;
9216 code
= BFD_RELOC_12_PCREL
;
9219 code
= BFD_RELOC_16_PCREL
;
9222 code
= BFD_RELOC_24_PCREL
;
9225 code
= BFD_RELOC_32_PCREL
;
9228 code
= BFD_RELOC_64_PCREL
;
9234 howto
= bfd_reloc_type_lookup (abfd
, code
);
9236 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9238 if (howto
->pcrel_offset
)
9239 areloc
->addend
+= areloc
->address
;
9241 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9246 switch (areloc
->howto
->bitsize
)
9252 code
= BFD_RELOC_14
;
9255 code
= BFD_RELOC_16
;
9258 code
= BFD_RELOC_26
;
9261 code
= BFD_RELOC_32
;
9264 code
= BFD_RELOC_64
;
9270 howto
= bfd_reloc_type_lookup (abfd
, code
);
9274 areloc
->howto
= howto
;
9282 /* xgettext:c-format */
9283 _bfd_error_handler (_("%pB: %s unsupported"),
9284 abfd
, areloc
->howto
->name
);
9285 bfd_set_error (bfd_error_sorry
);
9290 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9292 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9293 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
9295 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9296 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9297 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9300 return _bfd_generic_close_and_cleanup (abfd
);
9303 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9304 in the relocation's offset. Thus we cannot allow any sort of sanity
9305 range-checking to interfere. There is nothing else to do in processing
9308 bfd_reloc_status_type
9309 _bfd_elf_rel_vtable_reloc_fn
9310 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9311 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9312 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9313 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9315 return bfd_reloc_ok
;
9318 /* Elf core file support. Much of this only works on native
9319 toolchains, since we rely on knowing the
9320 machine-dependent procfs structure in order to pick
9321 out details about the corefile. */
9323 #ifdef HAVE_SYS_PROCFS_H
9324 /* Needed for new procfs interface on sparc-solaris. */
9325 # define _STRUCTURED_PROC 1
9326 # include <sys/procfs.h>
9329 /* Return a PID that identifies a "thread" for threaded cores, or the
9330 PID of the main process for non-threaded cores. */
9333 elfcore_make_pid (bfd
*abfd
)
9337 pid
= elf_tdata (abfd
)->core
->lwpid
;
9339 pid
= elf_tdata (abfd
)->core
->pid
;
9344 /* If there isn't a section called NAME, make one, using
9345 data from SECT. Note, this function will generate a
9346 reference to NAME, so you shouldn't deallocate or
9350 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9354 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9357 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9361 sect2
->size
= sect
->size
;
9362 sect2
->filepos
= sect
->filepos
;
9363 sect2
->alignment_power
= sect
->alignment_power
;
9367 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9368 actually creates up to two pseudosections:
9369 - For the single-threaded case, a section named NAME, unless
9370 such a section already exists.
9371 - For the multi-threaded case, a section named "NAME/PID", where
9372 PID is elfcore_make_pid (abfd).
9373 Both pseudosections have identical contents. */
9375 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9381 char *threaded_name
;
9385 /* Build the section name. */
9387 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9388 len
= strlen (buf
) + 1;
9389 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9390 if (threaded_name
== NULL
)
9392 memcpy (threaded_name
, buf
, len
);
9394 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9399 sect
->filepos
= filepos
;
9400 sect
->alignment_power
= 2;
9402 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9406 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9409 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9415 sect
->size
= note
->descsz
- offs
;
9416 sect
->filepos
= note
->descpos
+ offs
;
9417 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9422 /* prstatus_t exists on:
9424 linux 2.[01] + glibc
9428 #if defined (HAVE_PRSTATUS_T)
9431 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9436 if (note
->descsz
== sizeof (prstatus_t
))
9440 size
= sizeof (prstat
.pr_reg
);
9441 offset
= offsetof (prstatus_t
, pr_reg
);
9442 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9444 /* Do not overwrite the core signal if it
9445 has already been set by another thread. */
9446 if (elf_tdata (abfd
)->core
->signal
== 0)
9447 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9448 if (elf_tdata (abfd
)->core
->pid
== 0)
9449 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9451 /* pr_who exists on:
9454 pr_who doesn't exist on:
9457 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9458 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9460 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9463 #if defined (HAVE_PRSTATUS32_T)
9464 else if (note
->descsz
== sizeof (prstatus32_t
))
9466 /* 64-bit host, 32-bit corefile */
9467 prstatus32_t prstat
;
9469 size
= sizeof (prstat
.pr_reg
);
9470 offset
= offsetof (prstatus32_t
, pr_reg
);
9471 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9473 /* Do not overwrite the core signal if it
9474 has already been set by another thread. */
9475 if (elf_tdata (abfd
)->core
->signal
== 0)
9476 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9477 if (elf_tdata (abfd
)->core
->pid
== 0)
9478 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9480 /* pr_who exists on:
9483 pr_who doesn't exist on:
9486 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9487 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9489 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9492 #endif /* HAVE_PRSTATUS32_T */
9495 /* Fail - we don't know how to handle any other
9496 note size (ie. data object type). */
9500 /* Make a ".reg/999" section and a ".reg" section. */
9501 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9502 size
, note
->descpos
+ offset
);
9504 #endif /* defined (HAVE_PRSTATUS_T) */
9506 /* Create a pseudosection containing the exact contents of NOTE. */
9508 elfcore_make_note_pseudosection (bfd
*abfd
,
9510 Elf_Internal_Note
*note
)
9512 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9513 note
->descsz
, note
->descpos
);
9516 /* There isn't a consistent prfpregset_t across platforms,
9517 but it doesn't matter, because we don't have to pick this
9518 data structure apart. */
9521 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9523 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9526 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9527 type of NT_PRXFPREG. Just include the whole note's contents
9531 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9533 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9536 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9537 with a note type of NT_X86_XSTATE. Just include the whole note's
9538 contents literally. */
9541 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9543 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9547 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9549 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9553 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9555 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9559 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9561 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9565 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9567 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9571 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9573 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9577 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9579 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9583 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9585 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9589 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9591 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9595 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9597 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9601 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9603 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9607 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9609 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9613 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9615 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9619 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9621 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9625 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9627 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9631 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9633 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9637 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9639 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9643 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9645 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9649 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9651 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9655 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9657 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9661 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9663 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9667 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9669 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9673 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9675 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9679 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9681 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9685 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9687 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9691 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9693 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9697 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9699 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9703 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9705 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9709 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9711 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9715 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9717 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9721 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9723 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9727 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9729 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9733 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9735 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9739 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9741 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9745 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9747 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9750 #if defined (HAVE_PRPSINFO_T)
9751 typedef prpsinfo_t elfcore_psinfo_t
;
9752 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9753 typedef prpsinfo32_t elfcore_psinfo32_t
;
9757 #if defined (HAVE_PSINFO_T)
9758 typedef psinfo_t elfcore_psinfo_t
;
9759 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9760 typedef psinfo32_t elfcore_psinfo32_t
;
9764 /* return a malloc'ed copy of a string at START which is at
9765 most MAX bytes long, possibly without a terminating '\0'.
9766 the copy will always have a terminating '\0'. */
9769 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9772 char *end
= (char *) memchr (start
, '\0', max
);
9780 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9784 memcpy (dups
, start
, len
);
9790 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9792 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9794 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9796 elfcore_psinfo_t psinfo
;
9798 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9800 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9801 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9803 elf_tdata (abfd
)->core
->program
9804 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9805 sizeof (psinfo
.pr_fname
));
9807 elf_tdata (abfd
)->core
->command
9808 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9809 sizeof (psinfo
.pr_psargs
));
9811 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9812 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9814 /* 64-bit host, 32-bit corefile */
9815 elfcore_psinfo32_t psinfo
;
9817 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9819 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9820 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9822 elf_tdata (abfd
)->core
->program
9823 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9824 sizeof (psinfo
.pr_fname
));
9826 elf_tdata (abfd
)->core
->command
9827 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9828 sizeof (psinfo
.pr_psargs
));
9834 /* Fail - we don't know how to handle any other
9835 note size (ie. data object type). */
9839 /* Note that for some reason, a spurious space is tacked
9840 onto the end of the args in some (at least one anyway)
9841 implementations, so strip it off if it exists. */
9844 char *command
= elf_tdata (abfd
)->core
->command
;
9845 int n
= strlen (command
);
9847 if (0 < n
&& command
[n
- 1] == ' ')
9848 command
[n
- 1] = '\0';
9853 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9855 #if defined (HAVE_PSTATUS_T)
9857 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9859 if (note
->descsz
== sizeof (pstatus_t
)
9860 #if defined (HAVE_PXSTATUS_T)
9861 || note
->descsz
== sizeof (pxstatus_t
)
9867 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9869 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9871 #if defined (HAVE_PSTATUS32_T)
9872 else if (note
->descsz
== sizeof (pstatus32_t
))
9874 /* 64-bit host, 32-bit corefile */
9877 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9879 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9882 /* Could grab some more details from the "representative"
9883 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9884 NT_LWPSTATUS note, presumably. */
9888 #endif /* defined (HAVE_PSTATUS_T) */
9890 #if defined (HAVE_LWPSTATUS_T)
9892 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9894 lwpstatus_t lwpstat
;
9900 if (note
->descsz
!= sizeof (lwpstat
)
9901 #if defined (HAVE_LWPXSTATUS_T)
9902 && note
->descsz
!= sizeof (lwpxstatus_t
)
9907 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
9909 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
9910 /* Do not overwrite the core signal if it has already been set by
9912 if (elf_tdata (abfd
)->core
->signal
== 0)
9913 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
9915 /* Make a ".reg/999" section. */
9917 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
9918 len
= strlen (buf
) + 1;
9919 name
= bfd_alloc (abfd
, len
);
9922 memcpy (name
, buf
, len
);
9924 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9928 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9929 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
9930 sect
->filepos
= note
->descpos
9931 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
9934 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9935 sect
->size
= sizeof (lwpstat
.pr_reg
);
9936 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
9939 sect
->alignment_power
= 2;
9941 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9944 /* Make a ".reg2/999" section */
9946 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
9947 len
= strlen (buf
) + 1;
9948 name
= bfd_alloc (abfd
, len
);
9951 memcpy (name
, buf
, len
);
9953 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9957 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9958 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
9959 sect
->filepos
= note
->descpos
9960 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
9963 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9964 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9965 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9968 sect
->alignment_power
= 2;
9970 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9972 #endif /* defined (HAVE_LWPSTATUS_T) */
9975 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9982 int is_active_thread
;
9985 if (note
->descsz
< 728)
9988 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9991 type
= bfd_get_32 (abfd
, note
->descdata
);
9995 case 1 /* NOTE_INFO_PROCESS */:
9996 /* FIXME: need to add ->core->command. */
9997 /* process_info.pid */
9998 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9999 /* process_info.signal */
10000 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10003 case 2 /* NOTE_INFO_THREAD */:
10004 /* Make a ".reg/999" section. */
10005 /* thread_info.tid */
10006 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
10008 len
= strlen (buf
) + 1;
10009 name
= (char *) bfd_alloc (abfd
, len
);
10013 memcpy (name
, buf
, len
);
10015 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10019 /* sizeof (thread_info.thread_context) */
10021 /* offsetof (thread_info.thread_context) */
10022 sect
->filepos
= note
->descpos
+ 12;
10023 sect
->alignment_power
= 2;
10025 /* thread_info.is_active_thread */
10026 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10028 if (is_active_thread
)
10029 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10033 case 3 /* NOTE_INFO_MODULE */:
10034 /* Make a ".module/xxxxxxxx" section. */
10035 /* module_info.base_address */
10036 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10037 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10039 len
= strlen (buf
) + 1;
10040 name
= (char *) bfd_alloc (abfd
, len
);
10044 memcpy (name
, buf
, len
);
10046 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10051 sect
->size
= note
->descsz
;
10052 sect
->filepos
= note
->descpos
;
10053 sect
->alignment_power
= 2;
10064 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10066 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10068 switch (note
->type
)
10074 if (bed
->elf_backend_grok_prstatus
)
10075 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10077 #if defined (HAVE_PRSTATUS_T)
10078 return elfcore_grok_prstatus (abfd
, note
);
10083 #if defined (HAVE_PSTATUS_T)
10085 return elfcore_grok_pstatus (abfd
, note
);
10088 #if defined (HAVE_LWPSTATUS_T)
10090 return elfcore_grok_lwpstatus (abfd
, note
);
10093 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10094 return elfcore_grok_prfpreg (abfd
, note
);
10096 case NT_WIN32PSTATUS
:
10097 return elfcore_grok_win32pstatus (abfd
, note
);
10099 case NT_PRXFPREG
: /* Linux SSE extension */
10100 if (note
->namesz
== 6
10101 && strcmp (note
->namedata
, "LINUX") == 0)
10102 return elfcore_grok_prxfpreg (abfd
, note
);
10106 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10107 if (note
->namesz
== 6
10108 && strcmp (note
->namedata
, "LINUX") == 0)
10109 return elfcore_grok_xstatereg (abfd
, note
);
10114 if (note
->namesz
== 6
10115 && strcmp (note
->namedata
, "LINUX") == 0)
10116 return elfcore_grok_ppc_vmx (abfd
, note
);
10121 if (note
->namesz
== 6
10122 && strcmp (note
->namedata
, "LINUX") == 0)
10123 return elfcore_grok_ppc_vsx (abfd
, note
);
10128 if (note
->namesz
== 6
10129 && strcmp (note
->namedata
, "LINUX") == 0)
10130 return elfcore_grok_ppc_tar (abfd
, note
);
10135 if (note
->namesz
== 6
10136 && strcmp (note
->namedata
, "LINUX") == 0)
10137 return elfcore_grok_ppc_ppr (abfd
, note
);
10142 if (note
->namesz
== 6
10143 && strcmp (note
->namedata
, "LINUX") == 0)
10144 return elfcore_grok_ppc_dscr (abfd
, note
);
10149 if (note
->namesz
== 6
10150 && strcmp (note
->namedata
, "LINUX") == 0)
10151 return elfcore_grok_ppc_ebb (abfd
, note
);
10156 if (note
->namesz
== 6
10157 && strcmp (note
->namedata
, "LINUX") == 0)
10158 return elfcore_grok_ppc_pmu (abfd
, note
);
10162 case NT_PPC_TM_CGPR
:
10163 if (note
->namesz
== 6
10164 && strcmp (note
->namedata
, "LINUX") == 0)
10165 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10169 case NT_PPC_TM_CFPR
:
10170 if (note
->namesz
== 6
10171 && strcmp (note
->namedata
, "LINUX") == 0)
10172 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10176 case NT_PPC_TM_CVMX
:
10177 if (note
->namesz
== 6
10178 && strcmp (note
->namedata
, "LINUX") == 0)
10179 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10183 case NT_PPC_TM_CVSX
:
10184 if (note
->namesz
== 6
10185 && strcmp (note
->namedata
, "LINUX") == 0)
10186 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10190 case NT_PPC_TM_SPR
:
10191 if (note
->namesz
== 6
10192 && strcmp (note
->namedata
, "LINUX") == 0)
10193 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10197 case NT_PPC_TM_CTAR
:
10198 if (note
->namesz
== 6
10199 && strcmp (note
->namedata
, "LINUX") == 0)
10200 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10204 case NT_PPC_TM_CPPR
:
10205 if (note
->namesz
== 6
10206 && strcmp (note
->namedata
, "LINUX") == 0)
10207 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10211 case NT_PPC_TM_CDSCR
:
10212 if (note
->namesz
== 6
10213 && strcmp (note
->namedata
, "LINUX") == 0)
10214 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10218 case NT_S390_HIGH_GPRS
:
10219 if (note
->namesz
== 6
10220 && strcmp (note
->namedata
, "LINUX") == 0)
10221 return elfcore_grok_s390_high_gprs (abfd
, note
);
10225 case NT_S390_TIMER
:
10226 if (note
->namesz
== 6
10227 && strcmp (note
->namedata
, "LINUX") == 0)
10228 return elfcore_grok_s390_timer (abfd
, note
);
10232 case NT_S390_TODCMP
:
10233 if (note
->namesz
== 6
10234 && strcmp (note
->namedata
, "LINUX") == 0)
10235 return elfcore_grok_s390_todcmp (abfd
, note
);
10239 case NT_S390_TODPREG
:
10240 if (note
->namesz
== 6
10241 && strcmp (note
->namedata
, "LINUX") == 0)
10242 return elfcore_grok_s390_todpreg (abfd
, note
);
10247 if (note
->namesz
== 6
10248 && strcmp (note
->namedata
, "LINUX") == 0)
10249 return elfcore_grok_s390_ctrs (abfd
, note
);
10253 case NT_S390_PREFIX
:
10254 if (note
->namesz
== 6
10255 && strcmp (note
->namedata
, "LINUX") == 0)
10256 return elfcore_grok_s390_prefix (abfd
, note
);
10260 case NT_S390_LAST_BREAK
:
10261 if (note
->namesz
== 6
10262 && strcmp (note
->namedata
, "LINUX") == 0)
10263 return elfcore_grok_s390_last_break (abfd
, note
);
10267 case NT_S390_SYSTEM_CALL
:
10268 if (note
->namesz
== 6
10269 && strcmp (note
->namedata
, "LINUX") == 0)
10270 return elfcore_grok_s390_system_call (abfd
, note
);
10275 if (note
->namesz
== 6
10276 && strcmp (note
->namedata
, "LINUX") == 0)
10277 return elfcore_grok_s390_tdb (abfd
, note
);
10281 case NT_S390_VXRS_LOW
:
10282 if (note
->namesz
== 6
10283 && strcmp (note
->namedata
, "LINUX") == 0)
10284 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10288 case NT_S390_VXRS_HIGH
:
10289 if (note
->namesz
== 6
10290 && strcmp (note
->namedata
, "LINUX") == 0)
10291 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10295 case NT_S390_GS_CB
:
10296 if (note
->namesz
== 6
10297 && strcmp (note
->namedata
, "LINUX") == 0)
10298 return elfcore_grok_s390_gs_cb (abfd
, note
);
10302 case NT_S390_GS_BC
:
10303 if (note
->namesz
== 6
10304 && strcmp (note
->namedata
, "LINUX") == 0)
10305 return elfcore_grok_s390_gs_bc (abfd
, note
);
10310 if (note
->namesz
== 6
10311 && strcmp (note
->namedata
, "LINUX") == 0)
10312 return elfcore_grok_arm_vfp (abfd
, note
);
10317 if (note
->namesz
== 6
10318 && strcmp (note
->namedata
, "LINUX") == 0)
10319 return elfcore_grok_aarch_tls (abfd
, note
);
10323 case NT_ARM_HW_BREAK
:
10324 if (note
->namesz
== 6
10325 && strcmp (note
->namedata
, "LINUX") == 0)
10326 return elfcore_grok_aarch_hw_break (abfd
, note
);
10330 case NT_ARM_HW_WATCH
:
10331 if (note
->namesz
== 6
10332 && strcmp (note
->namedata
, "LINUX") == 0)
10333 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10338 if (note
->namesz
== 6
10339 && strcmp (note
->namedata
, "LINUX") == 0)
10340 return elfcore_grok_aarch_sve (abfd
, note
);
10344 case NT_ARM_PAC_MASK
:
10345 if (note
->namesz
== 6
10346 && strcmp (note
->namedata
, "LINUX") == 0)
10347 return elfcore_grok_aarch_pauth (abfd
, note
);
10353 if (bed
->elf_backend_grok_psinfo
)
10354 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10356 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10357 return elfcore_grok_psinfo (abfd
, note
);
10363 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10366 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10370 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10377 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10379 struct bfd_build_id
* build_id
;
10381 if (note
->descsz
== 0)
10384 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10385 if (build_id
== NULL
)
10388 build_id
->size
= note
->descsz
;
10389 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10390 abfd
->build_id
= build_id
;
10396 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10398 switch (note
->type
)
10403 case NT_GNU_PROPERTY_TYPE_0
:
10404 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10406 case NT_GNU_BUILD_ID
:
10407 return elfobj_grok_gnu_build_id (abfd
, note
);
10412 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10414 struct sdt_note
*cur
=
10415 (struct sdt_note
*) bfd_alloc (abfd
,
10416 sizeof (struct sdt_note
) + note
->descsz
);
10418 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10419 cur
->size
= (bfd_size_type
) note
->descsz
;
10420 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10422 elf_tdata (abfd
)->sdt_note_head
= cur
;
10428 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10430 switch (note
->type
)
10433 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10441 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10445 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10448 if (note
->descsz
< 108)
10453 if (note
->descsz
< 120)
10461 /* Check for version 1 in pr_version. */
10462 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10467 /* Skip over pr_psinfosz. */
10468 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10472 offset
+= 4; /* Padding before pr_psinfosz. */
10476 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10477 elf_tdata (abfd
)->core
->program
10478 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10481 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10482 elf_tdata (abfd
)->core
->command
10483 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10486 /* Padding before pr_pid. */
10489 /* The pr_pid field was added in version "1a". */
10490 if (note
->descsz
< offset
+ 4)
10493 elf_tdata (abfd
)->core
->pid
10494 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10500 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10506 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10507 Also compute minimum size of this note. */
10508 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10512 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10516 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10517 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10524 if (note
->descsz
< min_size
)
10527 /* Check for version 1 in pr_version. */
10528 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10531 /* Extract size of pr_reg from pr_gregsetsz. */
10532 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10533 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10535 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10540 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10544 /* Skip over pr_osreldate. */
10547 /* Read signal from pr_cursig. */
10548 if (elf_tdata (abfd
)->core
->signal
== 0)
10549 elf_tdata (abfd
)->core
->signal
10550 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10553 /* Read TID from pr_pid. */
10554 elf_tdata (abfd
)->core
->lwpid
10555 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10558 /* Padding before pr_reg. */
10559 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10562 /* Make sure that there is enough data remaining in the note. */
10563 if ((note
->descsz
- offset
) < size
)
10566 /* Make a ".reg/999" section and a ".reg" section. */
10567 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10568 size
, note
->descpos
+ offset
);
10572 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10574 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10576 switch (note
->type
)
10579 if (bed
->elf_backend_grok_freebsd_prstatus
)
10580 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10582 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10585 return elfcore_grok_prfpreg (abfd
, note
);
10588 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10590 case NT_FREEBSD_THRMISC
:
10591 if (note
->namesz
== 8)
10592 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10596 case NT_FREEBSD_PROCSTAT_PROC
:
10597 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10600 case NT_FREEBSD_PROCSTAT_FILES
:
10601 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10604 case NT_FREEBSD_PROCSTAT_VMMAP
:
10605 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10608 case NT_FREEBSD_PROCSTAT_AUXV
:
10609 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10611 case NT_X86_XSTATE
:
10612 if (note
->namesz
== 8)
10613 return elfcore_grok_xstatereg (abfd
, note
);
10617 case NT_FREEBSD_PTLWPINFO
:
10618 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10622 return elfcore_grok_arm_vfp (abfd
, note
);
10630 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10634 cp
= strchr (note
->namedata
, '@');
10637 *lwpidp
= atoi(cp
+ 1);
10644 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10646 if (note
->descsz
<= 0x7c + 31)
10649 /* Signal number at offset 0x08. */
10650 elf_tdata (abfd
)->core
->signal
10651 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10653 /* Process ID at offset 0x50. */
10654 elf_tdata (abfd
)->core
->pid
10655 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10657 /* Command name at 0x7c (max 32 bytes, including nul). */
10658 elf_tdata (abfd
)->core
->command
10659 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10661 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10666 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10670 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10671 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10673 switch (note
->type
)
10675 case NT_NETBSDCORE_PROCINFO
:
10676 /* NetBSD-specific core "procinfo". Note that we expect to
10677 find this note before any of the others, which is fine,
10678 since the kernel writes this note out first when it
10679 creates a core file. */
10680 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10681 #ifdef NT_NETBSDCORE_AUXV
10682 case NT_NETBSDCORE_AUXV
:
10683 /* NetBSD-specific Elf Auxiliary Vector data. */
10684 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10690 /* As of March 2017 there are no other machine-independent notes
10691 defined for NetBSD core files. If the note type is less
10692 than the start of the machine-dependent note types, we don't
10695 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10699 switch (bfd_get_arch (abfd
))
10701 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10702 PT_GETFPREGS == mach+2. */
10704 case bfd_arch_alpha
:
10705 case bfd_arch_sparc
:
10706 switch (note
->type
)
10708 case NT_NETBSDCORE_FIRSTMACH
+0:
10709 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10711 case NT_NETBSDCORE_FIRSTMACH
+2:
10712 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10718 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10719 There's also old PT___GETREGS40 == mach + 1 for old reg
10720 structure which lacks GBR. */
10723 switch (note
->type
)
10725 case NT_NETBSDCORE_FIRSTMACH
+3:
10726 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10728 case NT_NETBSDCORE_FIRSTMACH
+5:
10729 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10735 /* On all other arch's, PT_GETREGS == mach+1 and
10736 PT_GETFPREGS == mach+3. */
10739 switch (note
->type
)
10741 case NT_NETBSDCORE_FIRSTMACH
+1:
10742 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10744 case NT_NETBSDCORE_FIRSTMACH
+3:
10745 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10755 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10757 if (note
->descsz
<= 0x48 + 31)
10760 /* Signal number at offset 0x08. */
10761 elf_tdata (abfd
)->core
->signal
10762 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10764 /* Process ID at offset 0x20. */
10765 elf_tdata (abfd
)->core
->pid
10766 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
10768 /* Command name at 0x48 (max 32 bytes, including nul). */
10769 elf_tdata (abfd
)->core
->command
10770 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
10776 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10778 if (note
->type
== NT_OPENBSD_PROCINFO
)
10779 return elfcore_grok_openbsd_procinfo (abfd
, note
);
10781 if (note
->type
== NT_OPENBSD_REGS
)
10782 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10784 if (note
->type
== NT_OPENBSD_FPREGS
)
10785 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10787 if (note
->type
== NT_OPENBSD_XFPREGS
)
10788 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
10790 if (note
->type
== NT_OPENBSD_AUXV
)
10791 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10793 if (note
->type
== NT_OPENBSD_WCOOKIE
)
10795 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
10800 sect
->size
= note
->descsz
;
10801 sect
->filepos
= note
->descpos
;
10802 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10811 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
10813 void *ddata
= note
->descdata
;
10820 if (note
->descsz
< 16)
10823 /* nto_procfs_status 'pid' field is at offset 0. */
10824 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
10826 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10827 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
10829 /* nto_procfs_status 'flags' field is at offset 8. */
10830 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
10832 /* nto_procfs_status 'what' field is at offset 14. */
10833 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
10835 elf_tdata (abfd
)->core
->signal
= sig
;
10836 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10839 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10840 do not come from signals so we make sure we set the current
10841 thread just in case. */
10842 if (flags
& 0x00000080)
10843 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10845 /* Make a ".qnx_core_status/%d" section. */
10846 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
10848 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10851 strcpy (name
, buf
);
10853 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10857 sect
->size
= note
->descsz
;
10858 sect
->filepos
= note
->descpos
;
10859 sect
->alignment_power
= 2;
10861 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
10865 elfcore_grok_nto_regs (bfd
*abfd
,
10866 Elf_Internal_Note
*note
,
10874 /* Make a "(base)/%d" section. */
10875 sprintf (buf
, "%s/%ld", base
, tid
);
10877 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10880 strcpy (name
, buf
);
10882 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10886 sect
->size
= note
->descsz
;
10887 sect
->filepos
= note
->descpos
;
10888 sect
->alignment_power
= 2;
10890 /* This is the current thread. */
10891 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
10892 return elfcore_maybe_make_sect (abfd
, base
, sect
);
10897 #define BFD_QNT_CORE_INFO 7
10898 #define BFD_QNT_CORE_STATUS 8
10899 #define BFD_QNT_CORE_GREG 9
10900 #define BFD_QNT_CORE_FPREG 10
10903 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10905 /* Every GREG section has a STATUS section before it. Store the
10906 tid from the previous call to pass down to the next gregs
10908 static long tid
= 1;
10910 switch (note
->type
)
10912 case BFD_QNT_CORE_INFO
:
10913 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
10914 case BFD_QNT_CORE_STATUS
:
10915 return elfcore_grok_nto_status (abfd
, note
, &tid
);
10916 case BFD_QNT_CORE_GREG
:
10917 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
10918 case BFD_QNT_CORE_FPREG
:
10919 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
10926 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10932 /* Use note name as section name. */
10933 len
= note
->namesz
;
10934 name
= (char *) bfd_alloc (abfd
, len
);
10937 memcpy (name
, note
->namedata
, len
);
10938 name
[len
- 1] = '\0';
10940 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10944 sect
->size
= note
->descsz
;
10945 sect
->filepos
= note
->descpos
;
10946 sect
->alignment_power
= 1;
10951 /* Function: elfcore_write_note
10954 buffer to hold note, and current size of buffer
10958 size of data for note
10960 Writes note to end of buffer. ELF64 notes are written exactly as
10961 for ELF32, despite the current (as of 2006) ELF gabi specifying
10962 that they ought to have 8-byte namesz and descsz field, and have
10963 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10966 Pointer to realloc'd buffer, *BUFSIZ updated. */
10969 elfcore_write_note (bfd
*abfd
,
10977 Elf_External_Note
*xnp
;
10984 namesz
= strlen (name
) + 1;
10986 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
10988 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
10991 dest
= buf
+ *bufsiz
;
10992 *bufsiz
+= newspace
;
10993 xnp
= (Elf_External_Note
*) dest
;
10994 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
10995 H_PUT_32 (abfd
, size
, xnp
->descsz
);
10996 H_PUT_32 (abfd
, type
, xnp
->type
);
11000 memcpy (dest
, name
, namesz
);
11008 memcpy (dest
, input
, size
);
11018 /* gcc-8 warns (*) on all the strncpy calls in this function about
11019 possible string truncation. The "truncation" is not a bug. We
11020 have an external representation of structs with fields that are not
11021 necessarily NULL terminated and corresponding internal
11022 representation fields that are one larger so that they can always
11023 be NULL terminated.
11024 gcc versions between 4.2 and 4.6 do not allow pragma control of
11025 diagnostics inside functions, giving a hard error if you try to use
11026 the finer control available with later versions.
11027 gcc prior to 4.2 warns about diagnostic push and pop.
11028 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11029 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11030 (*) Depending on your system header files! */
11031 #if GCC_VERSION >= 8000
11032 # pragma GCC diagnostic push
11033 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11036 elfcore_write_prpsinfo (bfd
*abfd
,
11040 const char *psargs
)
11042 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11044 if (bed
->elf_backend_write_core_note
!= NULL
)
11047 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11048 NT_PRPSINFO
, fname
, psargs
);
11053 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11054 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11055 if (bed
->s
->elfclass
== ELFCLASS32
)
11057 # if defined (HAVE_PSINFO32_T)
11059 int note_type
= NT_PSINFO
;
11062 int note_type
= NT_PRPSINFO
;
11065 memset (&data
, 0, sizeof (data
));
11066 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11067 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11068 return elfcore_write_note (abfd
, buf
, bufsiz
,
11069 "CORE", note_type
, &data
, sizeof (data
));
11074 # if defined (HAVE_PSINFO_T)
11076 int note_type
= NT_PSINFO
;
11079 int note_type
= NT_PRPSINFO
;
11082 memset (&data
, 0, sizeof (data
));
11083 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11084 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11085 return elfcore_write_note (abfd
, buf
, bufsiz
,
11086 "CORE", note_type
, &data
, sizeof (data
));
11088 #endif /* PSINFO_T or PRPSINFO_T */
11093 #if GCC_VERSION >= 8000
11094 # pragma GCC diagnostic pop
11098 elfcore_write_linux_prpsinfo32
11099 (bfd
*abfd
, char *buf
, int *bufsiz
,
11100 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11102 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11104 struct elf_external_linux_prpsinfo32_ugid16 data
;
11106 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11107 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11108 &data
, sizeof (data
));
11112 struct elf_external_linux_prpsinfo32_ugid32 data
;
11114 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11115 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11116 &data
, sizeof (data
));
11121 elfcore_write_linux_prpsinfo64
11122 (bfd
*abfd
, char *buf
, int *bufsiz
,
11123 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11125 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11127 struct elf_external_linux_prpsinfo64_ugid16 data
;
11129 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11130 return elfcore_write_note (abfd
, buf
, bufsiz
,
11131 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11135 struct elf_external_linux_prpsinfo64_ugid32 data
;
11137 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11138 return elfcore_write_note (abfd
, buf
, bufsiz
,
11139 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11144 elfcore_write_prstatus (bfd
*abfd
,
11151 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11153 if (bed
->elf_backend_write_core_note
!= NULL
)
11156 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11158 pid
, cursig
, gregs
);
11163 #if defined (HAVE_PRSTATUS_T)
11164 #if defined (HAVE_PRSTATUS32_T)
11165 if (bed
->s
->elfclass
== ELFCLASS32
)
11167 prstatus32_t prstat
;
11169 memset (&prstat
, 0, sizeof (prstat
));
11170 prstat
.pr_pid
= pid
;
11171 prstat
.pr_cursig
= cursig
;
11172 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11173 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11174 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11181 memset (&prstat
, 0, sizeof (prstat
));
11182 prstat
.pr_pid
= pid
;
11183 prstat
.pr_cursig
= cursig
;
11184 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11185 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11186 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11188 #endif /* HAVE_PRSTATUS_T */
11194 #if defined (HAVE_LWPSTATUS_T)
11196 elfcore_write_lwpstatus (bfd
*abfd
,
11203 lwpstatus_t lwpstat
;
11204 const char *note_name
= "CORE";
11206 memset (&lwpstat
, 0, sizeof (lwpstat
));
11207 lwpstat
.pr_lwpid
= pid
>> 16;
11208 lwpstat
.pr_cursig
= cursig
;
11209 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11210 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11211 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11212 #if !defined(gregs)
11213 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11214 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11216 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11217 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11220 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11221 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11223 #endif /* HAVE_LWPSTATUS_T */
11225 #if defined (HAVE_PSTATUS_T)
11227 elfcore_write_pstatus (bfd
*abfd
,
11231 int cursig ATTRIBUTE_UNUSED
,
11232 const void *gregs ATTRIBUTE_UNUSED
)
11234 const char *note_name
= "CORE";
11235 #if defined (HAVE_PSTATUS32_T)
11236 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11238 if (bed
->s
->elfclass
== ELFCLASS32
)
11242 memset (&pstat
, 0, sizeof (pstat
));
11243 pstat
.pr_pid
= pid
& 0xffff;
11244 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11245 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11253 memset (&pstat
, 0, sizeof (pstat
));
11254 pstat
.pr_pid
= pid
& 0xffff;
11255 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11256 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11260 #endif /* HAVE_PSTATUS_T */
11263 elfcore_write_prfpreg (bfd
*abfd
,
11266 const void *fpregs
,
11269 const char *note_name
= "CORE";
11270 return elfcore_write_note (abfd
, buf
, bufsiz
,
11271 note_name
, NT_FPREGSET
, fpregs
, size
);
11275 elfcore_write_prxfpreg (bfd
*abfd
,
11278 const void *xfpregs
,
11281 char *note_name
= "LINUX";
11282 return elfcore_write_note (abfd
, buf
, bufsiz
,
11283 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11287 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11288 const void *xfpregs
, int size
)
11291 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11292 note_name
= "FreeBSD";
11294 note_name
= "LINUX";
11295 return elfcore_write_note (abfd
, buf
, bufsiz
,
11296 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11300 elfcore_write_ppc_vmx (bfd
*abfd
,
11303 const void *ppc_vmx
,
11306 char *note_name
= "LINUX";
11307 return elfcore_write_note (abfd
, buf
, bufsiz
,
11308 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11312 elfcore_write_ppc_vsx (bfd
*abfd
,
11315 const void *ppc_vsx
,
11318 char *note_name
= "LINUX";
11319 return elfcore_write_note (abfd
, buf
, bufsiz
,
11320 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11324 elfcore_write_ppc_tar (bfd
*abfd
,
11327 const void *ppc_tar
,
11330 char *note_name
= "LINUX";
11331 return elfcore_write_note (abfd
, buf
, bufsiz
,
11332 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11336 elfcore_write_ppc_ppr (bfd
*abfd
,
11339 const void *ppc_ppr
,
11342 char *note_name
= "LINUX";
11343 return elfcore_write_note (abfd
, buf
, bufsiz
,
11344 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11348 elfcore_write_ppc_dscr (bfd
*abfd
,
11351 const void *ppc_dscr
,
11354 char *note_name
= "LINUX";
11355 return elfcore_write_note (abfd
, buf
, bufsiz
,
11356 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11360 elfcore_write_ppc_ebb (bfd
*abfd
,
11363 const void *ppc_ebb
,
11366 char *note_name
= "LINUX";
11367 return elfcore_write_note (abfd
, buf
, bufsiz
,
11368 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11372 elfcore_write_ppc_pmu (bfd
*abfd
,
11375 const void *ppc_pmu
,
11378 char *note_name
= "LINUX";
11379 return elfcore_write_note (abfd
, buf
, bufsiz
,
11380 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11384 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11387 const void *ppc_tm_cgpr
,
11390 char *note_name
= "LINUX";
11391 return elfcore_write_note (abfd
, buf
, bufsiz
,
11392 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11396 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11399 const void *ppc_tm_cfpr
,
11402 char *note_name
= "LINUX";
11403 return elfcore_write_note (abfd
, buf
, bufsiz
,
11404 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11408 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11411 const void *ppc_tm_cvmx
,
11414 char *note_name
= "LINUX";
11415 return elfcore_write_note (abfd
, buf
, bufsiz
,
11416 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11420 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11423 const void *ppc_tm_cvsx
,
11426 char *note_name
= "LINUX";
11427 return elfcore_write_note (abfd
, buf
, bufsiz
,
11428 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11432 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11435 const void *ppc_tm_spr
,
11438 char *note_name
= "LINUX";
11439 return elfcore_write_note (abfd
, buf
, bufsiz
,
11440 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11444 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11447 const void *ppc_tm_ctar
,
11450 char *note_name
= "LINUX";
11451 return elfcore_write_note (abfd
, buf
, bufsiz
,
11452 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11456 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11459 const void *ppc_tm_cppr
,
11462 char *note_name
= "LINUX";
11463 return elfcore_write_note (abfd
, buf
, bufsiz
,
11464 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11468 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11471 const void *ppc_tm_cdscr
,
11474 char *note_name
= "LINUX";
11475 return elfcore_write_note (abfd
, buf
, bufsiz
,
11476 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11480 elfcore_write_s390_high_gprs (bfd
*abfd
,
11483 const void *s390_high_gprs
,
11486 char *note_name
= "LINUX";
11487 return elfcore_write_note (abfd
, buf
, bufsiz
,
11488 note_name
, NT_S390_HIGH_GPRS
,
11489 s390_high_gprs
, size
);
11493 elfcore_write_s390_timer (bfd
*abfd
,
11496 const void *s390_timer
,
11499 char *note_name
= "LINUX";
11500 return elfcore_write_note (abfd
, buf
, bufsiz
,
11501 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11505 elfcore_write_s390_todcmp (bfd
*abfd
,
11508 const void *s390_todcmp
,
11511 char *note_name
= "LINUX";
11512 return elfcore_write_note (abfd
, buf
, bufsiz
,
11513 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11517 elfcore_write_s390_todpreg (bfd
*abfd
,
11520 const void *s390_todpreg
,
11523 char *note_name
= "LINUX";
11524 return elfcore_write_note (abfd
, buf
, bufsiz
,
11525 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11529 elfcore_write_s390_ctrs (bfd
*abfd
,
11532 const void *s390_ctrs
,
11535 char *note_name
= "LINUX";
11536 return elfcore_write_note (abfd
, buf
, bufsiz
,
11537 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11541 elfcore_write_s390_prefix (bfd
*abfd
,
11544 const void *s390_prefix
,
11547 char *note_name
= "LINUX";
11548 return elfcore_write_note (abfd
, buf
, bufsiz
,
11549 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11553 elfcore_write_s390_last_break (bfd
*abfd
,
11556 const void *s390_last_break
,
11559 char *note_name
= "LINUX";
11560 return elfcore_write_note (abfd
, buf
, bufsiz
,
11561 note_name
, NT_S390_LAST_BREAK
,
11562 s390_last_break
, size
);
11566 elfcore_write_s390_system_call (bfd
*abfd
,
11569 const void *s390_system_call
,
11572 char *note_name
= "LINUX";
11573 return elfcore_write_note (abfd
, buf
, bufsiz
,
11574 note_name
, NT_S390_SYSTEM_CALL
,
11575 s390_system_call
, size
);
11579 elfcore_write_s390_tdb (bfd
*abfd
,
11582 const void *s390_tdb
,
11585 char *note_name
= "LINUX";
11586 return elfcore_write_note (abfd
, buf
, bufsiz
,
11587 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11591 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11594 const void *s390_vxrs_low
,
11597 char *note_name
= "LINUX";
11598 return elfcore_write_note (abfd
, buf
, bufsiz
,
11599 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11603 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11606 const void *s390_vxrs_high
,
11609 char *note_name
= "LINUX";
11610 return elfcore_write_note (abfd
, buf
, bufsiz
,
11611 note_name
, NT_S390_VXRS_HIGH
,
11612 s390_vxrs_high
, size
);
11616 elfcore_write_s390_gs_cb (bfd
*abfd
,
11619 const void *s390_gs_cb
,
11622 char *note_name
= "LINUX";
11623 return elfcore_write_note (abfd
, buf
, bufsiz
,
11624 note_name
, NT_S390_GS_CB
,
11629 elfcore_write_s390_gs_bc (bfd
*abfd
,
11632 const void *s390_gs_bc
,
11635 char *note_name
= "LINUX";
11636 return elfcore_write_note (abfd
, buf
, bufsiz
,
11637 note_name
, NT_S390_GS_BC
,
11642 elfcore_write_arm_vfp (bfd
*abfd
,
11645 const void *arm_vfp
,
11648 char *note_name
= "LINUX";
11649 return elfcore_write_note (abfd
, buf
, bufsiz
,
11650 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11654 elfcore_write_aarch_tls (bfd
*abfd
,
11657 const void *aarch_tls
,
11660 char *note_name
= "LINUX";
11661 return elfcore_write_note (abfd
, buf
, bufsiz
,
11662 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11666 elfcore_write_aarch_hw_break (bfd
*abfd
,
11669 const void *aarch_hw_break
,
11672 char *note_name
= "LINUX";
11673 return elfcore_write_note (abfd
, buf
, bufsiz
,
11674 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11678 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11681 const void *aarch_hw_watch
,
11684 char *note_name
= "LINUX";
11685 return elfcore_write_note (abfd
, buf
, bufsiz
,
11686 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11690 elfcore_write_aarch_sve (bfd
*abfd
,
11693 const void *aarch_sve
,
11696 char *note_name
= "LINUX";
11697 return elfcore_write_note (abfd
, buf
, bufsiz
,
11698 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11702 elfcore_write_aarch_pauth (bfd
*abfd
,
11705 const void *aarch_pauth
,
11708 char *note_name
= "LINUX";
11709 return elfcore_write_note (abfd
, buf
, bufsiz
,
11710 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11714 elfcore_write_register_note (bfd
*abfd
,
11717 const char *section
,
11721 if (strcmp (section
, ".reg2") == 0)
11722 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
11723 if (strcmp (section
, ".reg-xfp") == 0)
11724 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
11725 if (strcmp (section
, ".reg-xstate") == 0)
11726 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
11727 if (strcmp (section
, ".reg-ppc-vmx") == 0)
11728 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
11729 if (strcmp (section
, ".reg-ppc-vsx") == 0)
11730 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
11731 if (strcmp (section
, ".reg-ppc-tar") == 0)
11732 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
11733 if (strcmp (section
, ".reg-ppc-ppr") == 0)
11734 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
11735 if (strcmp (section
, ".reg-ppc-dscr") == 0)
11736 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
11737 if (strcmp (section
, ".reg-ppc-ebb") == 0)
11738 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
11739 if (strcmp (section
, ".reg-ppc-pmu") == 0)
11740 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
11741 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
11742 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
11743 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
11744 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
11745 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
11746 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
11747 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
11748 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
11749 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
11750 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
11751 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
11752 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
11753 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
11754 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
11755 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
11756 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
11757 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
11758 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
11759 if (strcmp (section
, ".reg-s390-timer") == 0)
11760 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
11761 if (strcmp (section
, ".reg-s390-todcmp") == 0)
11762 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
11763 if (strcmp (section
, ".reg-s390-todpreg") == 0)
11764 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
11765 if (strcmp (section
, ".reg-s390-ctrs") == 0)
11766 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
11767 if (strcmp (section
, ".reg-s390-prefix") == 0)
11768 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
11769 if (strcmp (section
, ".reg-s390-last-break") == 0)
11770 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
11771 if (strcmp (section
, ".reg-s390-system-call") == 0)
11772 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
11773 if (strcmp (section
, ".reg-s390-tdb") == 0)
11774 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
11775 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
11776 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
11777 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
11778 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
11779 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
11780 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
11781 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
11782 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
11783 if (strcmp (section
, ".reg-arm-vfp") == 0)
11784 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
11785 if (strcmp (section
, ".reg-aarch-tls") == 0)
11786 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
11787 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
11788 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
11789 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
11790 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
11791 if (strcmp (section
, ".reg-aarch-sve") == 0)
11792 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
11793 if (strcmp (section
, ".reg-aarch-pauth") == 0)
11794 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
11799 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
11804 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11805 gABI specifies that PT_NOTE alignment should be aligned to 4
11806 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11807 align is less than 4, we use 4 byte alignment. */
11810 if (align
!= 4 && align
!= 8)
11814 while (p
< buf
+ size
)
11816 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
11817 Elf_Internal_Note in
;
11819 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
11822 in
.type
= H_GET_32 (abfd
, xnp
->type
);
11824 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
11825 in
.namedata
= xnp
->name
;
11826 if (in
.namesz
> buf
- in
.namedata
+ size
)
11829 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
11830 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
11831 in
.descpos
= offset
+ (in
.descdata
- buf
);
11833 && (in
.descdata
>= buf
+ size
11834 || in
.descsz
> buf
- in
.descdata
+ size
))
11837 switch (bfd_get_format (abfd
))
11844 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11847 const char * string
;
11849 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
11853 GROKER_ELEMENT ("", elfcore_grok_note
),
11854 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
11855 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
11856 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
11857 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
11858 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
11859 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
11861 #undef GROKER_ELEMENT
11864 for (i
= ARRAY_SIZE (grokers
); i
--;)
11866 if (in
.namesz
>= grokers
[i
].len
11867 && strncmp (in
.namedata
, grokers
[i
].string
,
11868 grokers
[i
].len
) == 0)
11870 if (! grokers
[i
].func (abfd
, & in
))
11879 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
11881 if (! elfobj_grok_gnu_note (abfd
, &in
))
11884 else if (in
.namesz
== sizeof "stapsdt"
11885 && strcmp (in
.namedata
, "stapsdt") == 0)
11887 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
11893 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
11900 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
11905 if (size
== 0 || (size
+ 1) == 0)
11908 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
11911 buf
= (char *) bfd_malloc (size
+ 1);
11915 /* PR 17512: file: ec08f814
11916 0-termintate the buffer so that string searches will not overflow. */
11919 if (bfd_bread (buf
, size
, abfd
) != size
11920 || !elf_parse_notes (abfd
, buf
, size
, offset
, align
))
11930 /* Providing external access to the ELF program header table. */
11932 /* Return an upper bound on the number of bytes required to store a
11933 copy of ABFD's program header table entries. Return -1 if an error
11934 occurs; bfd_get_error will return an appropriate code. */
11937 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
11939 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11941 bfd_set_error (bfd_error_wrong_format
);
11945 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
11948 /* Copy ABFD's program header table entries to *PHDRS. The entries
11949 will be stored as an array of Elf_Internal_Phdr structures, as
11950 defined in include/elf/internal.h. To find out how large the
11951 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11953 Return the number of program header table entries read, or -1 if an
11954 error occurs; bfd_get_error will return an appropriate code. */
11957 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
11961 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11963 bfd_set_error (bfd_error_wrong_format
);
11967 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
11968 if (num_phdrs
!= 0)
11969 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
11970 num_phdrs
* sizeof (Elf_Internal_Phdr
));
11975 enum elf_reloc_type_class
11976 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11977 const asection
*rel_sec ATTRIBUTE_UNUSED
,
11978 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
11980 return reloc_class_normal
;
11983 /* For RELA architectures, return the relocation value for a
11984 relocation against a local symbol. */
11987 _bfd_elf_rela_local_sym (bfd
*abfd
,
11988 Elf_Internal_Sym
*sym
,
11990 Elf_Internal_Rela
*rel
)
11992 asection
*sec
= *psec
;
11993 bfd_vma relocation
;
11995 relocation
= (sec
->output_section
->vma
11996 + sec
->output_offset
11998 if ((sec
->flags
& SEC_MERGE
)
11999 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
12000 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12003 _bfd_merged_section_offset (abfd
, psec
,
12004 elf_section_data (sec
)->sec_info
,
12005 sym
->st_value
+ rel
->r_addend
);
12008 /* If we have changed the section, and our original section is
12009 marked with SEC_EXCLUDE, it means that the original
12010 SEC_MERGE section has been completely subsumed in some
12011 other SEC_MERGE section. In this case, we need to leave
12012 some info around for --emit-relocs. */
12013 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12014 sec
->kept_section
= *psec
;
12017 rel
->r_addend
-= relocation
;
12018 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12024 _bfd_elf_rel_local_sym (bfd
*abfd
,
12025 Elf_Internal_Sym
*sym
,
12029 asection
*sec
= *psec
;
12031 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12032 return sym
->st_value
+ addend
;
12034 return _bfd_merged_section_offset (abfd
, psec
,
12035 elf_section_data (sec
)->sec_info
,
12036 sym
->st_value
+ addend
);
12039 /* Adjust an address within a section. Given OFFSET within SEC, return
12040 the new offset within the section, based upon changes made to the
12041 section. Returns -1 if the offset is now invalid.
12042 The offset (in abnd out) is in target sized bytes, however big a
12046 _bfd_elf_section_offset (bfd
*abfd
,
12047 struct bfd_link_info
*info
,
12051 switch (sec
->sec_info_type
)
12053 case SEC_INFO_TYPE_STABS
:
12054 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12056 case SEC_INFO_TYPE_EH_FRAME
:
12057 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12060 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12062 /* Reverse the offset. */
12063 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12064 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12066 /* address_size and sec->size are in octets. Convert
12067 to bytes before subtracting the original offset. */
12068 offset
= ((sec
->size
- address_size
)
12069 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12075 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12076 reconstruct an ELF file by reading the segments out of remote memory
12077 based on the ELF file header at EHDR_VMA and the ELF program headers it
12078 points to. If not null, *LOADBASEP is filled in with the difference
12079 between the VMAs from which the segments were read, and the VMAs the
12080 file headers (and hence BFD's idea of each section's VMA) put them at.
12082 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12083 remote memory at target address VMA into the local buffer at MYADDR; it
12084 should return zero on success or an `errno' code on failure. TEMPL must
12085 be a BFD for an ELF target with the word size and byte order found in
12086 the remote memory. */
12089 bfd_elf_bfd_from_remote_memory
12092 bfd_size_type size
,
12093 bfd_vma
*loadbasep
,
12094 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12096 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12097 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12101 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12102 long symcount ATTRIBUTE_UNUSED
,
12103 asymbol
**syms ATTRIBUTE_UNUSED
,
12108 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12111 const char *relplt_name
;
12112 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
12116 Elf_Internal_Shdr
*hdr
;
12122 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12125 if (dynsymcount
<= 0)
12128 if (!bed
->plt_sym_val
)
12131 relplt_name
= bed
->relplt_name
;
12132 if (relplt_name
== NULL
)
12133 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12134 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12135 if (relplt
== NULL
)
12138 hdr
= &elf_section_data (relplt
)->this_hdr
;
12139 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12140 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12143 plt
= bfd_get_section_by_name (abfd
, ".plt");
12147 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12148 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
12151 count
= relplt
->size
/ hdr
->sh_entsize
;
12152 size
= count
* sizeof (asymbol
);
12153 p
= relplt
->relocation
;
12154 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12156 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12157 if (p
->addend
!= 0)
12160 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12162 size
+= sizeof ("+0x") - 1 + 8;
12167 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12171 names
= (char *) (s
+ count
);
12172 p
= relplt
->relocation
;
12174 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12179 addr
= bed
->plt_sym_val (i
, plt
, p
);
12180 if (addr
== (bfd_vma
) -1)
12183 *s
= **p
->sym_ptr_ptr
;
12184 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12185 we are defining a symbol, ensure one of them is set. */
12186 if ((s
->flags
& BSF_LOCAL
) == 0)
12187 s
->flags
|= BSF_GLOBAL
;
12188 s
->flags
|= BSF_SYNTHETIC
;
12190 s
->value
= addr
- plt
->vma
;
12193 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12194 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12196 if (p
->addend
!= 0)
12200 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12201 names
+= sizeof ("+0x") - 1;
12202 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12203 for (a
= buf
; *a
== '0'; ++a
)
12206 memcpy (names
, a
, len
);
12209 memcpy (names
, "@plt", sizeof ("@plt"));
12210 names
+= sizeof ("@plt");
12217 /* It is only used by x86-64 so far.
12218 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12219 but current usage would allow all of _bfd_std_section to be zero. */
12220 static const asymbol lcomm_sym
12221 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12222 asection _bfd_elf_large_com_section
12223 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12224 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12227 _bfd_elf_final_write_processing (bfd
*abfd
)
12229 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12231 i_ehdrp
= elf_elfheader (abfd
);
12233 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12234 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12236 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12237 SHF_GNU_MBIND sections or symbols of STT_GNU_IFUNC type or
12238 STB_GNU_UNIQUE binding. */
12239 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12241 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12242 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12243 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12244 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12246 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12247 _bfd_error_handler (_("GNU_MBIND section is unsupported"));
12248 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12249 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is unsupported"));
12250 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12251 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is unsupported"));
12252 bfd_set_error (bfd_error_sorry
);
12260 /* Return TRUE for ELF symbol types that represent functions.
12261 This is the default version of this function, which is sufficient for
12262 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12265 _bfd_elf_is_function_type (unsigned int type
)
12267 return (type
== STT_FUNC
12268 || type
== STT_GNU_IFUNC
);
12271 /* If the ELF symbol SYM might be a function in SEC, return the
12272 function size and set *CODE_OFF to the function's entry point,
12273 otherwise return zero. */
12276 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12279 bfd_size_type size
;
12281 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12282 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12283 || sym
->section
!= sec
)
12286 *code_off
= sym
->value
;
12288 if (!(sym
->flags
& BSF_SYNTHETIC
))
12289 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;