1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2022 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 bool assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
54 static bool swap_out_syms (bfd
*, struct elf_strtab_hash
**, int,
55 struct bfd_link_info
*);
56 static bool elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
57 file_ptr offset
, size_t align
);
59 /* Swap version information in and out. The version information is
60 currently size independent. If that ever changes, this code will
61 need to move into elfcode.h. */
63 /* Swap in a Verdef structure. */
66 _bfd_elf_swap_verdef_in (bfd
*abfd
,
67 const Elf_External_Verdef
*src
,
68 Elf_Internal_Verdef
*dst
)
70 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
71 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
72 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
73 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
74 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
75 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
76 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
79 /* Swap out a Verdef structure. */
82 _bfd_elf_swap_verdef_out (bfd
*abfd
,
83 const Elf_Internal_Verdef
*src
,
84 Elf_External_Verdef
*dst
)
86 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
99 const Elf_External_Verdaux
*src
,
100 Elf_Internal_Verdaux
*dst
)
102 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
103 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
106 /* Swap out a Verdaux structure. */
109 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
110 const Elf_Internal_Verdaux
*src
,
111 Elf_External_Verdaux
*dst
)
113 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
114 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
117 /* Swap in a Verneed structure. */
120 _bfd_elf_swap_verneed_in (bfd
*abfd
,
121 const Elf_External_Verneed
*src
,
122 Elf_Internal_Verneed
*dst
)
124 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
125 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
126 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
127 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
128 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
131 /* Swap out a Verneed structure. */
134 _bfd_elf_swap_verneed_out (bfd
*abfd
,
135 const Elf_Internal_Verneed
*src
,
136 Elf_External_Verneed
*dst
)
138 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
139 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
140 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
141 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
142 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
145 /* Swap in a Vernaux structure. */
148 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
149 const Elf_External_Vernaux
*src
,
150 Elf_Internal_Vernaux
*dst
)
152 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
153 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
154 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
155 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
156 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
159 /* Swap out a Vernaux structure. */
162 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
163 const Elf_Internal_Vernaux
*src
,
164 Elf_External_Vernaux
*dst
)
166 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
167 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
168 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
169 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
170 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
173 /* Swap in a Versym structure. */
176 _bfd_elf_swap_versym_in (bfd
*abfd
,
177 const Elf_External_Versym
*src
,
178 Elf_Internal_Versym
*dst
)
180 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
183 /* Swap out a Versym structure. */
186 _bfd_elf_swap_versym_out (bfd
*abfd
,
187 const Elf_Internal_Versym
*src
,
188 Elf_External_Versym
*dst
)
190 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
193 /* Standard ELF hash function. Do not change this function; you will
194 cause invalid hash tables to be generated. */
197 bfd_elf_hash (const char *namearg
)
199 const unsigned char *name
= (const unsigned char *) namearg
;
204 while ((ch
= *name
++) != '\0')
207 if ((g
= (h
& 0xf0000000)) != 0)
210 /* The ELF ABI says `h &= ~g', but this is equivalent in
211 this case and on some machines one insn instead of two. */
215 return h
& 0xffffffff;
218 /* DT_GNU_HASH hash function. Do not change this function; you will
219 cause invalid hash tables to be generated. */
222 bfd_elf_gnu_hash (const char *namearg
)
224 const unsigned char *name
= (const unsigned char *) namearg
;
225 unsigned long h
= 5381;
228 while ((ch
= *name
++) != '\0')
229 h
= (h
<< 5) + h
+ ch
;
230 return h
& 0xffffffff;
233 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
234 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
236 bfd_elf_allocate_object (bfd
*abfd
,
238 enum elf_target_id object_id
)
240 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
241 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
242 if (abfd
->tdata
.any
== NULL
)
245 elf_object_id (abfd
) = object_id
;
246 if (abfd
->direction
!= read_direction
)
248 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
251 elf_tdata (abfd
)->o
= o
;
252 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
259 bfd_elf_make_object (bfd
*abfd
)
261 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
262 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
267 bfd_elf_mkcorefile (bfd
*abfd
)
269 /* I think this can be done just like an object file. */
270 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
272 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
273 return elf_tdata (abfd
)->core
!= NULL
;
277 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
279 Elf_Internal_Shdr
**i_shdrp
;
280 bfd_byte
*shstrtab
= NULL
;
282 bfd_size_type shstrtabsize
;
284 i_shdrp
= elf_elfsections (abfd
);
286 || shindex
>= elf_numsections (abfd
)
287 || i_shdrp
[shindex
] == 0)
290 shstrtab
= i_shdrp
[shindex
]->contents
;
291 if (shstrtab
== NULL
)
293 /* No cached one, attempt to read, and cache what we read. */
294 offset
= i_shdrp
[shindex
]->sh_offset
;
295 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
297 /* Allocate and clear an extra byte at the end, to prevent crashes
298 in case the string table is not terminated. */
299 if (shstrtabsize
+ 1 <= 1
300 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
301 || (shstrtab
= _bfd_alloc_and_read (abfd
, shstrtabsize
+ 1,
302 shstrtabsize
)) == NULL
)
304 /* Once we've failed to read it, make sure we don't keep
305 trying. Otherwise, we'll keep allocating space for
306 the string table over and over. */
307 i_shdrp
[shindex
]->sh_size
= 0;
310 shstrtab
[shstrtabsize
] = '\0';
311 i_shdrp
[shindex
]->contents
= shstrtab
;
313 return (char *) shstrtab
;
317 bfd_elf_string_from_elf_section (bfd
*abfd
,
318 unsigned int shindex
,
319 unsigned int strindex
)
321 Elf_Internal_Shdr
*hdr
;
326 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
329 hdr
= elf_elfsections (abfd
)[shindex
];
331 if (hdr
->contents
== NULL
)
333 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
335 /* PR 17512: file: f057ec89. */
336 /* xgettext:c-format */
337 _bfd_error_handler (_("%pB: attempt to load strings from"
338 " a non-string section (number %d)"),
343 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
348 /* PR 24273: The string section's contents may have already
349 been loaded elsewhere, eg because a corrupt file has the
350 string section index in the ELF header pointing at a group
351 section. So be paranoid, and test that the last byte of
352 the section is zero. */
353 if (hdr
->sh_size
== 0 || hdr
->contents
[hdr
->sh_size
- 1] != 0)
357 if (strindex
>= hdr
->sh_size
)
359 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
361 /* xgettext:c-format */
362 (_("%pB: invalid string offset %u >= %" PRIu64
" for section `%s'"),
363 abfd
, strindex
, (uint64_t) hdr
->sh_size
,
364 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
366 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
370 return ((char *) hdr
->contents
) + strindex
;
373 /* Read and convert symbols to internal format.
374 SYMCOUNT specifies the number of symbols to read, starting from
375 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
376 are non-NULL, they are used to store the internal symbols, external
377 symbols, and symbol section index extensions, respectively.
378 Returns a pointer to the internal symbol buffer (malloced if necessary)
379 or NULL if there were no symbols or some kind of problem. */
382 bfd_elf_get_elf_syms (bfd
*ibfd
,
383 Elf_Internal_Shdr
*symtab_hdr
,
386 Elf_Internal_Sym
*intsym_buf
,
388 Elf_External_Sym_Shndx
*extshndx_buf
)
390 Elf_Internal_Shdr
*shndx_hdr
;
392 const bfd_byte
*esym
;
393 Elf_External_Sym_Shndx
*alloc_extshndx
;
394 Elf_External_Sym_Shndx
*shndx
;
395 Elf_Internal_Sym
*alloc_intsym
;
396 Elf_Internal_Sym
*isym
;
397 Elf_Internal_Sym
*isymend
;
398 const struct elf_backend_data
*bed
;
403 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
409 /* Normal syms might have section extension entries. */
411 if (elf_symtab_shndx_list (ibfd
) != NULL
)
413 elf_section_list
* entry
;
414 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
416 /* Find an index section that is linked to this symtab section. */
417 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
420 if (entry
->hdr
.sh_link
>= elf_numsections (ibfd
))
423 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
425 shndx_hdr
= & entry
->hdr
;
430 if (shndx_hdr
== NULL
)
432 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
433 /* Not really accurate, but this was how the old code used to work. */
434 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
435 /* Otherwise we do nothing. The assumption is that
436 the index table will not be needed. */
440 /* Read the symbols. */
442 alloc_extshndx
= NULL
;
444 bed
= get_elf_backend_data (ibfd
);
445 extsym_size
= bed
->s
->sizeof_sym
;
446 if (_bfd_mul_overflow (symcount
, extsym_size
, &amt
))
448 bfd_set_error (bfd_error_file_too_big
);
452 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
453 if (extsym_buf
== NULL
)
455 alloc_ext
= bfd_malloc (amt
);
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 if (_bfd_mul_overflow (symcount
, sizeof (Elf_External_Sym_Shndx
), &amt
))
472 bfd_set_error (bfd_error_file_too_big
);
476 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
477 if (extshndx_buf
== NULL
)
479 alloc_extshndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
480 extshndx_buf
= alloc_extshndx
;
482 if (extshndx_buf
== NULL
483 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
484 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
491 if (intsym_buf
== NULL
)
493 if (_bfd_mul_overflow (symcount
, sizeof (Elf_Internal_Sym
), &amt
))
495 bfd_set_error (bfd_error_file_too_big
);
498 alloc_intsym
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
499 intsym_buf
= alloc_intsym
;
500 if (intsym_buf
== NULL
)
504 /* Convert the symbols to internal form. */
505 isymend
= intsym_buf
+ symcount
;
506 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
507 shndx
= extshndx_buf
;
509 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
510 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
512 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
513 /* xgettext:c-format */
514 _bfd_error_handler (_("%pB symbol number %lu references"
515 " nonexistent SHT_SYMTAB_SHNDX section"),
516 ibfd
, (unsigned long) symoffset
);
524 free (alloc_extshndx
);
529 /* Look up a symbol name. */
531 bfd_elf_sym_name (bfd
*abfd
,
532 Elf_Internal_Shdr
*symtab_hdr
,
533 Elf_Internal_Sym
*isym
,
537 unsigned int iname
= isym
->st_name
;
538 unsigned int shindex
= symtab_hdr
->sh_link
;
540 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
541 /* Check for a bogus st_shndx to avoid crashing. */
542 && isym
->st_shndx
< elf_numsections (abfd
))
544 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
545 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
548 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
551 else if (sym_sec
&& *name
== '\0')
552 name
= bfd_section_name (sym_sec
);
557 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
558 sections. The first element is the flags, the rest are section
561 typedef union elf_internal_group
{
562 Elf_Internal_Shdr
*shdr
;
564 } Elf_Internal_Group
;
566 /* Return the name of the group signature symbol. Why isn't the
567 signature just a string? */
570 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
572 Elf_Internal_Shdr
*hdr
;
573 unsigned char esym
[sizeof (Elf64_External_Sym
)];
574 Elf_External_Sym_Shndx eshndx
;
575 Elf_Internal_Sym isym
;
577 /* First we need to ensure the symbol table is available. Make sure
578 that it is a symbol table section. */
579 if (ghdr
->sh_link
>= elf_numsections (abfd
))
581 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
582 if (hdr
->sh_type
!= SHT_SYMTAB
583 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
586 /* Go read the symbol. */
587 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
588 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
589 &isym
, esym
, &eshndx
) == NULL
)
592 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
595 /* Set next_in_group list pointer, and group name for NEWSECT. */
598 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
600 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
602 /* If num_group is zero, read in all SHT_GROUP sections. The count
603 is set to -1 if there are no SHT_GROUP sections. */
606 unsigned int i
, shnum
;
608 /* First count the number of groups. If we have a SHT_GROUP
609 section with just a flag word (ie. sh_size is 4), ignore it. */
610 shnum
= elf_numsections (abfd
);
613 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
614 ( (shdr)->sh_type == SHT_GROUP \
615 && (shdr)->sh_size >= minsize \
616 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
617 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
619 for (i
= 0; i
< shnum
; i
++)
621 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
623 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
629 num_group
= (unsigned) -1;
630 elf_tdata (abfd
)->num_group
= num_group
;
631 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
635 /* We keep a list of elf section headers for group sections,
636 so we can find them quickly. */
639 elf_tdata (abfd
)->num_group
= num_group
;
640 amt
= num_group
* sizeof (Elf_Internal_Shdr
*);
641 elf_tdata (abfd
)->group_sect_ptr
642 = (Elf_Internal_Shdr
**) bfd_zalloc (abfd
, amt
);
643 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
647 for (i
= 0; i
< shnum
; i
++)
649 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
651 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
654 Elf_Internal_Group
*dest
;
656 /* Make sure the group section has a BFD section
658 if (!bfd_section_from_shdr (abfd
, i
))
661 /* Add to list of sections. */
662 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
665 /* Read the raw contents. */
666 BFD_ASSERT (sizeof (*dest
) >= 4 && sizeof (*dest
) % 4 == 0);
667 shdr
->contents
= NULL
;
668 if (_bfd_mul_overflow (shdr
->sh_size
,
669 sizeof (*dest
) / 4, &amt
)
670 || bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
672 = _bfd_alloc_and_read (abfd
, amt
, shdr
->sh_size
)))
675 /* xgettext:c-format */
676 (_("%pB: invalid size field in group section"
677 " header: %#" PRIx64
""),
678 abfd
, (uint64_t) shdr
->sh_size
);
679 bfd_set_error (bfd_error_bad_value
);
684 /* Translate raw contents, a flag word followed by an
685 array of elf section indices all in target byte order,
686 to the flag word followed by an array of elf section
688 src
= shdr
->contents
+ shdr
->sh_size
;
689 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
697 idx
= H_GET_32 (abfd
, src
);
698 if (src
== shdr
->contents
)
702 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
703 shdr
->bfd_section
->flags
704 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
709 dest
->shdr
= elf_elfsections (abfd
)[idx
];
710 /* PR binutils/23199: All sections in a
711 section group should be marked with
712 SHF_GROUP. But some tools generate
713 broken objects without SHF_GROUP. Fix
715 dest
->shdr
->sh_flags
|= SHF_GROUP
;
718 || dest
->shdr
->sh_type
== SHT_GROUP
)
721 (_("%pB: invalid entry in SHT_GROUP section [%u]"),
729 /* PR 17510: Corrupt binaries might contain invalid groups. */
730 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
732 elf_tdata (abfd
)->num_group
= num_group
;
734 /* If all groups are invalid then fail. */
737 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
738 elf_tdata (abfd
)->num_group
= num_group
= -1;
740 (_("%pB: no valid group sections found"), abfd
);
741 bfd_set_error (bfd_error_bad_value
);
747 if (num_group
!= (unsigned) -1)
749 unsigned int search_offset
= elf_tdata (abfd
)->group_search_offset
;
752 for (j
= 0; j
< num_group
; j
++)
754 /* Begin search from previous found group. */
755 unsigned i
= (j
+ search_offset
) % num_group
;
757 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
758 Elf_Internal_Group
*idx
;
764 idx
= (Elf_Internal_Group
*) shdr
->contents
;
765 if (idx
== NULL
|| shdr
->sh_size
< 4)
767 /* See PR 21957 for a reproducer. */
768 /* xgettext:c-format */
769 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
770 abfd
, shdr
->bfd_section
);
771 elf_tdata (abfd
)->group_sect_ptr
[i
] = NULL
;
772 bfd_set_error (bfd_error_bad_value
);
775 n_elt
= shdr
->sh_size
/ 4;
777 /* Look through this group's sections to see if current
778 section is a member. */
780 if ((++idx
)->shdr
== hdr
)
784 /* We are a member of this group. Go looking through
785 other members to see if any others are linked via
787 idx
= (Elf_Internal_Group
*) shdr
->contents
;
788 n_elt
= shdr
->sh_size
/ 4;
790 if ((++idx
)->shdr
!= NULL
791 && (s
= idx
->shdr
->bfd_section
) != NULL
792 && elf_next_in_group (s
) != NULL
)
796 /* Snarf the group name from other member, and
797 insert current section in circular list. */
798 elf_group_name (newsect
) = elf_group_name (s
);
799 elf_next_in_group (newsect
) = elf_next_in_group (s
);
800 elf_next_in_group (s
) = newsect
;
806 gname
= group_signature (abfd
, shdr
);
809 elf_group_name (newsect
) = gname
;
811 /* Start a circular list with one element. */
812 elf_next_in_group (newsect
) = newsect
;
815 /* If the group section has been created, point to the
817 if (shdr
->bfd_section
!= NULL
)
818 elf_next_in_group (shdr
->bfd_section
) = newsect
;
820 elf_tdata (abfd
)->group_search_offset
= i
;
827 if (elf_group_name (newsect
) == NULL
)
829 /* xgettext:c-format */
830 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
838 _bfd_elf_setup_sections (bfd
*abfd
)
841 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
845 /* Process SHF_LINK_ORDER. */
846 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
848 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
849 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
851 unsigned int elfsec
= this_hdr
->sh_link
;
852 /* An sh_link value of 0 is now allowed. It indicates that linked
853 to section has already been discarded, but that the current
854 section has been retained for some other reason. This linking
855 section is still a candidate for later garbage collection
859 elf_linked_to_section (s
) = NULL
;
863 asection
*linksec
= NULL
;
865 if (elfsec
< elf_numsections (abfd
))
867 this_hdr
= elf_elfsections (abfd
)[elfsec
];
868 linksec
= this_hdr
->bfd_section
;
872 Some strip/objcopy may leave an incorrect value in
873 sh_link. We don't want to proceed. */
877 /* xgettext:c-format */
878 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
879 s
->owner
, elfsec
, s
);
883 elf_linked_to_section (s
) = linksec
;
886 else if (this_hdr
->sh_type
== SHT_GROUP
887 && elf_next_in_group (s
) == NULL
)
890 /* xgettext:c-format */
891 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
892 abfd
, elf_section_data (s
)->this_idx
);
897 /* Process section groups. */
898 if (num_group
== (unsigned) -1)
901 for (i
= 0; i
< num_group
; i
++)
903 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
904 Elf_Internal_Group
*idx
;
907 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
908 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
911 /* xgettext:c-format */
912 (_("%pB: section group entry number %u is corrupt"),
918 idx
= (Elf_Internal_Group
*) shdr
->contents
;
919 n_elt
= shdr
->sh_size
/ 4;
925 if (idx
->shdr
== NULL
)
927 else if (idx
->shdr
->bfd_section
)
928 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
929 else if (idx
->shdr
->sh_type
!= SHT_RELA
930 && idx
->shdr
->sh_type
!= SHT_REL
)
932 /* There are some unknown sections in the group. */
934 /* xgettext:c-format */
935 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
938 bfd_elf_string_from_elf_section (abfd
,
939 (elf_elfheader (abfd
)
952 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
954 return elf_next_in_group (sec
) != NULL
;
958 bfd_elf_group_name (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
960 if (elf_sec_group (sec
) != NULL
)
961 return elf_group_name (sec
);
966 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
968 unsigned int len
= strlen (name
);
969 char *new_name
= bfd_alloc (abfd
, len
+ 2);
970 if (new_name
== NULL
)
974 memcpy (new_name
+ 2, name
+ 1, len
);
979 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
981 unsigned int len
= strlen (name
);
982 char *new_name
= bfd_alloc (abfd
, len
);
983 if (new_name
== NULL
)
986 memcpy (new_name
+ 1, name
+ 2, len
- 1);
990 /* This a copy of lto_section defined in GCC (lto-streamer.h). */
994 int16_t major_version
;
995 int16_t minor_version
;
996 unsigned char slim_object
;
998 /* Flags is a private field that is not defined publicly. */
1002 /* Make a BFD section from an ELF section. We store a pointer to the
1003 BFD section in the bfd_section field of the header. */
1006 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
1007 Elf_Internal_Shdr
*hdr
,
1013 const struct elf_backend_data
*bed
;
1014 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
1016 if (hdr
->bfd_section
!= NULL
)
1019 newsect
= bfd_make_section_anyway (abfd
, name
);
1020 if (newsect
== NULL
)
1023 hdr
->bfd_section
= newsect
;
1024 elf_section_data (newsect
)->this_hdr
= *hdr
;
1025 elf_section_data (newsect
)->this_idx
= shindex
;
1027 /* Always use the real type/flags. */
1028 elf_section_type (newsect
) = hdr
->sh_type
;
1029 elf_section_flags (newsect
) = hdr
->sh_flags
;
1031 newsect
->filepos
= hdr
->sh_offset
;
1033 flags
= SEC_NO_FLAGS
;
1034 if (hdr
->sh_type
!= SHT_NOBITS
)
1035 flags
|= SEC_HAS_CONTENTS
;
1036 if (hdr
->sh_type
== SHT_GROUP
)
1038 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1041 if (hdr
->sh_type
!= SHT_NOBITS
)
1044 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
1045 flags
|= SEC_READONLY
;
1046 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1048 else if ((flags
& SEC_LOAD
) != 0)
1050 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
1053 newsect
->entsize
= hdr
->sh_entsize
;
1055 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
1056 flags
|= SEC_STRINGS
;
1057 if (hdr
->sh_flags
& SHF_GROUP
)
1058 if (!setup_group (abfd
, hdr
, newsect
))
1060 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
1061 flags
|= SEC_THREAD_LOCAL
;
1062 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
1063 flags
|= SEC_EXCLUDE
;
1065 switch (elf_elfheader (abfd
)->e_ident
[EI_OSABI
])
1067 /* FIXME: We should not recognize SHF_GNU_MBIND for ELFOSABI_NONE,
1068 but binutils as of 2019-07-23 did not set the EI_OSABI header
1071 case ELFOSABI_FREEBSD
:
1072 if ((hdr
->sh_flags
& SHF_GNU_RETAIN
) != 0)
1073 elf_tdata (abfd
)->has_gnu_osabi
|= elf_gnu_osabi_retain
;
1076 if ((hdr
->sh_flags
& SHF_GNU_MBIND
) != 0)
1077 elf_tdata (abfd
)->has_gnu_osabi
|= elf_gnu_osabi_mbind
;
1081 if ((flags
& SEC_ALLOC
) == 0)
1083 /* The debugging sections appear to be recognized only by name,
1084 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1085 if (name
[0] == '.')
1087 if (startswith (name
, ".debug")
1088 || startswith (name
, ".gnu.debuglto_.debug_")
1089 || startswith (name
, ".gnu.linkonce.wi.")
1090 || startswith (name
, ".zdebug"))
1091 flags
|= SEC_DEBUGGING
| SEC_ELF_OCTETS
;
1092 else if (startswith (name
, GNU_BUILD_ATTRS_SECTION_NAME
)
1093 || startswith (name
, ".note.gnu"))
1095 flags
|= SEC_ELF_OCTETS
;
1098 else if (startswith (name
, ".line")
1099 || startswith (name
, ".stab")
1100 || strcmp (name
, ".gdb_index") == 0)
1101 flags
|= SEC_DEBUGGING
;
1105 if (!bfd_set_section_vma (newsect
, hdr
->sh_addr
/ opb
)
1106 || !bfd_set_section_size (newsect
, hdr
->sh_size
)
1107 || !bfd_set_section_alignment (newsect
, bfd_log2 (hdr
->sh_addralign
)))
1110 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1111 only link a single copy of the section. This is used to support
1112 g++. g++ will emit each template expansion in its own section.
1113 The symbols will be defined as weak, so that multiple definitions
1114 are permitted. The GNU linker extension is to actually discard
1115 all but one of the sections. */
1116 if (startswith (name
, ".gnu.linkonce")
1117 && elf_next_in_group (newsect
) == NULL
)
1118 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1120 if (!bfd_set_section_flags (newsect
, flags
))
1123 bed
= get_elf_backend_data (abfd
);
1124 if (bed
->elf_backend_section_flags
)
1125 if (!bed
->elf_backend_section_flags (hdr
))
1128 /* We do not parse the PT_NOTE segments as we are interested even in the
1129 separate debug info files which may have the segments offsets corrupted.
1130 PT_NOTEs from the core files are currently not parsed using BFD. */
1131 if (hdr
->sh_type
== SHT_NOTE
)
1135 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1138 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1139 hdr
->sh_offset
, hdr
->sh_addralign
);
1143 if ((newsect
->flags
& SEC_ALLOC
) != 0)
1145 Elf_Internal_Phdr
*phdr
;
1146 unsigned int i
, nload
;
1148 /* Some ELF linkers produce binaries with all the program header
1149 p_paddr fields zero. If we have such a binary with more than
1150 one PT_LOAD header, then leave the section lma equal to vma
1151 so that we don't create sections with overlapping lma. */
1152 phdr
= elf_tdata (abfd
)->phdr
;
1153 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1154 if (phdr
->p_paddr
!= 0)
1156 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1158 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1161 phdr
= elf_tdata (abfd
)->phdr
;
1162 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1164 if (((phdr
->p_type
== PT_LOAD
1165 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1166 || phdr
->p_type
== PT_TLS
)
1167 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1169 if ((newsect
->flags
& SEC_LOAD
) == 0)
1170 newsect
->lma
= (phdr
->p_paddr
1171 + hdr
->sh_addr
- phdr
->p_vaddr
) / opb
;
1173 /* We used to use the same adjustment for SEC_LOAD
1174 sections, but that doesn't work if the segment
1175 is packed with code from multiple VMAs.
1176 Instead we calculate the section LMA based on
1177 the segment LMA. It is assumed that the
1178 segment will contain sections with contiguous
1179 LMAs, even if the VMAs are not. */
1180 newsect
->lma
= (phdr
->p_paddr
1181 + hdr
->sh_offset
- phdr
->p_offset
) / opb
;
1183 /* With contiguous segments, we can't tell from file
1184 offsets whether a section with zero size should
1185 be placed at the end of one segment or the
1186 beginning of the next. Decide based on vaddr. */
1187 if (hdr
->sh_addr
>= phdr
->p_vaddr
1188 && (hdr
->sh_addr
+ hdr
->sh_size
1189 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1195 /* Compress/decompress DWARF debug sections with names: .debug_* and
1196 .zdebug_*, after the section flags is set. */
1197 if ((newsect
->flags
& SEC_DEBUGGING
)
1198 && ((name
[1] == 'd' && name
[6] == '_')
1199 || (name
[1] == 'z' && name
[7] == '_')))
1201 enum { nothing
, compress
, decompress
} action
= nothing
;
1202 int compression_header_size
;
1203 bfd_size_type uncompressed_size
;
1204 unsigned int uncompressed_align_power
;
1206 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1207 &compression_header_size
,
1209 &uncompressed_align_power
);
1212 /* Compressed section. Check if we should decompress. */
1213 if ((abfd
->flags
& BFD_DECOMPRESS
))
1214 action
= decompress
;
1217 /* Compress the uncompressed section or convert from/to .zdebug*
1218 section. Check if we should compress. */
1219 if (action
== nothing
)
1221 if (newsect
->size
!= 0
1222 && (abfd
->flags
& BFD_COMPRESS
)
1223 && compression_header_size
>= 0
1224 && uncompressed_size
> 0
1226 || ((compression_header_size
> 0)
1227 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1233 if (action
== compress
)
1235 if (!bfd_init_section_compress_status (abfd
, newsect
))
1238 /* xgettext:c-format */
1239 (_("%pB: unable to initialize compress status for section %s"),
1246 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1249 /* xgettext:c-format */
1250 (_("%pB: unable to initialize decompress status for section %s"),
1256 if (abfd
->is_linker_input
)
1259 && (action
== decompress
1260 || (action
== compress
1261 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1263 /* Convert section name from .zdebug_* to .debug_* so
1264 that linker will consider this section as a debug
1266 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1267 if (new_name
== NULL
)
1269 bfd_rename_section (newsect
, new_name
);
1273 /* For objdump, don't rename the section. For objcopy, delay
1274 section rename to elf_fake_sections. */
1275 newsect
->flags
|= SEC_ELF_RENAME
;
1278 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
1280 if (startswith (name
, ".gnu.lto_.lto."))
1282 struct lto_section lsection
;
1283 if (bfd_get_section_contents (abfd
, newsect
, &lsection
, 0,
1284 sizeof (struct lto_section
)))
1285 abfd
->lto_slim_object
= lsection
.slim_object
;
1291 const char *const bfd_elf_section_type_names
[] =
1293 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1294 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1295 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1298 /* ELF relocs are against symbols. If we are producing relocatable
1299 output, and the reloc is against an external symbol, and nothing
1300 has given us any additional addend, the resulting reloc will also
1301 be against the same symbol. In such a case, we don't want to
1302 change anything about the way the reloc is handled, since it will
1303 all be done at final link time. Rather than put special case code
1304 into bfd_perform_relocation, all the reloc types use this howto
1305 function, or should call this function for relocatable output. */
1307 bfd_reloc_status_type
1308 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1309 arelent
*reloc_entry
,
1311 void *data ATTRIBUTE_UNUSED
,
1312 asection
*input_section
,
1314 char **error_message ATTRIBUTE_UNUSED
)
1316 if (output_bfd
!= NULL
1317 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1318 && (! reloc_entry
->howto
->partial_inplace
1319 || reloc_entry
->addend
== 0))
1321 reloc_entry
->address
+= input_section
->output_offset
;
1322 return bfd_reloc_ok
;
1325 /* In some cases the relocation should be treated as output section
1326 relative, as when linking ELF DWARF into PE COFF. Many ELF
1327 targets lack section relative relocations and instead use
1328 ordinary absolute relocations for references between DWARF
1329 sections. That is arguably a bug in those targets but it happens
1330 to work for the usual case of linking to non-loaded ELF debug
1331 sections with VMAs forced to zero. PE COFF on the other hand
1332 doesn't allow a section VMA of zero. */
1333 if (output_bfd
== NULL
1334 && !reloc_entry
->howto
->pc_relative
1335 && (symbol
->section
->flags
& SEC_DEBUGGING
) != 0
1336 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
1337 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1339 return bfd_reloc_continue
;
1342 /* Returns TRUE if section A matches section B.
1343 Names, addresses and links may be different, but everything else
1344 should be the same. */
1347 section_match (const Elf_Internal_Shdr
* a
,
1348 const Elf_Internal_Shdr
* b
)
1350 if (a
->sh_type
!= b
->sh_type
1351 || ((a
->sh_flags
^ b
->sh_flags
) & ~SHF_INFO_LINK
) != 0
1352 || a
->sh_addralign
!= b
->sh_addralign
1353 || a
->sh_entsize
!= b
->sh_entsize
)
1355 if (a
->sh_type
== SHT_SYMTAB
1356 || a
->sh_type
== SHT_STRTAB
)
1358 return a
->sh_size
== b
->sh_size
;
1361 /* Find a section in OBFD that has the same characteristics
1362 as IHEADER. Return the index of this section or SHN_UNDEF if
1363 none can be found. Check's section HINT first, as this is likely
1364 to be the correct section. */
1367 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1368 const unsigned int hint
)
1370 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1373 BFD_ASSERT (iheader
!= NULL
);
1375 /* See PR 20922 for a reproducer of the NULL test. */
1376 if (hint
< elf_numsections (obfd
)
1377 && oheaders
[hint
] != NULL
1378 && section_match (oheaders
[hint
], iheader
))
1381 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1383 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1385 if (oheader
== NULL
)
1387 if (section_match (oheader
, iheader
))
1388 /* FIXME: Do we care if there is a potential for
1389 multiple matches ? */
1396 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1397 Processor specific section, based upon a matching input section.
1398 Returns TRUE upon success, FALSE otherwise. */
1401 copy_special_section_fields (const bfd
*ibfd
,
1403 const Elf_Internal_Shdr
*iheader
,
1404 Elf_Internal_Shdr
*oheader
,
1405 const unsigned int secnum
)
1407 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1408 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1409 bool changed
= false;
1410 unsigned int sh_link
;
1412 if (oheader
->sh_type
== SHT_NOBITS
)
1414 /* This is a feature for objcopy --only-keep-debug:
1415 When a section's type is changed to NOBITS, we preserve
1416 the sh_link and sh_info fields so that they can be
1417 matched up with the original.
1419 Note: Strictly speaking these assignments are wrong.
1420 The sh_link and sh_info fields should point to the
1421 relevent sections in the output BFD, which may not be in
1422 the same location as they were in the input BFD. But
1423 the whole point of this action is to preserve the
1424 original values of the sh_link and sh_info fields, so
1425 that they can be matched up with the section headers in
1426 the original file. So strictly speaking we may be
1427 creating an invalid ELF file, but it is only for a file
1428 that just contains debug info and only for sections
1429 without any contents. */
1430 if (oheader
->sh_link
== 0)
1431 oheader
->sh_link
= iheader
->sh_link
;
1432 if (oheader
->sh_info
== 0)
1433 oheader
->sh_info
= iheader
->sh_info
;
1437 /* Allow the target a chance to decide how these fields should be set. */
1438 if (bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
,
1442 /* We have an iheader which might match oheader, and which has non-zero
1443 sh_info and/or sh_link fields. Attempt to follow those links and find
1444 the section in the output bfd which corresponds to the linked section
1445 in the input bfd. */
1446 if (iheader
->sh_link
!= SHN_UNDEF
)
1448 /* See PR 20931 for a reproducer. */
1449 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1452 /* xgettext:c-format */
1453 (_("%pB: invalid sh_link field (%d) in section number %d"),
1454 ibfd
, iheader
->sh_link
, secnum
);
1458 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1459 if (sh_link
!= SHN_UNDEF
)
1461 oheader
->sh_link
= sh_link
;
1465 /* FIXME: Should we install iheader->sh_link
1466 if we could not find a match ? */
1468 /* xgettext:c-format */
1469 (_("%pB: failed to find link section for section %d"), obfd
, secnum
);
1472 if (iheader
->sh_info
)
1474 /* The sh_info field can hold arbitrary information, but if the
1475 SHF_LINK_INFO flag is set then it should be interpreted as a
1477 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1479 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1481 if (sh_link
!= SHN_UNDEF
)
1482 oheader
->sh_flags
|= SHF_INFO_LINK
;
1485 /* No idea what it means - just copy it. */
1486 sh_link
= iheader
->sh_info
;
1488 if (sh_link
!= SHN_UNDEF
)
1490 oheader
->sh_info
= sh_link
;
1495 /* xgettext:c-format */
1496 (_("%pB: failed to find info section for section %d"), obfd
, secnum
);
1502 /* Copy the program header and other data from one object module to
1506 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1508 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1509 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1510 const struct elf_backend_data
*bed
;
1513 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1514 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1517 if (!elf_flags_init (obfd
))
1519 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1520 elf_flags_init (obfd
) = true;
1523 elf_gp (obfd
) = elf_gp (ibfd
);
1525 /* Also copy the EI_OSABI field. */
1526 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1527 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1529 /* If set, copy the EI_ABIVERSION field. */
1530 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1531 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1532 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1534 /* Copy object attributes. */
1535 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1537 if (iheaders
== NULL
|| oheaders
== NULL
)
1540 bed
= get_elf_backend_data (obfd
);
1542 /* Possibly copy other fields in the section header. */
1543 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1546 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1548 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1549 because of a special case need for generating separate debug info
1550 files. See below for more details. */
1552 || (oheader
->sh_type
!= SHT_NOBITS
1553 && oheader
->sh_type
< SHT_LOOS
))
1556 /* Ignore empty sections, and sections whose
1557 fields have already been initialised. */
1558 if (oheader
->sh_size
== 0
1559 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1562 /* Scan for the matching section in the input bfd.
1563 First we try for a direct mapping between the input and output sections. */
1564 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1566 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1568 if (iheader
== NULL
)
1571 if (oheader
->bfd_section
!= NULL
1572 && iheader
->bfd_section
!= NULL
1573 && iheader
->bfd_section
->output_section
!= NULL
1574 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1576 /* We have found a connection from the input section to the
1577 output section. Attempt to copy the header fields. If
1578 this fails then do not try any further sections - there
1579 should only be a one-to-one mapping between input and output. */
1580 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1581 j
= elf_numsections (ibfd
);
1586 if (j
< elf_numsections (ibfd
))
1589 /* That failed. So try to deduce the corresponding input section.
1590 Unfortunately we cannot compare names as the output string table
1591 is empty, so instead we check size, address and type. */
1592 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1594 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1596 if (iheader
== NULL
)
1599 /* Try matching fields in the input section's header.
1600 Since --only-keep-debug turns all non-debug sections into
1601 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1603 if ((oheader
->sh_type
== SHT_NOBITS
1604 || iheader
->sh_type
== oheader
->sh_type
)
1605 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1606 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1607 && iheader
->sh_addralign
== oheader
->sh_addralign
1608 && iheader
->sh_entsize
== oheader
->sh_entsize
1609 && iheader
->sh_size
== oheader
->sh_size
1610 && iheader
->sh_addr
== oheader
->sh_addr
1611 && (iheader
->sh_info
!= oheader
->sh_info
1612 || iheader
->sh_link
!= oheader
->sh_link
))
1614 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1619 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1621 /* Final attempt. Call the backend copy function
1622 with a NULL input section. */
1623 (void) bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
,
1632 get_segment_type (unsigned int p_type
)
1637 case PT_NULL
: pt
= "NULL"; break;
1638 case PT_LOAD
: pt
= "LOAD"; break;
1639 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1640 case PT_INTERP
: pt
= "INTERP"; break;
1641 case PT_NOTE
: pt
= "NOTE"; break;
1642 case PT_SHLIB
: pt
= "SHLIB"; break;
1643 case PT_PHDR
: pt
= "PHDR"; break;
1644 case PT_TLS
: pt
= "TLS"; break;
1645 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1646 case PT_GNU_STACK
: pt
= "STACK"; break;
1647 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1648 default: pt
= NULL
; break;
1653 /* Print out the program headers. */
1656 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1658 FILE *f
= (FILE *) farg
;
1659 Elf_Internal_Phdr
*p
;
1661 bfd_byte
*dynbuf
= NULL
;
1663 p
= elf_tdata (abfd
)->phdr
;
1668 fprintf (f
, _("\nProgram Header:\n"));
1669 c
= elf_elfheader (abfd
)->e_phnum
;
1670 for (i
= 0; i
< c
; i
++, p
++)
1672 const char *pt
= get_segment_type (p
->p_type
);
1677 sprintf (buf
, "0x%lx", p
->p_type
);
1680 fprintf (f
, "%8s off 0x", pt
);
1681 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1682 fprintf (f
, " vaddr 0x");
1683 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1684 fprintf (f
, " paddr 0x");
1685 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1686 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1687 fprintf (f
, " filesz 0x");
1688 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1689 fprintf (f
, " memsz 0x");
1690 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1691 fprintf (f
, " flags %c%c%c",
1692 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1693 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1694 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1695 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1696 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1701 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1704 unsigned int elfsec
;
1705 unsigned long shlink
;
1706 bfd_byte
*extdyn
, *extdynend
;
1708 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1710 fprintf (f
, _("\nDynamic Section:\n"));
1712 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1715 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1716 if (elfsec
== SHN_BAD
)
1718 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1720 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1721 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1724 /* PR 17512: file: 6f427532. */
1725 if (s
->size
< extdynsize
)
1727 extdynend
= extdyn
+ s
->size
;
1728 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1730 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1732 Elf_Internal_Dyn dyn
;
1733 const char *name
= "";
1736 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1738 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1740 if (dyn
.d_tag
== DT_NULL
)
1747 if (bed
->elf_backend_get_target_dtag
)
1748 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1750 if (!strcmp (name
, ""))
1752 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1757 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
1758 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1759 case DT_PLTGOT
: name
= "PLTGOT"; break;
1760 case DT_HASH
: name
= "HASH"; break;
1761 case DT_STRTAB
: name
= "STRTAB"; break;
1762 case DT_SYMTAB
: name
= "SYMTAB"; break;
1763 case DT_RELA
: name
= "RELA"; break;
1764 case DT_RELASZ
: name
= "RELASZ"; break;
1765 case DT_RELAENT
: name
= "RELAENT"; break;
1766 case DT_STRSZ
: name
= "STRSZ"; break;
1767 case DT_SYMENT
: name
= "SYMENT"; break;
1768 case DT_INIT
: name
= "INIT"; break;
1769 case DT_FINI
: name
= "FINI"; break;
1770 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
1771 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
1772 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1773 case DT_REL
: name
= "REL"; break;
1774 case DT_RELSZ
: name
= "RELSZ"; break;
1775 case DT_RELENT
: name
= "RELENT"; break;
1776 case DT_RELR
: name
= "RELR"; break;
1777 case DT_RELRSZ
: name
= "RELRSZ"; break;
1778 case DT_RELRENT
: name
= "RELRENT"; break;
1779 case DT_PLTREL
: name
= "PLTREL"; break;
1780 case DT_DEBUG
: name
= "DEBUG"; break;
1781 case DT_TEXTREL
: name
= "TEXTREL"; break;
1782 case DT_JMPREL
: name
= "JMPREL"; break;
1783 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1784 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1785 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1786 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1787 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1788 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= true; break;
1789 case DT_FLAGS
: name
= "FLAGS"; break;
1790 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1791 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1792 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1793 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1794 case DT_MOVEENT
: name
= "MOVEENT"; break;
1795 case DT_MOVESZ
: name
= "MOVESZ"; break;
1796 case DT_FEATURE
: name
= "FEATURE"; break;
1797 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1798 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1799 case DT_SYMINENT
: name
= "SYMINENT"; break;
1800 case DT_CONFIG
: name
= "CONFIG"; stringp
= true; break;
1801 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= true; break;
1802 case DT_AUDIT
: name
= "AUDIT"; stringp
= true; break;
1803 case DT_PLTPAD
: name
= "PLTPAD"; break;
1804 case DT_MOVETAB
: name
= "MOVETAB"; break;
1805 case DT_SYMINFO
: name
= "SYMINFO"; break;
1806 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1807 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1808 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1809 case DT_VERSYM
: name
= "VERSYM"; break;
1810 case DT_VERDEF
: name
= "VERDEF"; break;
1811 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1812 case DT_VERNEED
: name
= "VERNEED"; break;
1813 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1814 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
1815 case DT_USED
: name
= "USED"; break;
1816 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
1817 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1820 fprintf (f
, " %-20s ", name
);
1824 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1829 unsigned int tagv
= dyn
.d_un
.d_val
;
1831 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1834 fprintf (f
, "%s", string
);
1843 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1844 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1846 if (! _bfd_elf_slurp_version_tables (abfd
, false))
1850 if (elf_dynverdef (abfd
) != 0)
1852 Elf_Internal_Verdef
*t
;
1854 fprintf (f
, _("\nVersion definitions:\n"));
1855 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1857 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1858 t
->vd_flags
, t
->vd_hash
,
1859 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1860 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1862 Elf_Internal_Verdaux
*a
;
1865 for (a
= t
->vd_auxptr
->vda_nextptr
;
1869 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1875 if (elf_dynverref (abfd
) != 0)
1877 Elf_Internal_Verneed
*t
;
1879 fprintf (f
, _("\nVersion References:\n"));
1880 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1882 Elf_Internal_Vernaux
*a
;
1884 fprintf (f
, _(" required from %s:\n"),
1885 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1886 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1887 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1888 a
->vna_flags
, a
->vna_other
,
1889 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1900 /* Get version name. If BASE_P is TRUE, return "Base" for VER_FLG_BASE
1901 and return symbol version for symbol version itself. */
1904 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1908 const char *version_string
= NULL
;
1909 if (elf_dynversym (abfd
) != 0
1910 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1912 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1914 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1915 vernum
&= VERSYM_VERSION
;
1918 version_string
= "";
1919 else if (vernum
== 1
1920 && (vernum
> elf_tdata (abfd
)->cverdefs
1921 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1923 version_string
= base_p
? "Base" : "";
1924 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1926 const char *nodename
1927 = elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1928 version_string
= "";
1931 || symbol
->name
== NULL
1932 || strcmp (symbol
->name
, nodename
) != 0)
1933 version_string
= nodename
;
1937 Elf_Internal_Verneed
*t
;
1939 version_string
= _("<corrupt>");
1940 for (t
= elf_tdata (abfd
)->verref
;
1944 Elf_Internal_Vernaux
*a
;
1946 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1948 if (a
->vna_other
== vernum
)
1951 version_string
= a
->vna_nodename
;
1958 return version_string
;
1961 /* Display ELF-specific fields of a symbol. */
1964 bfd_elf_print_symbol (bfd
*abfd
,
1967 bfd_print_symbol_type how
)
1969 FILE *file
= (FILE *) filep
;
1972 case bfd_print_symbol_name
:
1973 fprintf (file
, "%s", symbol
->name
);
1975 case bfd_print_symbol_more
:
1976 fprintf (file
, "elf ");
1977 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1978 fprintf (file
, " %x", symbol
->flags
);
1980 case bfd_print_symbol_all
:
1982 const char *section_name
;
1983 const char *name
= NULL
;
1984 const struct elf_backend_data
*bed
;
1985 unsigned char st_other
;
1987 const char *version_string
;
1990 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1992 bed
= get_elf_backend_data (abfd
);
1993 if (bed
->elf_backend_print_symbol_all
)
1994 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1998 name
= symbol
->name
;
1999 bfd_print_symbol_vandf (abfd
, file
, symbol
);
2002 fprintf (file
, " %s\t", section_name
);
2003 /* Print the "other" value for a symbol. For common symbols,
2004 we've already printed the size; now print the alignment.
2005 For other symbols, we have no specified alignment, and
2006 we've printed the address; now print the size. */
2007 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
2008 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
2010 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
2011 bfd_fprintf_vma (abfd
, file
, val
);
2013 /* If we have version information, print it. */
2014 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
2021 fprintf (file
, " %-11s", version_string
);
2026 fprintf (file
, " (%s)", version_string
);
2027 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
2032 /* If the st_other field is not zero, print it. */
2033 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
2038 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
2039 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
2040 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
2042 /* Some other non-defined flags are also present, so print
2044 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
2047 fprintf (file
, " %s", name
);
2053 /* ELF .o/exec file reading */
2055 /* Create a new bfd section from an ELF section header. */
2058 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2060 Elf_Internal_Shdr
*hdr
;
2061 Elf_Internal_Ehdr
*ehdr
;
2062 const struct elf_backend_data
*bed
;
2066 if (shindex
>= elf_numsections (abfd
))
2069 /* PR17512: A corrupt ELF binary might contain a loop of sections via
2070 sh_link or sh_info. Detect this here, by refusing to load a
2071 section that we are already in the process of loading. */
2072 if (elf_tdata (abfd
)->being_created
[shindex
])
2075 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2078 elf_tdata (abfd
)->being_created
[shindex
] = true;
2080 hdr
= elf_elfsections (abfd
)[shindex
];
2081 ehdr
= elf_elfheader (abfd
);
2082 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2087 bed
= get_elf_backend_data (abfd
);
2088 switch (hdr
->sh_type
)
2091 /* Inactive section. Throw it away. */
2094 case SHT_PROGBITS
: /* Normal section with contents. */
2095 case SHT_NOBITS
: /* .bss section. */
2096 case SHT_HASH
: /* .hash section. */
2097 case SHT_NOTE
: /* .note section. */
2098 case SHT_INIT_ARRAY
: /* .init_array section. */
2099 case SHT_FINI_ARRAY
: /* .fini_array section. */
2100 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2101 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2102 case SHT_GNU_HASH
: /* .gnu.hash section. */
2103 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2106 case SHT_DYNAMIC
: /* Dynamic linking information. */
2107 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2110 if (hdr
->sh_link
> elf_numsections (abfd
))
2112 /* PR 10478: Accept Solaris binaries with a sh_link
2113 field set to SHN_BEFORE or SHN_AFTER. */
2114 switch (bfd_get_arch (abfd
))
2117 case bfd_arch_sparc
:
2118 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2119 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2121 /* Otherwise fall through. */
2126 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2128 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2130 Elf_Internal_Shdr
*dynsymhdr
;
2132 /* The shared libraries distributed with hpux11 have a bogus
2133 sh_link field for the ".dynamic" section. Find the
2134 string table for the ".dynsym" section instead. */
2135 if (elf_dynsymtab (abfd
) != 0)
2137 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2138 hdr
->sh_link
= dynsymhdr
->sh_link
;
2142 unsigned int i
, num_sec
;
2144 num_sec
= elf_numsections (abfd
);
2145 for (i
= 1; i
< num_sec
; i
++)
2147 dynsymhdr
= elf_elfsections (abfd
)[i
];
2148 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2150 hdr
->sh_link
= dynsymhdr
->sh_link
;
2158 case SHT_SYMTAB
: /* A symbol table. */
2159 if (elf_onesymtab (abfd
) == shindex
)
2162 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2165 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2167 if (hdr
->sh_size
!= 0)
2169 /* Some assemblers erroneously set sh_info to one with a
2170 zero sh_size. ld sees this as a global symbol count
2171 of (unsigned) -1. Fix it here. */
2176 /* PR 18854: A binary might contain more than one symbol table.
2177 Unusual, but possible. Warn, but continue. */
2178 if (elf_onesymtab (abfd
) != 0)
2181 /* xgettext:c-format */
2182 (_("%pB: warning: multiple symbol tables detected"
2183 " - ignoring the table in section %u"),
2187 elf_onesymtab (abfd
) = shindex
;
2188 elf_symtab_hdr (abfd
) = *hdr
;
2189 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2190 abfd
->flags
|= HAS_SYMS
;
2192 /* Sometimes a shared object will map in the symbol table. If
2193 SHF_ALLOC is set, and this is a shared object, then we also
2194 treat this section as a BFD section. We can not base the
2195 decision purely on SHF_ALLOC, because that flag is sometimes
2196 set in a relocatable object file, which would confuse the
2198 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2199 && (abfd
->flags
& DYNAMIC
) != 0
2200 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2204 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2205 can't read symbols without that section loaded as well. It
2206 is most likely specified by the next section header. */
2208 elf_section_list
* entry
;
2209 unsigned int i
, num_sec
;
2211 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2212 if (entry
->hdr
.sh_link
== shindex
)
2215 num_sec
= elf_numsections (abfd
);
2216 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2218 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2220 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2221 && hdr2
->sh_link
== shindex
)
2226 for (i
= 1; i
< shindex
; i
++)
2228 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2230 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2231 && hdr2
->sh_link
== shindex
)
2236 ret
= bfd_section_from_shdr (abfd
, i
);
2237 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2241 case SHT_DYNSYM
: /* A dynamic symbol table. */
2242 if (elf_dynsymtab (abfd
) == shindex
)
2245 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2248 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2250 if (hdr
->sh_size
!= 0)
2253 /* Some linkers erroneously set sh_info to one with a
2254 zero sh_size. ld sees this as a global symbol count
2255 of (unsigned) -1. Fix it here. */
2260 /* PR 18854: A binary might contain more than one dynamic symbol table.
2261 Unusual, but possible. Warn, but continue. */
2262 if (elf_dynsymtab (abfd
) != 0)
2265 /* xgettext:c-format */
2266 (_("%pB: warning: multiple dynamic symbol tables detected"
2267 " - ignoring the table in section %u"),
2271 elf_dynsymtab (abfd
) = shindex
;
2272 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2273 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2274 abfd
->flags
|= HAS_SYMS
;
2276 /* Besides being a symbol table, we also treat this as a regular
2277 section, so that objcopy can handle it. */
2278 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2281 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2283 elf_section_list
* entry
;
2285 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2286 if (entry
->ndx
== shindex
)
2289 entry
= bfd_alloc (abfd
, sizeof (*entry
));
2292 entry
->ndx
= shindex
;
2294 entry
->next
= elf_symtab_shndx_list (abfd
);
2295 elf_symtab_shndx_list (abfd
) = entry
;
2296 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2300 case SHT_STRTAB
: /* A string table. */
2301 if (hdr
->bfd_section
!= NULL
)
2304 if (ehdr
->e_shstrndx
== shindex
)
2306 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2307 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2311 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2314 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2315 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2319 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2322 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2323 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2324 elf_elfsections (abfd
)[shindex
] = hdr
;
2325 /* We also treat this as a regular section, so that objcopy
2327 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2332 /* If the string table isn't one of the above, then treat it as a
2333 regular section. We need to scan all the headers to be sure,
2334 just in case this strtab section appeared before the above. */
2335 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2337 unsigned int i
, num_sec
;
2339 num_sec
= elf_numsections (abfd
);
2340 for (i
= 1; i
< num_sec
; i
++)
2342 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2343 if (hdr2
->sh_link
== shindex
)
2345 /* Prevent endless recursion on broken objects. */
2348 if (! bfd_section_from_shdr (abfd
, i
))
2350 if (elf_onesymtab (abfd
) == i
)
2352 if (elf_dynsymtab (abfd
) == i
)
2353 goto dynsymtab_strtab
;
2357 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2363 /* *These* do a lot of work -- but build no sections! */
2365 asection
*target_sect
;
2366 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2367 unsigned int num_sec
= elf_numsections (abfd
);
2368 struct bfd_elf_section_data
*esdt
;
2371 if (hdr
->sh_type
== SHT_REL
)
2372 size
= bed
->s
->sizeof_rel
;
2373 else if (hdr
->sh_type
== SHT_RELA
)
2374 size
= bed
->s
->sizeof_rela
;
2376 size
= bed
->s
->arch_size
/ 8;
2377 if (hdr
->sh_entsize
!= size
)
2380 /* Check for a bogus link to avoid crashing. */
2381 if (hdr
->sh_link
>= num_sec
)
2384 /* xgettext:c-format */
2385 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2386 abfd
, hdr
->sh_link
, name
, shindex
);
2387 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2392 /* Get the symbol table. */
2393 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2394 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2395 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2398 /* If this is an alloc section in an executable or shared
2399 library, or the reloc section does not use the main symbol
2400 table we don't treat it as a reloc section. BFD can't
2401 adequately represent such a section, so at least for now,
2402 we don't try. We just present it as a normal section. We
2403 also can't use it as a reloc section if it points to the
2404 null section, an invalid section, another reloc section, or
2405 its sh_link points to the null section. */
2406 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2407 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2408 || hdr
->sh_link
== SHN_UNDEF
2409 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2410 || hdr
->sh_info
== SHN_UNDEF
2411 || hdr
->sh_info
>= num_sec
2412 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2413 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2415 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2420 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2423 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2424 if (target_sect
== NULL
)
2427 esdt
= elf_section_data (target_sect
);
2428 if (hdr
->sh_type
== SHT_RELA
)
2429 p_hdr
= &esdt
->rela
.hdr
;
2431 p_hdr
= &esdt
->rel
.hdr
;
2433 /* PR 17512: file: 0b4f81b7.
2434 Also see PR 24456, for a file which deliberately has two reloc
2438 if (!bed
->init_secondary_reloc_section (abfd
, hdr
, name
, shindex
))
2441 /* xgettext:c-format */
2442 (_("%pB: warning: secondary relocation section '%s' "
2443 "for section %pA found - ignoring"),
2444 abfd
, name
, target_sect
);
2447 esdt
->has_secondary_relocs
= true;
2451 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2456 elf_elfsections (abfd
)[shindex
] = hdr2
;
2457 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2458 * bed
->s
->int_rels_per_ext_rel
);
2459 target_sect
->flags
|= SEC_RELOC
;
2460 target_sect
->relocation
= NULL
;
2461 target_sect
->rel_filepos
= hdr
->sh_offset
;
2462 /* In the section to which the relocations apply, mark whether
2463 its relocations are of the REL or RELA variety. */
2464 if (hdr
->sh_size
!= 0)
2466 if (hdr
->sh_type
== SHT_RELA
)
2467 target_sect
->use_rela_p
= 1;
2469 abfd
->flags
|= HAS_RELOC
;
2473 case SHT_GNU_verdef
:
2474 elf_dynverdef (abfd
) = shindex
;
2475 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2476 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2479 case SHT_GNU_versym
:
2480 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2483 elf_dynversym (abfd
) = shindex
;
2484 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2485 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2488 case SHT_GNU_verneed
:
2489 elf_dynverref (abfd
) = shindex
;
2490 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2491 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2498 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2501 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2507 /* Possibly an attributes section. */
2508 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2509 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2511 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2513 _bfd_elf_parse_attributes (abfd
, hdr
);
2517 /* Check for any processor-specific section types. */
2518 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2521 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2523 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2524 /* FIXME: How to properly handle allocated section reserved
2525 for applications? */
2527 /* xgettext:c-format */
2528 (_("%pB: unknown type [%#x] section `%s'"),
2529 abfd
, hdr
->sh_type
, name
);
2532 /* Allow sections reserved for applications. */
2533 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2538 else if (hdr
->sh_type
>= SHT_LOPROC
2539 && hdr
->sh_type
<= SHT_HIPROC
)
2540 /* FIXME: We should handle this section. */
2542 /* xgettext:c-format */
2543 (_("%pB: unknown type [%#x] section `%s'"),
2544 abfd
, hdr
->sh_type
, name
);
2545 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2547 /* Unrecognised OS-specific sections. */
2548 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2549 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2550 required to correctly process the section and the file should
2551 be rejected with an error message. */
2553 /* xgettext:c-format */
2554 (_("%pB: unknown type [%#x] section `%s'"),
2555 abfd
, hdr
->sh_type
, name
);
2558 /* Otherwise it should be processed. */
2559 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2564 /* FIXME: We should handle this section. */
2566 /* xgettext:c-format */
2567 (_("%pB: unknown type [%#x] section `%s'"),
2568 abfd
, hdr
->sh_type
, name
);
2576 elf_tdata (abfd
)->being_created
[shindex
] = false;
2580 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2583 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2585 unsigned long r_symndx
)
2587 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2589 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2591 Elf_Internal_Shdr
*symtab_hdr
;
2592 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2593 Elf_External_Sym_Shndx eshndx
;
2595 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2596 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2597 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2600 if (cache
->abfd
!= abfd
)
2602 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2605 cache
->indx
[ent
] = r_symndx
;
2608 return &cache
->sym
[ent
];
2611 /* Given an ELF section number, retrieve the corresponding BFD
2615 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2617 if (sec_index
>= elf_numsections (abfd
))
2619 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2622 static const struct bfd_elf_special_section special_sections_b
[] =
2624 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2625 { NULL
, 0, 0, 0, 0 }
2628 static const struct bfd_elf_special_section special_sections_c
[] =
2630 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2631 { STRING_COMMA_LEN (".ctf"), 0, SHT_PROGBITS
, 0 },
2632 { NULL
, 0, 0, 0, 0 }
2635 static const struct bfd_elf_special_section special_sections_d
[] =
2637 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2638 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2639 /* There are more DWARF sections than these, but they needn't be added here
2640 unless you have to cope with broken compilers that don't emit section
2641 attributes or you want to help the user writing assembler. */
2642 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2643 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2644 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2645 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2646 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2647 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2648 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2649 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2650 { NULL
, 0, 0, 0, 0 }
2653 static const struct bfd_elf_special_section special_sections_f
[] =
2655 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2656 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2657 { NULL
, 0 , 0, 0, 0 }
2660 static const struct bfd_elf_special_section special_sections_g
[] =
2662 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2663 { STRING_COMMA_LEN (".gnu.linkonce.n"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2664 { STRING_COMMA_LEN (".gnu.linkonce.p"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2665 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2666 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2667 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2668 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2669 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2670 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2671 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2672 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2673 { NULL
, 0, 0, 0, 0 }
2676 static const struct bfd_elf_special_section special_sections_h
[] =
2678 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2679 { NULL
, 0, 0, 0, 0 }
2682 static const struct bfd_elf_special_section special_sections_i
[] =
2684 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2685 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2686 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2687 { NULL
, 0, 0, 0, 0 }
2690 static const struct bfd_elf_special_section special_sections_l
[] =
2692 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2693 { NULL
, 0, 0, 0, 0 }
2696 static const struct bfd_elf_special_section special_sections_n
[] =
2698 { STRING_COMMA_LEN (".noinit"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2699 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2700 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2701 { NULL
, 0, 0, 0, 0 }
2704 static const struct bfd_elf_special_section special_sections_p
[] =
2706 { STRING_COMMA_LEN (".persistent.bss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2707 { STRING_COMMA_LEN (".persistent"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2708 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2709 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2710 { NULL
, 0, 0, 0, 0 }
2713 static const struct bfd_elf_special_section special_sections_r
[] =
2715 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2716 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2717 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2718 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2719 { NULL
, 0, 0, 0, 0 }
2722 static const struct bfd_elf_special_section special_sections_s
[] =
2724 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2725 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2726 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2727 /* See struct bfd_elf_special_section declaration for the semantics of
2728 this special case where .prefix_length != strlen (.prefix). */
2729 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2730 { NULL
, 0, 0, 0, 0 }
2733 static const struct bfd_elf_special_section special_sections_t
[] =
2735 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2736 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2737 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2738 { NULL
, 0, 0, 0, 0 }
2741 static const struct bfd_elf_special_section special_sections_z
[] =
2743 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2744 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2745 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2746 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2747 { NULL
, 0, 0, 0, 0 }
2750 static const struct bfd_elf_special_section
* const special_sections
[] =
2752 special_sections_b
, /* 'b' */
2753 special_sections_c
, /* 'c' */
2754 special_sections_d
, /* 'd' */
2756 special_sections_f
, /* 'f' */
2757 special_sections_g
, /* 'g' */
2758 special_sections_h
, /* 'h' */
2759 special_sections_i
, /* 'i' */
2762 special_sections_l
, /* 'l' */
2764 special_sections_n
, /* 'n' */
2766 special_sections_p
, /* 'p' */
2768 special_sections_r
, /* 'r' */
2769 special_sections_s
, /* 's' */
2770 special_sections_t
, /* 't' */
2776 special_sections_z
/* 'z' */
2779 const struct bfd_elf_special_section
*
2780 _bfd_elf_get_special_section (const char *name
,
2781 const struct bfd_elf_special_section
*spec
,
2787 len
= strlen (name
);
2789 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2792 int prefix_len
= spec
[i
].prefix_length
;
2794 if (len
< prefix_len
)
2796 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2799 suffix_len
= spec
[i
].suffix_length
;
2800 if (suffix_len
<= 0)
2802 if (name
[prefix_len
] != 0)
2804 if (suffix_len
== 0)
2806 if (name
[prefix_len
] != '.'
2807 && (suffix_len
== -2
2808 || (rela
&& spec
[i
].type
== SHT_REL
)))
2814 if (len
< prefix_len
+ suffix_len
)
2816 if (memcmp (name
+ len
- suffix_len
,
2817 spec
[i
].prefix
+ prefix_len
,
2827 const struct bfd_elf_special_section
*
2828 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2831 const struct bfd_elf_special_section
*spec
;
2832 const struct elf_backend_data
*bed
;
2834 /* See if this is one of the special sections. */
2835 if (sec
->name
== NULL
)
2838 bed
= get_elf_backend_data (abfd
);
2839 spec
= bed
->special_sections
;
2842 spec
= _bfd_elf_get_special_section (sec
->name
,
2843 bed
->special_sections
,
2849 if (sec
->name
[0] != '.')
2852 i
= sec
->name
[1] - 'b';
2853 if (i
< 0 || i
> 'z' - 'b')
2856 spec
= special_sections
[i
];
2861 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2865 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2867 struct bfd_elf_section_data
*sdata
;
2868 const struct elf_backend_data
*bed
;
2869 const struct bfd_elf_special_section
*ssect
;
2871 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2874 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2878 sec
->used_by_bfd
= sdata
;
2881 /* Indicate whether or not this section should use RELA relocations. */
2882 bed
= get_elf_backend_data (abfd
);
2883 sec
->use_rela_p
= bed
->default_use_rela_p
;
2885 /* Set up ELF section type and flags for newly created sections, if
2886 there is an ABI mandated section. */
2887 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2890 elf_section_type (sec
) = ssect
->type
;
2891 elf_section_flags (sec
) = ssect
->attr
;
2894 return _bfd_generic_new_section_hook (abfd
, sec
);
2897 /* Create a new bfd section from an ELF program header.
2899 Since program segments have no names, we generate a synthetic name
2900 of the form segment<NUM>, where NUM is generally the index in the
2901 program header table. For segments that are split (see below) we
2902 generate the names segment<NUM>a and segment<NUM>b.
2904 Note that some program segments may have a file size that is different than
2905 (less than) the memory size. All this means is that at execution the
2906 system must allocate the amount of memory specified by the memory size,
2907 but only initialize it with the first "file size" bytes read from the
2908 file. This would occur for example, with program segments consisting
2909 of combined data+bss.
2911 To handle the above situation, this routine generates TWO bfd sections
2912 for the single program segment. The first has the length specified by
2913 the file size of the segment, and the second has the length specified
2914 by the difference between the two sizes. In effect, the segment is split
2915 into its initialized and uninitialized parts.
2920 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2921 Elf_Internal_Phdr
*hdr
,
2923 const char *type_name
)
2930 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
2932 split
= ((hdr
->p_memsz
> 0)
2933 && (hdr
->p_filesz
> 0)
2934 && (hdr
->p_memsz
> hdr
->p_filesz
));
2936 if (hdr
->p_filesz
> 0)
2938 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2939 len
= strlen (namebuf
) + 1;
2940 name
= (char *) bfd_alloc (abfd
, len
);
2943 memcpy (name
, namebuf
, len
);
2944 newsect
= bfd_make_section (abfd
, name
);
2945 if (newsect
== NULL
)
2947 newsect
->vma
= hdr
->p_vaddr
/ opb
;
2948 newsect
->lma
= hdr
->p_paddr
/ opb
;
2949 newsect
->size
= hdr
->p_filesz
;
2950 newsect
->filepos
= hdr
->p_offset
;
2951 newsect
->flags
|= SEC_HAS_CONTENTS
;
2952 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2953 if (hdr
->p_type
== PT_LOAD
)
2955 newsect
->flags
|= SEC_ALLOC
;
2956 newsect
->flags
|= SEC_LOAD
;
2957 if (hdr
->p_flags
& PF_X
)
2959 /* FIXME: all we known is that it has execute PERMISSION,
2961 newsect
->flags
|= SEC_CODE
;
2964 if (!(hdr
->p_flags
& PF_W
))
2966 newsect
->flags
|= SEC_READONLY
;
2970 if (hdr
->p_memsz
> hdr
->p_filesz
)
2974 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2975 len
= strlen (namebuf
) + 1;
2976 name
= (char *) bfd_alloc (abfd
, len
);
2979 memcpy (name
, namebuf
, len
);
2980 newsect
= bfd_make_section (abfd
, name
);
2981 if (newsect
== NULL
)
2983 newsect
->vma
= (hdr
->p_vaddr
+ hdr
->p_filesz
) / opb
;
2984 newsect
->lma
= (hdr
->p_paddr
+ hdr
->p_filesz
) / opb
;
2985 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2986 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2987 align
= newsect
->vma
& -newsect
->vma
;
2988 if (align
== 0 || align
> hdr
->p_align
)
2989 align
= hdr
->p_align
;
2990 newsect
->alignment_power
= bfd_log2 (align
);
2991 if (hdr
->p_type
== PT_LOAD
)
2993 newsect
->flags
|= SEC_ALLOC
;
2994 if (hdr
->p_flags
& PF_X
)
2995 newsect
->flags
|= SEC_CODE
;
2997 if (!(hdr
->p_flags
& PF_W
))
2998 newsect
->flags
|= SEC_READONLY
;
3005 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3007 /* The return value is ignored. Build-ids are considered optional. */
3008 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3009 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3015 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3017 const struct elf_backend_data
*bed
;
3019 switch (hdr
->p_type
)
3022 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3025 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3027 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3028 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3032 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3035 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3038 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3040 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3046 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3049 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3051 case PT_GNU_EH_FRAME
:
3052 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3056 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3059 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3062 /* Check for any processor-specific program segment types. */
3063 bed
= get_elf_backend_data (abfd
);
3064 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3068 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3072 _bfd_elf_single_rel_hdr (asection
*sec
)
3074 if (elf_section_data (sec
)->rel
.hdr
)
3076 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3077 return elf_section_data (sec
)->rel
.hdr
;
3080 return elf_section_data (sec
)->rela
.hdr
;
3084 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3085 Elf_Internal_Shdr
*rel_hdr
,
3086 const char *sec_name
,
3089 char *name
= (char *) bfd_alloc (abfd
,
3090 sizeof ".rela" + strlen (sec_name
));
3094 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3096 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3098 if (rel_hdr
->sh_name
== (unsigned int) -1)
3104 /* Allocate and initialize a section-header for a new reloc section,
3105 containing relocations against ASECT. It is stored in RELDATA. If
3106 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3110 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3111 struct bfd_elf_section_reloc_data
*reldata
,
3112 const char *sec_name
,
3114 bool delay_st_name_p
)
3116 Elf_Internal_Shdr
*rel_hdr
;
3117 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3119 BFD_ASSERT (reldata
->hdr
== NULL
);
3120 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3121 reldata
->hdr
= rel_hdr
;
3123 if (delay_st_name_p
)
3124 rel_hdr
->sh_name
= (unsigned int) -1;
3125 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3128 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3129 rel_hdr
->sh_entsize
= (use_rela_p
3130 ? bed
->s
->sizeof_rela
3131 : bed
->s
->sizeof_rel
);
3132 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3133 rel_hdr
->sh_flags
= 0;
3134 rel_hdr
->sh_addr
= 0;
3135 rel_hdr
->sh_size
= 0;
3136 rel_hdr
->sh_offset
= 0;
3141 /* Return the default section type based on the passed in section flags. */
3144 bfd_elf_get_default_section_type (flagword flags
)
3146 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3147 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3149 return SHT_PROGBITS
;
3152 struct fake_section_arg
3154 struct bfd_link_info
*link_info
;
3158 /* Set up an ELF internal section header for a section. */
3161 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3163 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3164 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3165 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3166 Elf_Internal_Shdr
*this_hdr
;
3167 unsigned int sh_type
;
3168 const char *name
= asect
->name
;
3169 bool delay_st_name_p
= false;
3174 /* We already failed; just get out of the bfd_map_over_sections
3179 this_hdr
= &esd
->this_hdr
;
3183 /* ld: compress DWARF debug sections with names: .debug_*. */
3184 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3185 && (asect
->flags
& SEC_DEBUGGING
)
3189 /* Set SEC_ELF_COMPRESS to indicate this section should be
3191 asect
->flags
|= SEC_ELF_COMPRESS
;
3192 /* If this section will be compressed, delay adding section
3193 name to section name section after it is compressed in
3194 _bfd_elf_assign_file_positions_for_non_load. */
3195 delay_st_name_p
= true;
3198 else if ((asect
->flags
& SEC_ELF_RENAME
))
3200 /* objcopy: rename output DWARF debug section. */
3201 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3203 /* When we decompress or compress with SHF_COMPRESSED,
3204 convert section name from .zdebug_* to .debug_* if
3208 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3209 if (new_name
== NULL
)
3217 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3219 /* PR binutils/18087: Compression does not always make a
3220 section smaller. So only rename the section when
3221 compression has actually taken place. If input section
3222 name is .zdebug_*, we should never compress it again. */
3223 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3224 if (new_name
== NULL
)
3229 BFD_ASSERT (name
[1] != 'z');
3234 if (delay_st_name_p
)
3235 this_hdr
->sh_name
= (unsigned int) -1;
3239 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3241 if (this_hdr
->sh_name
== (unsigned int) -1)
3248 /* Don't clear sh_flags. Assembler may set additional bits. */
3250 if ((asect
->flags
& SEC_ALLOC
) != 0
3251 || asect
->user_set_vma
)
3252 this_hdr
->sh_addr
= asect
->vma
* bfd_octets_per_byte (abfd
, asect
);
3254 this_hdr
->sh_addr
= 0;
3256 this_hdr
->sh_offset
= 0;
3257 this_hdr
->sh_size
= asect
->size
;
3258 this_hdr
->sh_link
= 0;
3259 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3260 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3263 /* xgettext:c-format */
3264 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3265 abfd
, asect
->alignment_power
, asect
);
3269 /* Set sh_addralign to the highest power of two given by alignment
3270 consistent with the section VMA. Linker scripts can force VMA. */
3271 mask
= ((bfd_vma
) 1 << asect
->alignment_power
) | this_hdr
->sh_addr
;
3272 this_hdr
->sh_addralign
= mask
& -mask
;
3273 /* The sh_entsize and sh_info fields may have been set already by
3274 copy_private_section_data. */
3276 this_hdr
->bfd_section
= asect
;
3277 this_hdr
->contents
= NULL
;
3279 /* If the section type is unspecified, we set it based on
3281 if ((asect
->flags
& SEC_GROUP
) != 0)
3282 sh_type
= SHT_GROUP
;
3284 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3286 if (this_hdr
->sh_type
== SHT_NULL
)
3287 this_hdr
->sh_type
= sh_type
;
3288 else if (this_hdr
->sh_type
== SHT_NOBITS
3289 && sh_type
== SHT_PROGBITS
3290 && (asect
->flags
& SEC_ALLOC
) != 0)
3292 /* Warn if we are changing a NOBITS section to PROGBITS, but
3293 allow the link to proceed. This can happen when users link
3294 non-bss input sections to bss output sections, or emit data
3295 to a bss output section via a linker script. */
3297 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3298 this_hdr
->sh_type
= sh_type
;
3301 switch (this_hdr
->sh_type
)
3312 case SHT_INIT_ARRAY
:
3313 case SHT_FINI_ARRAY
:
3314 case SHT_PREINIT_ARRAY
:
3315 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3319 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3323 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3327 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3331 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3332 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3336 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3337 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3340 case SHT_GNU_versym
:
3341 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3344 case SHT_GNU_verdef
:
3345 this_hdr
->sh_entsize
= 0;
3346 /* objcopy or strip will copy over sh_info, but may not set
3347 cverdefs. The linker will set cverdefs, but sh_info will be
3349 if (this_hdr
->sh_info
== 0)
3350 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3352 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3353 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3356 case SHT_GNU_verneed
:
3357 this_hdr
->sh_entsize
= 0;
3358 /* objcopy or strip will copy over sh_info, but may not set
3359 cverrefs. The linker will set cverrefs, but sh_info will be
3361 if (this_hdr
->sh_info
== 0)
3362 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3364 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3365 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3369 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3373 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3377 if ((asect
->flags
& SEC_ALLOC
) != 0)
3378 this_hdr
->sh_flags
|= SHF_ALLOC
;
3379 if ((asect
->flags
& SEC_READONLY
) == 0)
3380 this_hdr
->sh_flags
|= SHF_WRITE
;
3381 if ((asect
->flags
& SEC_CODE
) != 0)
3382 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3383 if ((asect
->flags
& SEC_MERGE
) != 0)
3385 this_hdr
->sh_flags
|= SHF_MERGE
;
3386 this_hdr
->sh_entsize
= asect
->entsize
;
3388 if ((asect
->flags
& SEC_STRINGS
) != 0)
3389 this_hdr
->sh_flags
|= SHF_STRINGS
;
3390 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3391 this_hdr
->sh_flags
|= SHF_GROUP
;
3392 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3394 this_hdr
->sh_flags
|= SHF_TLS
;
3395 if (asect
->size
== 0
3396 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3398 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3400 this_hdr
->sh_size
= 0;
3403 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3404 if (this_hdr
->sh_size
!= 0)
3405 this_hdr
->sh_type
= SHT_NOBITS
;
3409 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3410 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3412 /* If the section has relocs, set up a section header for the
3413 SHT_REL[A] section. If two relocation sections are required for
3414 this section, it is up to the processor-specific back-end to
3415 create the other. */
3416 if ((asect
->flags
& SEC_RELOC
) != 0)
3418 /* When doing a relocatable link, create both REL and RELA sections if
3421 /* Do the normal setup if we wouldn't create any sections here. */
3422 && esd
->rel
.count
+ esd
->rela
.count
> 0
3423 && (bfd_link_relocatable (arg
->link_info
)
3424 || arg
->link_info
->emitrelocations
))
3426 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3427 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3428 false, delay_st_name_p
))
3433 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3434 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3435 true, delay_st_name_p
))
3441 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3443 ? &esd
->rela
: &esd
->rel
),
3453 /* Check for processor-specific section types. */
3454 sh_type
= this_hdr
->sh_type
;
3455 if (bed
->elf_backend_fake_sections
3456 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3462 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3464 /* Don't change the header type from NOBITS if we are being
3465 called for objcopy --only-keep-debug. */
3466 this_hdr
->sh_type
= sh_type
;
3470 /* Fill in the contents of a SHT_GROUP section. Called from
3471 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3472 when ELF targets use the generic linker, ld. Called for ld -r
3473 from bfd_elf_final_link. */
3476 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3478 bool *failedptr
= (bool *) failedptrarg
;
3479 asection
*elt
, *first
;
3483 /* Ignore linker created group section. See elfNN_ia64_object_p in
3485 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3490 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3492 unsigned long symindx
= 0;
3494 /* elf_group_id will have been set up by objcopy and the
3496 if (elf_group_id (sec
) != NULL
)
3497 symindx
= elf_group_id (sec
)->udata
.i
;
3501 /* If called from the assembler, swap_out_syms will have set up
3503 PR 25699: A corrupt input file could contain bogus group info. */
3504 if (sec
->index
>= elf_num_section_syms (abfd
)
3505 || elf_section_syms (abfd
)[sec
->index
] == NULL
)
3510 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3512 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3514 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3516 /* The ELF backend linker sets sh_info to -2 when the group
3517 signature symbol is global, and thus the index can't be
3518 set until all local symbols are output. */
3520 struct bfd_elf_section_data
*sec_data
;
3521 unsigned long symndx
;
3522 unsigned long extsymoff
;
3523 struct elf_link_hash_entry
*h
;
3525 /* The point of this little dance to the first SHF_GROUP section
3526 then back to the SHT_GROUP section is that this gets us to
3527 the SHT_GROUP in the input object. */
3528 igroup
= elf_sec_group (elf_next_in_group (sec
));
3529 sec_data
= elf_section_data (igroup
);
3530 symndx
= sec_data
->this_hdr
.sh_info
;
3532 if (!elf_bad_symtab (igroup
->owner
))
3534 Elf_Internal_Shdr
*symtab_hdr
;
3536 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3537 extsymoff
= symtab_hdr
->sh_info
;
3539 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3540 while (h
->root
.type
== bfd_link_hash_indirect
3541 || h
->root
.type
== bfd_link_hash_warning
)
3542 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3544 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3547 /* The contents won't be allocated for "ld -r" or objcopy. */
3549 if (sec
->contents
== NULL
)
3552 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3554 /* Arrange for the section to be written out. */
3555 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3556 if (sec
->contents
== NULL
)
3563 loc
= sec
->contents
+ sec
->size
;
3565 /* Get the pointer to the first section in the group that gas
3566 squirreled away here. objcopy arranges for this to be set to the
3567 start of the input section group. */
3568 first
= elt
= elf_next_in_group (sec
);
3570 /* First element is a flag word. Rest of section is elf section
3571 indices for all the sections of the group. Write them backwards
3572 just to keep the group in the same order as given in .section
3573 directives, not that it matters. */
3580 s
= s
->output_section
;
3582 && !bfd_is_abs_section (s
))
3584 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3585 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3587 if (elf_sec
->rel
.hdr
!= NULL
3589 || (input_elf_sec
->rel
.hdr
!= NULL
3590 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3592 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3594 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3596 if (elf_sec
->rela
.hdr
!= NULL
3598 || (input_elf_sec
->rela
.hdr
!= NULL
3599 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3601 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3603 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3606 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3608 elt
= elf_next_in_group (elt
);
3614 BFD_ASSERT (loc
== sec
->contents
);
3616 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3619 /* Given NAME, the name of a relocation section stripped of its
3620 .rel/.rela prefix, return the section in ABFD to which the
3621 relocations apply. */
3624 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3626 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3627 section likely apply to .got.plt or .got section. */
3628 if (get_elf_backend_data (abfd
)->want_got_plt
3629 && strcmp (name
, ".plt") == 0)
3634 sec
= bfd_get_section_by_name (abfd
, name
);
3640 return bfd_get_section_by_name (abfd
, name
);
3643 /* Return the section to which RELOC_SEC applies. */
3646 elf_get_reloc_section (asection
*reloc_sec
)
3651 const struct elf_backend_data
*bed
;
3653 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3654 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3657 /* We look up the section the relocs apply to by name. */
3658 name
= reloc_sec
->name
;
3659 if (!startswith (name
, ".rel"))
3662 if (type
== SHT_RELA
&& *name
++ != 'a')
3665 abfd
= reloc_sec
->owner
;
3666 bed
= get_elf_backend_data (abfd
);
3667 return bed
->get_reloc_section (abfd
, name
);
3670 /* Assign all ELF section numbers. The dummy first section is handled here
3671 too. The link/info pointers for the standard section types are filled
3672 in here too, while we're at it. LINK_INFO will be 0 when arriving
3673 here for objcopy, and when using the generic ELF linker. */
3676 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3678 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3680 unsigned int section_number
;
3681 Elf_Internal_Shdr
**i_shdrp
;
3682 struct bfd_elf_section_data
*d
;
3688 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3690 /* SHT_GROUP sections are in relocatable files only. */
3691 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3693 size_t reloc_count
= 0;
3695 /* Put SHT_GROUP sections first. */
3696 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3698 d
= elf_section_data (sec
);
3700 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3702 if (sec
->flags
& SEC_LINKER_CREATED
)
3704 /* Remove the linker created SHT_GROUP sections. */
3705 bfd_section_list_remove (abfd
, sec
);
3706 abfd
->section_count
--;
3709 d
->this_idx
= section_number
++;
3712 /* Count relocations. */
3713 reloc_count
+= sec
->reloc_count
;
3716 /* Clear HAS_RELOC if there are no relocations. */
3717 if (reloc_count
== 0)
3718 abfd
->flags
&= ~HAS_RELOC
;
3721 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3723 d
= elf_section_data (sec
);
3725 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3726 d
->this_idx
= section_number
++;
3727 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3728 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3731 d
->rel
.idx
= section_number
++;
3732 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3733 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3740 d
->rela
.idx
= section_number
++;
3741 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3742 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3748 need_symtab
= (bfd_get_symcount (abfd
) > 0
3749 || (link_info
== NULL
3750 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3754 elf_onesymtab (abfd
) = section_number
++;
3755 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3756 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3758 elf_section_list
*entry
;
3760 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3762 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3763 entry
->ndx
= section_number
++;
3764 elf_symtab_shndx_list (abfd
) = entry
;
3766 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3767 ".symtab_shndx", false);
3768 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3771 elf_strtab_sec (abfd
) = section_number
++;
3772 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3775 elf_shstrtab_sec (abfd
) = section_number
++;
3776 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3777 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3779 if (section_number
>= SHN_LORESERVE
)
3781 /* xgettext:c-format */
3782 _bfd_error_handler (_("%pB: too many sections: %u"),
3783 abfd
, section_number
);
3787 elf_numsections (abfd
) = section_number
;
3788 elf_elfheader (abfd
)->e_shnum
= section_number
;
3790 /* Set up the list of section header pointers, in agreement with the
3792 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
3793 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc (abfd
, amt
);
3794 if (i_shdrp
== NULL
)
3797 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3798 sizeof (Elf_Internal_Shdr
));
3799 if (i_shdrp
[0] == NULL
)
3801 bfd_release (abfd
, i_shdrp
);
3805 elf_elfsections (abfd
) = i_shdrp
;
3807 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3810 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3811 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3813 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3814 BFD_ASSERT (entry
!= NULL
);
3815 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3816 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3818 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3819 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3822 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3826 d
= elf_section_data (sec
);
3828 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3829 if (d
->rel
.idx
!= 0)
3830 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3831 if (d
->rela
.idx
!= 0)
3832 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3834 /* Fill in the sh_link and sh_info fields while we're at it. */
3836 /* sh_link of a reloc section is the section index of the symbol
3837 table. sh_info is the section index of the section to which
3838 the relocation entries apply. */
3839 if (d
->rel
.idx
!= 0)
3841 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3842 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3843 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3845 if (d
->rela
.idx
!= 0)
3847 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3848 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3849 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3852 /* We need to set up sh_link for SHF_LINK_ORDER. */
3853 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3855 s
= elf_linked_to_section (sec
);
3856 /* We can now have a NULL linked section pointer.
3857 This happens when the sh_link field is 0, which is done
3858 when a linked to section is discarded but the linking
3859 section has been retained for some reason. */
3862 /* Check discarded linkonce section. */
3863 if (discarded_section (s
))
3867 /* xgettext:c-format */
3868 (_("%pB: sh_link of section `%pA' points to"
3869 " discarded section `%pA' of `%pB'"),
3870 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3871 /* Point to the kept section if it has the same
3872 size as the discarded one. */
3873 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3876 bfd_set_error (bfd_error_bad_value
);
3881 /* Handle objcopy. */
3882 else if (s
->output_section
== NULL
)
3885 /* xgettext:c-format */
3886 (_("%pB: sh_link of section `%pA' points to"
3887 " removed section `%pA' of `%pB'"),
3888 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3889 bfd_set_error (bfd_error_bad_value
);
3892 s
= s
->output_section
;
3893 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3897 switch (d
->this_hdr
.sh_type
)
3901 /* A reloc section which we are treating as a normal BFD
3902 section. sh_link is the section index of the symbol
3903 table. sh_info is the section index of the section to
3904 which the relocation entries apply. We assume that an
3905 allocated reloc section uses the dynamic symbol table
3906 if there is one. Otherwise we guess the normal symbol
3907 table. FIXME: How can we be sure? */
3908 if (d
->this_hdr
.sh_link
== 0 && (sec
->flags
& SEC_ALLOC
) != 0)
3910 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3912 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3914 if (d
->this_hdr
.sh_link
== 0)
3915 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3917 s
= elf_get_reloc_section (sec
);
3920 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3921 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3926 /* We assume that a section named .stab*str is a stabs
3927 string section. We look for a section with the same name
3928 but without the trailing ``str'', and set its sh_link
3929 field to point to this section. */
3930 if (startswith (sec
->name
, ".stab")
3931 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3936 len
= strlen (sec
->name
);
3937 alc
= (char *) bfd_malloc (len
- 2);
3940 memcpy (alc
, sec
->name
, len
- 3);
3941 alc
[len
- 3] = '\0';
3942 s
= bfd_get_section_by_name (abfd
, alc
);
3946 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3948 /* This is a .stab section. */
3949 elf_section_data (s
)->this_hdr
.sh_entsize
= 12;
3956 case SHT_GNU_verneed
:
3957 case SHT_GNU_verdef
:
3958 /* sh_link is the section header index of the string table
3959 used for the dynamic entries, or the symbol table, or the
3961 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3963 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3966 case SHT_GNU_LIBLIST
:
3967 /* sh_link is the section header index of the prelink library
3968 list used for the dynamic entries, or the symbol table, or
3969 the version strings. */
3970 s
= bfd_get_section_by_name (abfd
, ((sec
->flags
& SEC_ALLOC
)
3971 ? ".dynstr" : ".gnu.libstr"));
3973 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3978 case SHT_GNU_versym
:
3979 /* sh_link is the section header index of the symbol table
3980 this hash table or version table is for. */
3981 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3983 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3987 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3991 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3992 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3993 debug section name from .debug_* to .zdebug_* if needed. */
3999 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4001 /* If the backend has a special mapping, use it. */
4002 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4003 if (bed
->elf_backend_sym_is_global
)
4004 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4006 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4007 || bfd_is_und_section (bfd_asymbol_section (sym
))
4008 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4011 /* Filter global symbols of ABFD to include in the import library. All
4012 SYMCOUNT symbols of ABFD can be examined from their pointers in
4013 SYMS. Pointers of symbols to keep should be stored contiguously at
4014 the beginning of that array.
4016 Returns the number of symbols to keep. */
4019 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4020 asymbol
**syms
, long symcount
)
4022 long src_count
, dst_count
= 0;
4024 for (src_count
= 0; src_count
< symcount
; src_count
++)
4026 asymbol
*sym
= syms
[src_count
];
4027 char *name
= (char *) bfd_asymbol_name (sym
);
4028 struct bfd_link_hash_entry
*h
;
4030 if (!sym_is_global (abfd
, sym
))
4033 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, false);
4036 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4038 if (h
->linker_def
|| h
->ldscript_def
)
4041 syms
[dst_count
++] = sym
;
4044 syms
[dst_count
] = NULL
;
4049 /* Don't output section symbols for sections that are not going to be
4050 output, that are duplicates or there is no BFD section. */
4053 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4055 elf_symbol_type
*type_ptr
;
4060 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4063 /* Ignore the section symbol if it isn't used. */
4064 if ((sym
->flags
& BSF_SECTION_SYM_USED
) == 0)
4067 if (sym
->section
== NULL
)
4070 type_ptr
= elf_symbol_from (sym
);
4071 return ((type_ptr
!= NULL
4072 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4073 && bfd_is_abs_section (sym
->section
))
4074 || !(sym
->section
->owner
== abfd
4075 || (sym
->section
->output_section
!= NULL
4076 && sym
->section
->output_section
->owner
== abfd
4077 && sym
->section
->output_offset
== 0)
4078 || bfd_is_abs_section (sym
->section
)));
4081 /* Map symbol from it's internal number to the external number, moving
4082 all local symbols to be at the head of the list. */
4085 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4087 unsigned int symcount
= bfd_get_symcount (abfd
);
4088 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4089 asymbol
**sect_syms
;
4090 unsigned int num_locals
= 0;
4091 unsigned int num_globals
= 0;
4092 unsigned int num_locals2
= 0;
4093 unsigned int num_globals2
= 0;
4094 unsigned int max_index
= 0;
4101 fprintf (stderr
, "elf_map_symbols\n");
4105 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4107 if (max_index
< asect
->index
)
4108 max_index
= asect
->index
;
4112 amt
= max_index
* sizeof (asymbol
*);
4113 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
4114 if (sect_syms
== NULL
)
4116 elf_section_syms (abfd
) = sect_syms
;
4117 elf_num_section_syms (abfd
) = max_index
;
4119 /* Init sect_syms entries for any section symbols we have already
4120 decided to output. */
4121 for (idx
= 0; idx
< symcount
; idx
++)
4123 asymbol
*sym
= syms
[idx
];
4125 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4127 && !ignore_section_sym (abfd
, sym
)
4128 && !bfd_is_abs_section (sym
->section
))
4130 asection
*sec
= sym
->section
;
4132 if (sec
->owner
!= abfd
)
4133 sec
= sec
->output_section
;
4135 sect_syms
[sec
->index
] = syms
[idx
];
4139 /* Classify all of the symbols. */
4140 for (idx
= 0; idx
< symcount
; idx
++)
4142 if (sym_is_global (abfd
, syms
[idx
]))
4144 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4148 /* We will be adding a section symbol for each normal BFD section. Most
4149 sections will already have a section symbol in outsymbols, but
4150 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4151 at least in that case. */
4152 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4154 asymbol
*sym
= asect
->symbol
;
4155 /* Don't include ignored section symbols. */
4156 if (!ignore_section_sym (abfd
, sym
)
4157 && sect_syms
[asect
->index
] == NULL
)
4159 if (!sym_is_global (abfd
, asect
->symbol
))
4166 /* Now sort the symbols so the local symbols are first. */
4167 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
4168 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
4169 if (new_syms
== NULL
)
4172 for (idx
= 0; idx
< symcount
; idx
++)
4174 asymbol
*sym
= syms
[idx
];
4177 if (sym_is_global (abfd
, sym
))
4178 i
= num_locals
+ num_globals2
++;
4179 /* Don't include ignored section symbols. */
4180 else if (!ignore_section_sym (abfd
, sym
))
4185 sym
->udata
.i
= i
+ 1;
4187 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4189 asymbol
*sym
= asect
->symbol
;
4190 if (!ignore_section_sym (abfd
, sym
)
4191 && sect_syms
[asect
->index
] == NULL
)
4195 sect_syms
[asect
->index
] = sym
;
4196 if (!sym_is_global (abfd
, sym
))
4199 i
= num_locals
+ num_globals2
++;
4201 sym
->udata
.i
= i
+ 1;
4205 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4207 *pnum_locals
= num_locals
;
4211 /* Align to the maximum file alignment that could be required for any
4212 ELF data structure. */
4214 static inline file_ptr
4215 align_file_position (file_ptr off
, int align
)
4217 return (off
+ align
- 1) & ~(align
- 1);
4220 /* Assign a file position to a section, optionally aligning to the
4221 required section alignment. */
4224 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4228 if (align
&& i_shdrp
->sh_addralign
> 1)
4229 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4230 i_shdrp
->sh_offset
= offset
;
4231 if (i_shdrp
->bfd_section
!= NULL
)
4232 i_shdrp
->bfd_section
->filepos
= offset
;
4233 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4234 offset
+= i_shdrp
->sh_size
;
4238 /* Compute the file positions we are going to put the sections at, and
4239 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4240 is not NULL, this is being called by the ELF backend linker. */
4243 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4244 struct bfd_link_info
*link_info
)
4246 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4247 struct fake_section_arg fsargs
;
4249 struct elf_strtab_hash
*strtab
= NULL
;
4250 Elf_Internal_Shdr
*shstrtab_hdr
;
4253 if (abfd
->output_has_begun
)
4256 /* Do any elf backend specific processing first. */
4257 if (bed
->elf_backend_begin_write_processing
)
4258 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4260 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4263 fsargs
.failed
= false;
4264 fsargs
.link_info
= link_info
;
4265 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4269 if (!assign_section_numbers (abfd
, link_info
))
4272 /* The backend linker builds symbol table information itself. */
4273 need_symtab
= (link_info
== NULL
4274 && (bfd_get_symcount (abfd
) > 0
4275 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4279 /* Non-zero if doing a relocatable link. */
4280 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4282 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
, link_info
))
4287 if (link_info
== NULL
)
4289 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4294 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4295 /* sh_name was set in init_file_header. */
4296 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4297 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4298 shstrtab_hdr
->sh_addr
= 0;
4299 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4300 shstrtab_hdr
->sh_entsize
= 0;
4301 shstrtab_hdr
->sh_link
= 0;
4302 shstrtab_hdr
->sh_info
= 0;
4303 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4304 shstrtab_hdr
->sh_addralign
= 1;
4306 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4312 Elf_Internal_Shdr
*hdr
;
4314 off
= elf_next_file_pos (abfd
);
4316 hdr
= & elf_symtab_hdr (abfd
);
4317 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4319 if (elf_symtab_shndx_list (abfd
) != NULL
)
4321 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4322 if (hdr
->sh_size
!= 0)
4323 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4324 /* FIXME: What about other symtab_shndx sections in the list ? */
4327 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4328 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4330 elf_next_file_pos (abfd
) = off
;
4332 /* Now that we know where the .strtab section goes, write it
4334 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4335 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4337 _bfd_elf_strtab_free (strtab
);
4340 abfd
->output_has_begun
= true;
4345 /* Make an initial estimate of the size of the program header. If we
4346 get the number wrong here, we'll redo section placement. */
4348 static bfd_size_type
4349 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4353 const struct elf_backend_data
*bed
;
4355 /* Assume we will need exactly two PT_LOAD segments: one for text
4356 and one for data. */
4359 s
= bfd_get_section_by_name (abfd
, ".interp");
4360 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4362 /* If we have a loadable interpreter section, we need a
4363 PT_INTERP segment. In this case, assume we also need a
4364 PT_PHDR segment, although that may not be true for all
4369 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4371 /* We need a PT_DYNAMIC segment. */
4375 if (info
!= NULL
&& info
->relro
)
4377 /* We need a PT_GNU_RELRO segment. */
4381 if (elf_eh_frame_hdr (abfd
))
4383 /* We need a PT_GNU_EH_FRAME segment. */
4387 if (elf_stack_flags (abfd
))
4389 /* We need a PT_GNU_STACK segment. */
4393 s
= bfd_get_section_by_name (abfd
,
4394 NOTE_GNU_PROPERTY_SECTION_NAME
);
4395 if (s
!= NULL
&& s
->size
!= 0)
4397 /* We need a PT_GNU_PROPERTY segment. */
4401 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4403 if ((s
->flags
& SEC_LOAD
) != 0
4404 && elf_section_type (s
) == SHT_NOTE
)
4406 unsigned int alignment_power
;
4407 /* We need a PT_NOTE segment. */
4409 /* Try to create just one PT_NOTE segment for all adjacent
4410 loadable SHT_NOTE sections. gABI requires that within a
4411 PT_NOTE segment (and also inside of each SHT_NOTE section)
4412 each note should have the same alignment. So we check
4413 whether the sections are correctly aligned. */
4414 alignment_power
= s
->alignment_power
;
4415 while (s
->next
!= NULL
4416 && s
->next
->alignment_power
== alignment_power
4417 && (s
->next
->flags
& SEC_LOAD
) != 0
4418 && elf_section_type (s
->next
) == SHT_NOTE
)
4423 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4425 if (s
->flags
& SEC_THREAD_LOCAL
)
4427 /* We need a PT_TLS segment. */
4433 bed
= get_elf_backend_data (abfd
);
4435 if ((abfd
->flags
& D_PAGED
) != 0
4436 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4438 /* Add a PT_GNU_MBIND segment for each mbind section. */
4439 bfd_vma commonpagesize
;
4440 unsigned int page_align_power
;
4443 commonpagesize
= info
->commonpagesize
;
4445 commonpagesize
= bed
->commonpagesize
;
4446 page_align_power
= bfd_log2 (commonpagesize
);
4447 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4448 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4450 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4453 /* xgettext:c-format */
4454 (_("%pB: GNU_MBIND section `%pA' has invalid "
4455 "sh_info field: %d"),
4456 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4459 /* Align mbind section to page size. */
4460 if (s
->alignment_power
< page_align_power
)
4461 s
->alignment_power
= page_align_power
;
4466 /* Let the backend count up any program headers it might need. */
4467 if (bed
->elf_backend_additional_program_headers
)
4471 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4477 return segs
* bed
->s
->sizeof_phdr
;
4480 /* Find the segment that contains the output_section of section. */
4483 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4485 struct elf_segment_map
*m
;
4486 Elf_Internal_Phdr
*p
;
4488 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4494 for (i
= m
->count
- 1; i
>= 0; i
--)
4495 if (m
->sections
[i
] == section
)
4502 /* Create a mapping from a set of sections to a program segment. */
4504 static struct elf_segment_map
*
4505 make_mapping (bfd
*abfd
,
4506 asection
**sections
,
4511 struct elf_segment_map
*m
;
4516 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4517 amt
+= (to
- from
) * sizeof (asection
*);
4518 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4522 m
->p_type
= PT_LOAD
;
4523 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4524 m
->sections
[i
- from
] = *hdrpp
;
4525 m
->count
= to
- from
;
4527 if (from
== 0 && phdr
)
4529 /* Include the headers in the first PT_LOAD segment. */
4530 m
->includes_filehdr
= 1;
4531 m
->includes_phdrs
= 1;
4537 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4540 struct elf_segment_map
*
4541 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4543 struct elf_segment_map
*m
;
4545 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4546 sizeof (struct elf_segment_map
));
4550 m
->p_type
= PT_DYNAMIC
;
4552 m
->sections
[0] = dynsec
;
4557 /* Possibly add or remove segments from the segment map. */
4560 elf_modify_segment_map (bfd
*abfd
,
4561 struct bfd_link_info
*info
,
4562 bool remove_empty_load
)
4564 struct elf_segment_map
**m
;
4565 const struct elf_backend_data
*bed
;
4567 /* The placement algorithm assumes that non allocated sections are
4568 not in PT_LOAD segments. We ensure this here by removing such
4569 sections from the segment map. We also remove excluded
4570 sections. Finally, any PT_LOAD segment without sections is
4572 m
= &elf_seg_map (abfd
);
4575 unsigned int i
, new_count
;
4577 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4579 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4580 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4581 || (*m
)->p_type
!= PT_LOAD
))
4583 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4587 (*m
)->count
= new_count
;
4589 if (remove_empty_load
4590 && (*m
)->p_type
== PT_LOAD
4592 && !(*m
)->includes_phdrs
)
4598 bed
= get_elf_backend_data (abfd
);
4599 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4601 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4608 #define IS_TBSS(s) \
4609 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4611 /* Set up a mapping from BFD sections to program segments. */
4614 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4617 struct elf_segment_map
*m
;
4618 asection
**sections
= NULL
;
4619 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4622 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4625 info
->user_phdrs
= !no_user_phdrs
;
4627 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4631 struct elf_segment_map
*mfirst
;
4632 struct elf_segment_map
**pm
;
4635 unsigned int hdr_index
;
4636 bfd_vma maxpagesize
;
4638 bool phdr_in_segment
;
4641 unsigned int tls_count
= 0;
4642 asection
*first_tls
= NULL
;
4643 asection
*first_mbind
= NULL
;
4644 asection
*dynsec
, *eh_frame_hdr
;
4646 bfd_vma addr_mask
, wrap_to
= 0; /* Bytes. */
4647 bfd_size_type phdr_size
; /* Octets/bytes. */
4648 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
4650 /* Select the allocated sections, and sort them. */
4652 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
4653 sections
= (asection
**) bfd_malloc (amt
);
4654 if (sections
== NULL
)
4657 /* Calculate top address, avoiding undefined behaviour of shift
4658 left operator when shift count is equal to size of type
4660 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4661 addr_mask
= (addr_mask
<< 1) + 1;
4664 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4666 if ((s
->flags
& SEC_ALLOC
) != 0)
4668 /* target_index is unused until bfd_elf_final_link
4669 starts output of section symbols. Use it to make
4671 s
->target_index
= i
;
4674 /* A wrapping section potentially clashes with header. */
4675 if (((s
->lma
+ s
->size
/ opb
) & addr_mask
) < (s
->lma
& addr_mask
))
4676 wrap_to
= (s
->lma
+ s
->size
/ opb
) & addr_mask
;
4679 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4682 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4684 phdr_size
= elf_program_header_size (abfd
);
4685 if (phdr_size
== (bfd_size_type
) -1)
4686 phdr_size
= get_program_header_size (abfd
, info
);
4687 phdr_size
+= bed
->s
->sizeof_ehdr
;
4688 /* phdr_size is compared to LMA values which are in bytes. */
4691 maxpagesize
= info
->maxpagesize
;
4693 maxpagesize
= bed
->maxpagesize
;
4694 if (maxpagesize
== 0)
4696 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4698 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4699 >= (phdr_size
& (maxpagesize
- 1))))
4700 /* For compatibility with old scripts that may not be using
4701 SIZEOF_HEADERS, add headers when it looks like space has
4702 been left for them. */
4703 phdr_in_segment
= true;
4705 /* Build the mapping. */
4709 /* If we have a .interp section, then create a PT_PHDR segment for
4710 the program headers and a PT_INTERP segment for the .interp
4712 s
= bfd_get_section_by_name (abfd
, ".interp");
4713 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4715 amt
= sizeof (struct elf_segment_map
);
4716 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4720 m
->p_type
= PT_PHDR
;
4722 m
->p_flags_valid
= 1;
4723 m
->includes_phdrs
= 1;
4724 phdr_in_segment
= true;
4728 amt
= sizeof (struct elf_segment_map
);
4729 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4733 m
->p_type
= PT_INTERP
;
4741 /* Look through the sections. We put sections in the same program
4742 segment when the start of the second section can be placed within
4743 a few bytes of the end of the first section. */
4749 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4751 && (dynsec
->flags
& SEC_LOAD
) == 0)
4754 if ((abfd
->flags
& D_PAGED
) == 0)
4755 phdr_in_segment
= false;
4757 /* Deal with -Ttext or something similar such that the first section
4758 is not adjacent to the program headers. This is an
4759 approximation, since at this point we don't know exactly how many
4760 program headers we will need. */
4761 if (phdr_in_segment
&& count
> 0)
4763 bfd_vma phdr_lma
; /* Bytes. */
4764 bool separate_phdr
= false;
4766 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4768 && info
->separate_code
4769 && (sections
[0]->flags
& SEC_CODE
) != 0)
4771 /* If data sections should be separate from code and
4772 thus not executable, and the first section is
4773 executable then put the file and program headers in
4774 their own PT_LOAD. */
4775 separate_phdr
= true;
4776 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4777 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4779 /* The file and program headers are currently on the
4780 same page as the first section. Put them on the
4781 previous page if we can. */
4782 if (phdr_lma
>= maxpagesize
)
4783 phdr_lma
-= maxpagesize
;
4785 separate_phdr
= false;
4788 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4789 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4790 /* If file and program headers would be placed at the end
4791 of memory then it's probably better to omit them. */
4792 phdr_in_segment
= false;
4793 else if (phdr_lma
< wrap_to
)
4794 /* If a section wraps around to where we'll be placing
4795 file and program headers, then the headers will be
4797 phdr_in_segment
= false;
4798 else if (separate_phdr
)
4800 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4803 m
->p_paddr
= phdr_lma
* opb
;
4805 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4806 m
->p_paddr_valid
= 1;
4809 phdr_in_segment
= false;
4813 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4820 /* See if this section and the last one will fit in the same
4823 if (last_hdr
== NULL
)
4825 /* If we don't have a segment yet, then we don't need a new
4826 one (we build the last one after this loop). */
4827 new_segment
= false;
4829 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4831 /* If this section has a different relation between the
4832 virtual address and the load address, then we need a new
4836 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4837 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4839 /* If this section has a load address that makes it overlap
4840 the previous section, then we need a new segment. */
4843 else if ((abfd
->flags
& D_PAGED
) != 0
4844 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4845 == (hdr
->lma
& -maxpagesize
)))
4847 /* If we are demand paged then we can't map two disk
4848 pages onto the same memory page. */
4849 new_segment
= false;
4851 /* In the next test we have to be careful when last_hdr->lma is close
4852 to the end of the address space. If the aligned address wraps
4853 around to the start of the address space, then there are no more
4854 pages left in memory and it is OK to assume that the current
4855 section can be included in the current segment. */
4856 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4857 + maxpagesize
> last_hdr
->lma
)
4858 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4859 + maxpagesize
<= hdr
->lma
))
4861 /* If putting this section in this segment would force us to
4862 skip a page in the segment, then we need a new segment. */
4865 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4866 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4868 /* We don't want to put a loaded section after a
4869 nonloaded (ie. bss style) section in the same segment
4870 as that will force the non-loaded section to be loaded.
4871 Consider .tbss sections as loaded for this purpose. */
4874 else if ((abfd
->flags
& D_PAGED
) == 0)
4876 /* If the file is not demand paged, which means that we
4877 don't require the sections to be correctly aligned in the
4878 file, then there is no other reason for a new segment. */
4879 new_segment
= false;
4881 else if (info
!= NULL
4882 && info
->separate_code
4883 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4888 && (hdr
->flags
& SEC_READONLY
) == 0)
4890 /* We don't want to put a writable section in a read only
4896 /* Otherwise, we can use the same segment. */
4897 new_segment
= false;
4900 /* Allow interested parties a chance to override our decision. */
4901 if (last_hdr
!= NULL
4903 && info
->callbacks
->override_segment_assignment
!= NULL
)
4905 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4911 if ((hdr
->flags
& SEC_READONLY
) == 0)
4913 if ((hdr
->flags
& SEC_CODE
) != 0)
4916 /* .tbss sections effectively have zero size. */
4917 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4921 /* We need a new program segment. We must create a new program
4922 header holding all the sections from hdr_index until hdr. */
4924 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4931 if ((hdr
->flags
& SEC_READONLY
) == 0)
4936 if ((hdr
->flags
& SEC_CODE
) == 0)
4942 /* .tbss sections effectively have zero size. */
4943 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4945 phdr_in_segment
= false;
4948 /* Create a final PT_LOAD program segment, but not if it's just
4950 if (last_hdr
!= NULL
4951 && (i
- hdr_index
!= 1
4952 || !IS_TBSS (last_hdr
)))
4954 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4962 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4965 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4972 /* For each batch of consecutive loadable SHT_NOTE sections,
4973 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4974 because if we link together nonloadable .note sections and
4975 loadable .note sections, we will generate two .note sections
4976 in the output file. */
4977 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4979 if ((s
->flags
& SEC_LOAD
) != 0
4980 && elf_section_type (s
) == SHT_NOTE
)
4983 unsigned int alignment_power
= s
->alignment_power
;
4986 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4988 if (s2
->next
->alignment_power
== alignment_power
4989 && (s2
->next
->flags
& SEC_LOAD
) != 0
4990 && elf_section_type (s2
->next
) == SHT_NOTE
4991 && align_power (s2
->lma
+ s2
->size
/ opb
,
4998 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4999 amt
+= count
* sizeof (asection
*);
5000 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5004 m
->p_type
= PT_NOTE
;
5008 m
->sections
[m
->count
- count
--] = s
;
5009 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5012 m
->sections
[m
->count
- 1] = s
;
5013 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5017 if (s
->flags
& SEC_THREAD_LOCAL
)
5023 if (first_mbind
== NULL
5024 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5028 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5031 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5032 amt
+= tls_count
* sizeof (asection
*);
5033 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5038 m
->count
= tls_count
;
5039 /* Mandated PF_R. */
5041 m
->p_flags_valid
= 1;
5043 for (i
= 0; i
< tls_count
; ++i
)
5045 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5048 (_("%pB: TLS sections are not adjacent:"), abfd
);
5051 while (i
< tls_count
)
5053 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5055 _bfd_error_handler (_(" TLS: %pA"), s
);
5059 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5062 bfd_set_error (bfd_error_bad_value
);
5074 && (abfd
->flags
& D_PAGED
) != 0
5075 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5076 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5077 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5078 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5080 /* Mandated PF_R. */
5081 unsigned long p_flags
= PF_R
;
5082 if ((s
->flags
& SEC_READONLY
) == 0)
5084 if ((s
->flags
& SEC_CODE
) != 0)
5087 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5088 m
= bfd_zalloc (abfd
, amt
);
5092 m
->p_type
= (PT_GNU_MBIND_LO
5093 + elf_section_data (s
)->this_hdr
.sh_info
);
5095 m
->p_flags_valid
= 1;
5097 m
->p_flags
= p_flags
;
5103 s
= bfd_get_section_by_name (abfd
,
5104 NOTE_GNU_PROPERTY_SECTION_NAME
);
5105 if (s
!= NULL
&& s
->size
!= 0)
5107 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5108 m
= bfd_zalloc (abfd
, amt
);
5112 m
->p_type
= PT_GNU_PROPERTY
;
5114 m
->p_flags_valid
= 1;
5121 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5123 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5124 if (eh_frame_hdr
!= NULL
5125 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5127 amt
= sizeof (struct elf_segment_map
);
5128 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5132 m
->p_type
= PT_GNU_EH_FRAME
;
5134 m
->sections
[0] = eh_frame_hdr
->output_section
;
5140 if (elf_stack_flags (abfd
))
5142 amt
= sizeof (struct elf_segment_map
);
5143 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5147 m
->p_type
= PT_GNU_STACK
;
5148 m
->p_flags
= elf_stack_flags (abfd
);
5149 m
->p_align
= bed
->stack_align
;
5150 m
->p_flags_valid
= 1;
5151 m
->p_align_valid
= m
->p_align
!= 0;
5152 if (info
->stacksize
> 0)
5154 m
->p_size
= info
->stacksize
;
5155 m
->p_size_valid
= 1;
5162 if (info
!= NULL
&& info
->relro
)
5164 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5166 if (m
->p_type
== PT_LOAD
5168 && m
->sections
[0]->vma
>= info
->relro_start
5169 && m
->sections
[0]->vma
< info
->relro_end
)
5172 while (--i
!= (unsigned) -1)
5174 if (m
->sections
[i
]->size
> 0
5175 && (m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5176 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5180 if (i
!= (unsigned) -1)
5185 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5188 amt
= sizeof (struct elf_segment_map
);
5189 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5193 m
->p_type
= PT_GNU_RELRO
;
5200 elf_seg_map (abfd
) = mfirst
;
5203 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5206 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5208 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5217 /* Sort sections by address. */
5220 elf_sort_sections (const void *arg1
, const void *arg2
)
5222 const asection
*sec1
= *(const asection
**) arg1
;
5223 const asection
*sec2
= *(const asection
**) arg2
;
5224 bfd_size_type size1
, size2
;
5226 /* Sort by LMA first, since this is the address used to
5227 place the section into a segment. */
5228 if (sec1
->lma
< sec2
->lma
)
5230 else if (sec1
->lma
> sec2
->lma
)
5233 /* Then sort by VMA. Normally the LMA and the VMA will be
5234 the same, and this will do nothing. */
5235 if (sec1
->vma
< sec2
->vma
)
5237 else if (sec1
->vma
> sec2
->vma
)
5240 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5242 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0 \
5250 else if (TOEND (sec2
))
5255 /* Sort by size, to put zero sized sections
5256 before others at the same address. */
5258 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5259 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5266 return sec1
->target_index
- sec2
->target_index
;
5269 /* This qsort comparison functions sorts PT_LOAD segments first and
5270 by p_paddr, for assign_file_positions_for_load_sections. */
5273 elf_sort_segments (const void *arg1
, const void *arg2
)
5275 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5276 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5278 if (m1
->p_type
!= m2
->p_type
)
5280 if (m1
->p_type
== PT_NULL
)
5282 if (m2
->p_type
== PT_NULL
)
5284 return m1
->p_type
< m2
->p_type
? -1 : 1;
5286 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5287 return m1
->includes_filehdr
? -1 : 1;
5288 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5289 return m1
->no_sort_lma
? -1 : 1;
5290 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5292 bfd_vma lma1
, lma2
; /* Octets. */
5294 if (m1
->p_paddr_valid
)
5296 else if (m1
->count
!= 0)
5298 unsigned int opb
= bfd_octets_per_byte (m1
->sections
[0]->owner
,
5300 lma1
= (m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
) * opb
;
5303 if (m2
->p_paddr_valid
)
5305 else if (m2
->count
!= 0)
5307 unsigned int opb
= bfd_octets_per_byte (m2
->sections
[0]->owner
,
5309 lma2
= (m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
) * opb
;
5312 return lma1
< lma2
? -1 : 1;
5314 if (m1
->idx
!= m2
->idx
)
5315 return m1
->idx
< m2
->idx
? -1 : 1;
5319 /* Ian Lance Taylor writes:
5321 We shouldn't be using % with a negative signed number. That's just
5322 not good. We have to make sure either that the number is not
5323 negative, or that the number has an unsigned type. When the types
5324 are all the same size they wind up as unsigned. When file_ptr is a
5325 larger signed type, the arithmetic winds up as signed long long,
5328 What we're trying to say here is something like ``increase OFF by
5329 the least amount that will cause it to be equal to the VMA modulo
5331 /* In other words, something like:
5333 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5334 off_offset = off % bed->maxpagesize;
5335 if (vma_offset < off_offset)
5336 adjustment = vma_offset + bed->maxpagesize - off_offset;
5338 adjustment = vma_offset - off_offset;
5340 which can be collapsed into the expression below. */
5343 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5345 /* PR binutils/16199: Handle an alignment of zero. */
5346 if (maxpagesize
== 0)
5348 return ((vma
- off
) % maxpagesize
);
5352 print_segment_map (const struct elf_segment_map
*m
)
5355 const char *pt
= get_segment_type (m
->p_type
);
5360 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5361 sprintf (buf
, "LOPROC+%7.7x",
5362 (unsigned int) (m
->p_type
- PT_LOPROC
));
5363 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5364 sprintf (buf
, "LOOS+%7.7x",
5365 (unsigned int) (m
->p_type
- PT_LOOS
));
5367 snprintf (buf
, sizeof (buf
), "%8.8x",
5368 (unsigned int) m
->p_type
);
5372 fprintf (stderr
, "%s:", pt
);
5373 for (j
= 0; j
< m
->count
; j
++)
5374 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5380 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5385 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5387 buf
= bfd_zmalloc (len
);
5390 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5395 /* Assign file positions to the sections based on the mapping from
5396 sections to segments. This function also sets up some fields in
5400 assign_file_positions_for_load_sections (bfd
*abfd
,
5401 struct bfd_link_info
*link_info
)
5403 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5404 struct elf_segment_map
*m
;
5405 struct elf_segment_map
*phdr_load_seg
;
5406 Elf_Internal_Phdr
*phdrs
;
5407 Elf_Internal_Phdr
*p
;
5408 file_ptr off
; /* Octets. */
5409 bfd_size_type maxpagesize
;
5410 unsigned int alloc
, actual
;
5412 struct elf_segment_map
**sorted_seg_map
;
5413 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
5415 if (link_info
== NULL
5416 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5420 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5425 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5426 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5430 /* PR binutils/12467. */
5431 elf_elfheader (abfd
)->e_phoff
= 0;
5432 elf_elfheader (abfd
)->e_phentsize
= 0;
5435 elf_elfheader (abfd
)->e_phnum
= alloc
;
5437 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5440 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5444 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5445 BFD_ASSERT (elf_program_header_size (abfd
)
5446 == actual
* bed
->s
->sizeof_phdr
);
5447 BFD_ASSERT (actual
>= alloc
);
5452 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5456 /* We're writing the size in elf_program_header_size (abfd),
5457 see assign_file_positions_except_relocs, so make sure we have
5458 that amount allocated, with trailing space cleared.
5459 The variable alloc contains the computed need, while
5460 elf_program_header_size (abfd) contains the size used for the
5462 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5463 where the layout is forced to according to a larger size in the
5464 last iterations for the testcase ld-elf/header. */
5465 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5466 + alloc
* sizeof (*sorted_seg_map
)));
5467 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5468 elf_tdata (abfd
)->phdr
= phdrs
;
5472 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5474 sorted_seg_map
[j
] = m
;
5475 /* If elf_segment_map is not from map_sections_to_segments, the
5476 sections may not be correctly ordered. NOTE: sorting should
5477 not be done to the PT_NOTE section of a corefile, which may
5478 contain several pseudo-sections artificially created by bfd.
5479 Sorting these pseudo-sections breaks things badly. */
5481 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5482 && m
->p_type
== PT_NOTE
))
5484 for (i
= 0; i
< m
->count
; i
++)
5485 m
->sections
[i
]->target_index
= i
;
5486 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5491 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5495 if ((abfd
->flags
& D_PAGED
) != 0)
5497 if (link_info
!= NULL
)
5498 maxpagesize
= link_info
->maxpagesize
;
5500 maxpagesize
= bed
->maxpagesize
;
5503 /* Sections must map to file offsets past the ELF file header. */
5504 off
= bed
->s
->sizeof_ehdr
;
5505 /* And if one of the PT_LOAD headers doesn't include the program
5506 headers then we'll be mapping program headers in the usual
5507 position after the ELF file header. */
5508 phdr_load_seg
= NULL
;
5509 for (j
= 0; j
< alloc
; j
++)
5511 m
= sorted_seg_map
[j
];
5512 if (m
->p_type
!= PT_LOAD
)
5514 if (m
->includes_phdrs
)
5520 if (phdr_load_seg
== NULL
)
5521 off
+= actual
* bed
->s
->sizeof_phdr
;
5523 for (j
= 0; j
< alloc
; j
++)
5526 bfd_vma off_adjust
; /* Octets. */
5529 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5530 number of sections with contents contributing to both p_filesz
5531 and p_memsz, followed by a number of sections with no contents
5532 that just contribute to p_memsz. In this loop, OFF tracks next
5533 available file offset for PT_LOAD and PT_NOTE segments. */
5534 m
= sorted_seg_map
[j
];
5536 p
->p_type
= m
->p_type
;
5537 p
->p_flags
= m
->p_flags
;
5540 p
->p_vaddr
= m
->p_vaddr_offset
* opb
;
5542 p
->p_vaddr
= (m
->sections
[0]->vma
+ m
->p_vaddr_offset
) * opb
;
5544 if (m
->p_paddr_valid
)
5545 p
->p_paddr
= m
->p_paddr
;
5546 else if (m
->count
== 0)
5549 p
->p_paddr
= (m
->sections
[0]->lma
+ m
->p_vaddr_offset
) * opb
;
5551 if (p
->p_type
== PT_LOAD
5552 && (abfd
->flags
& D_PAGED
) != 0)
5554 /* p_align in demand paged PT_LOAD segments effectively stores
5555 the maximum page size. When copying an executable with
5556 objcopy, we set m->p_align from the input file. Use this
5557 value for maxpagesize rather than bed->maxpagesize, which
5558 may be different. Note that we use maxpagesize for PT_TLS
5559 segment alignment later in this function, so we are relying
5560 on at least one PT_LOAD segment appearing before a PT_TLS
5562 if (m
->p_align_valid
)
5563 maxpagesize
= m
->p_align
;
5565 p
->p_align
= maxpagesize
;
5567 else if (m
->p_align_valid
)
5568 p
->p_align
= m
->p_align
;
5569 else if (m
->count
== 0)
5570 p
->p_align
= 1 << bed
->s
->log_file_align
;
5572 if (m
== phdr_load_seg
)
5574 if (!m
->includes_filehdr
)
5576 off
+= actual
* bed
->s
->sizeof_phdr
;
5579 no_contents
= false;
5581 if (p
->p_type
== PT_LOAD
5584 bfd_size_type align
; /* Bytes. */
5585 unsigned int align_power
= 0;
5587 if (m
->p_align_valid
)
5591 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5593 unsigned int secalign
;
5595 secalign
= bfd_section_alignment (*secpp
);
5596 if (secalign
> align_power
)
5597 align_power
= secalign
;
5599 align
= (bfd_size_type
) 1 << align_power
;
5600 if (align
< maxpagesize
)
5601 align
= maxpagesize
;
5604 for (i
= 0; i
< m
->count
; i
++)
5605 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5606 /* If we aren't making room for this section, then
5607 it must be SHT_NOBITS regardless of what we've
5608 set via struct bfd_elf_special_section. */
5609 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5611 /* Find out whether this segment contains any loadable
5614 for (i
= 0; i
< m
->count
; i
++)
5615 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5617 no_contents
= false;
5621 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
* opb
);
5623 /* Broken hardware and/or kernel require that files do not
5624 map the same page with different permissions on some hppa
5627 && (abfd
->flags
& D_PAGED
) != 0
5628 && bed
->no_page_alias
5629 && (off
& (maxpagesize
- 1)) != 0
5630 && ((off
& -maxpagesize
)
5631 == ((off
+ off_adjust
) & -maxpagesize
)))
5632 off_adjust
+= maxpagesize
;
5636 /* We shouldn't need to align the segment on disk since
5637 the segment doesn't need file space, but the gABI
5638 arguably requires the alignment and glibc ld.so
5639 checks it. So to comply with the alignment
5640 requirement but not waste file space, we adjust
5641 p_offset for just this segment. (OFF_ADJUST is
5642 subtracted from OFF later.) This may put p_offset
5643 past the end of file, but that shouldn't matter. */
5648 /* Make sure the .dynamic section is the first section in the
5649 PT_DYNAMIC segment. */
5650 else if (p
->p_type
== PT_DYNAMIC
5652 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5655 (_("%pB: The first section in the PT_DYNAMIC segment"
5656 " is not the .dynamic section"),
5658 bfd_set_error (bfd_error_bad_value
);
5661 /* Set the note section type to SHT_NOTE. */
5662 else if (p
->p_type
== PT_NOTE
)
5663 for (i
= 0; i
< m
->count
; i
++)
5664 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5666 if (m
->includes_filehdr
)
5668 if (!m
->p_flags_valid
)
5670 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5671 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5672 if (p
->p_type
== PT_LOAD
)
5676 if (p
->p_vaddr
< (bfd_vma
) off
5677 || (!m
->p_paddr_valid
5678 && p
->p_paddr
< (bfd_vma
) off
))
5681 (_("%pB: not enough room for program headers,"
5682 " try linking with -N"),
5684 bfd_set_error (bfd_error_bad_value
);
5688 if (!m
->p_paddr_valid
)
5692 else if (sorted_seg_map
[0]->includes_filehdr
)
5694 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5695 p
->p_vaddr
= filehdr
->p_vaddr
;
5696 if (!m
->p_paddr_valid
)
5697 p
->p_paddr
= filehdr
->p_paddr
;
5701 if (m
->includes_phdrs
)
5703 if (!m
->p_flags_valid
)
5705 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5706 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5707 if (!m
->includes_filehdr
)
5709 if (p
->p_type
== PT_LOAD
)
5711 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5714 p
->p_vaddr
-= off
- p
->p_offset
;
5715 if (!m
->p_paddr_valid
)
5716 p
->p_paddr
-= off
- p
->p_offset
;
5719 else if (phdr_load_seg
!= NULL
)
5721 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5722 bfd_vma phdr_off
= 0; /* Octets. */
5723 if (phdr_load_seg
->includes_filehdr
)
5724 phdr_off
= bed
->s
->sizeof_ehdr
;
5725 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5726 if (!m
->p_paddr_valid
)
5727 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5728 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5731 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5735 if (p
->p_type
== PT_LOAD
5736 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5738 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5743 /* Put meaningless p_offset for PT_LOAD segments
5744 without file contents somewhere within the first
5745 page, in an attempt to not point past EOF. */
5746 bfd_size_type align
= maxpagesize
;
5747 if (align
< p
->p_align
)
5751 p
->p_offset
= off
% align
;
5756 file_ptr adjust
; /* Octets. */
5758 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5760 p
->p_filesz
+= adjust
;
5761 p
->p_memsz
+= adjust
;
5765 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5766 maps. Set filepos for sections in PT_LOAD segments, and in
5767 core files, for sections in PT_NOTE segments.
5768 assign_file_positions_for_non_load_sections will set filepos
5769 for other sections and update p_filesz for other segments. */
5770 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5773 bfd_size_type align
;
5774 Elf_Internal_Shdr
*this_hdr
;
5777 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5778 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5780 if ((p
->p_type
== PT_LOAD
5781 || p
->p_type
== PT_TLS
)
5782 && (this_hdr
->sh_type
!= SHT_NOBITS
5783 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5784 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5785 || p
->p_type
== PT_TLS
))))
5787 bfd_vma p_start
= p
->p_paddr
; /* Octets. */
5788 bfd_vma p_end
= p_start
+ p
->p_memsz
; /* Octets. */
5789 bfd_vma s_start
= sec
->lma
* opb
; /* Octets. */
5790 bfd_vma adjust
= s_start
- p_end
; /* Octets. */
5794 || p_end
< p_start
))
5797 /* xgettext:c-format */
5798 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5799 abfd
, sec
, (uint64_t) s_start
/ opb
,
5800 (uint64_t) p_end
/ opb
);
5802 sec
->lma
= p_end
/ opb
;
5804 p
->p_memsz
+= adjust
;
5806 if (p
->p_type
== PT_LOAD
)
5808 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5811 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5813 /* We have a PROGBITS section following NOBITS ones.
5814 Allocate file space for the NOBITS section(s) and
5816 adjust
= p
->p_memsz
- p
->p_filesz
;
5817 if (!write_zeros (abfd
, off
, adjust
))
5821 /* We only adjust sh_offset in SHT_NOBITS sections
5822 as would seem proper for their address when the
5823 section is first in the segment. sh_offset
5824 doesn't really have any significance for
5825 SHT_NOBITS anyway, apart from a notional position
5826 relative to other sections. Historically we
5827 didn't bother with adjusting sh_offset and some
5828 programs depend on it not being adjusted. See
5829 pr12921 and pr25662. */
5830 if (this_hdr
->sh_type
!= SHT_NOBITS
|| i
== 0)
5833 if (this_hdr
->sh_type
== SHT_NOBITS
)
5834 off_adjust
+= adjust
;
5837 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5838 p
->p_filesz
+= adjust
;
5841 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5843 /* The section at i == 0 is the one that actually contains
5847 this_hdr
->sh_offset
= sec
->filepos
= off
;
5848 off
+= this_hdr
->sh_size
;
5849 p
->p_filesz
= this_hdr
->sh_size
;
5855 /* The rest are fake sections that shouldn't be written. */
5864 if (p
->p_type
== PT_LOAD
)
5866 this_hdr
->sh_offset
= sec
->filepos
= off
;
5867 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5868 off
+= this_hdr
->sh_size
;
5870 else if (this_hdr
->sh_type
== SHT_NOBITS
5871 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5872 && this_hdr
->sh_offset
== 0)
5874 /* This is a .tbss section that didn't get a PT_LOAD.
5875 (See _bfd_elf_map_sections_to_segments "Create a
5876 final PT_LOAD".) Set sh_offset to the value it
5877 would have if we had created a zero p_filesz and
5878 p_memsz PT_LOAD header for the section. This
5879 also makes the PT_TLS header have the same
5881 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5883 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5886 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5888 p
->p_filesz
+= this_hdr
->sh_size
;
5889 /* A load section without SHF_ALLOC is something like
5890 a note section in a PT_NOTE segment. These take
5891 file space but are not loaded into memory. */
5892 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5893 p
->p_memsz
+= this_hdr
->sh_size
;
5895 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5897 if (p
->p_type
== PT_TLS
)
5898 p
->p_memsz
+= this_hdr
->sh_size
;
5900 /* .tbss is special. It doesn't contribute to p_memsz of
5902 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5903 p
->p_memsz
+= this_hdr
->sh_size
;
5906 if (align
> p
->p_align
5907 && !m
->p_align_valid
5908 && (p
->p_type
!= PT_LOAD
5909 || (abfd
->flags
& D_PAGED
) == 0))
5913 if (!m
->p_flags_valid
)
5916 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5918 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5925 /* PR ld/20815 - Check that the program header segment, if
5926 present, will be loaded into memory. */
5927 if (p
->p_type
== PT_PHDR
5928 && phdr_load_seg
== NULL
5929 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5930 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5932 /* The fix for this error is usually to edit the linker script being
5933 used and set up the program headers manually. Either that or
5934 leave room for the headers at the start of the SECTIONS. */
5935 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5936 " by LOAD segment"),
5938 if (link_info
== NULL
)
5940 /* Arrange for the linker to exit with an error, deleting
5941 the output file unless --noinhibit-exec is given. */
5942 link_info
->callbacks
->info ("%X");
5945 /* Check that all sections are in a PT_LOAD segment.
5946 Don't check funky gdb generated core files. */
5947 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5949 bool check_vma
= true;
5951 for (i
= 1; i
< m
->count
; i
++)
5952 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5953 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5954 ->this_hdr
), p
) != 0
5955 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5956 ->this_hdr
), p
) != 0)
5958 /* Looks like we have overlays packed into the segment. */
5963 for (i
= 0; i
< m
->count
; i
++)
5965 Elf_Internal_Shdr
*this_hdr
;
5968 sec
= m
->sections
[i
];
5969 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5970 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5971 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5974 /* xgettext:c-format */
5975 (_("%pB: section `%pA' can't be allocated in segment %d"),
5977 print_segment_map (m
);
5983 elf_next_file_pos (abfd
) = off
;
5985 if (link_info
!= NULL
5986 && phdr_load_seg
!= NULL
5987 && phdr_load_seg
->includes_filehdr
)
5989 /* There is a segment that contains both the file headers and the
5990 program headers, so provide a symbol __ehdr_start pointing there.
5991 A program can use this to examine itself robustly. */
5993 struct elf_link_hash_entry
*hash
5994 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5995 false, false, true);
5996 /* If the symbol was referenced and not defined, define it. */
5998 && (hash
->root
.type
== bfd_link_hash_new
5999 || hash
->root
.type
== bfd_link_hash_undefined
6000 || hash
->root
.type
== bfd_link_hash_undefweak
6001 || hash
->root
.type
== bfd_link_hash_common
))
6004 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
/ opb
;
6006 if (phdr_load_seg
->count
!= 0)
6007 /* The segment contains sections, so use the first one. */
6008 s
= phdr_load_seg
->sections
[0];
6010 /* Use the first (i.e. lowest-addressed) section in any segment. */
6011 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6012 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6020 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6021 hash
->root
.u
.def
.section
= s
;
6025 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6026 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6029 hash
->root
.type
= bfd_link_hash_defined
;
6030 hash
->def_regular
= 1;
6038 /* Determine if a bfd is a debuginfo file. Unfortunately there
6039 is no defined method for detecting such files, so we have to
6040 use heuristics instead. */
6043 is_debuginfo_file (bfd
*abfd
)
6045 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6048 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6049 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6050 Elf_Internal_Shdr
**headerp
;
6052 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6054 Elf_Internal_Shdr
*header
= * headerp
;
6056 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6057 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6058 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6059 && header
->sh_type
!= SHT_NOBITS
6060 && header
->sh_type
!= SHT_NOTE
)
6067 /* Assign file positions for the other sections, except for compressed debugging
6068 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6071 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6072 struct bfd_link_info
*link_info
)
6074 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6075 Elf_Internal_Shdr
**i_shdrpp
;
6076 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6077 Elf_Internal_Phdr
*phdrs
;
6078 Elf_Internal_Phdr
*p
;
6079 struct elf_segment_map
*m
;
6081 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
6082 bfd_vma maxpagesize
;
6084 if (link_info
!= NULL
)
6085 maxpagesize
= link_info
->maxpagesize
;
6087 maxpagesize
= bed
->maxpagesize
;
6088 i_shdrpp
= elf_elfsections (abfd
);
6089 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6090 off
= elf_next_file_pos (abfd
);
6091 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6093 Elf_Internal_Shdr
*hdr
;
6096 if (hdr
->bfd_section
!= NULL
6097 && (hdr
->bfd_section
->filepos
!= 0
6098 || (hdr
->sh_type
== SHT_NOBITS
6099 && hdr
->contents
== NULL
)))
6100 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6101 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6103 if (hdr
->sh_size
!= 0
6104 /* PR 24717 - debuginfo files are known to be not strictly
6105 compliant with the ELF standard. In particular they often
6106 have .note.gnu.property sections that are outside of any
6107 loadable segment. This is not a problem for such files,
6108 so do not warn about them. */
6109 && ! is_debuginfo_file (abfd
))
6111 /* xgettext:c-format */
6112 (_("%pB: warning: allocated section `%s' not in segment"),
6114 (hdr
->bfd_section
== NULL
6116 : hdr
->bfd_section
->name
));
6117 /* We don't need to page align empty sections. */
6118 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6119 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6122 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6124 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6127 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6128 && hdr
->bfd_section
== NULL
)
6129 /* We don't know the offset of these sections yet: their size has
6130 not been decided. */
6131 || (hdr
->bfd_section
!= NULL
6132 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6133 || (bfd_section_is_ctf (hdr
->bfd_section
)
6134 && abfd
->is_linker_output
)))
6135 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6136 || (elf_symtab_shndx_list (abfd
) != NULL
6137 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6138 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6139 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6140 hdr
->sh_offset
= -1;
6142 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6144 elf_next_file_pos (abfd
) = off
;
6146 /* Now that we have set the section file positions, we can set up
6147 the file positions for the non PT_LOAD segments. */
6148 phdrs
= elf_tdata (abfd
)->phdr
;
6149 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6151 if (p
->p_type
== PT_GNU_RELRO
)
6153 bfd_vma start
, end
; /* Bytes. */
6156 if (link_info
!= NULL
)
6158 /* During linking the range of the RELRO segment is passed
6159 in link_info. Note that there may be padding between
6160 relro_start and the first RELRO section. */
6161 start
= link_info
->relro_start
;
6162 end
= link_info
->relro_end
;
6164 else if (m
->count
!= 0)
6166 if (!m
->p_size_valid
)
6168 start
= m
->sections
[0]->vma
;
6169 end
= start
+ m
->p_size
/ opb
;
6180 struct elf_segment_map
*lm
;
6181 const Elf_Internal_Phdr
*lp
;
6184 /* Find a LOAD segment containing a section in the RELRO
6186 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6188 lm
= lm
->next
, lp
++)
6190 if (lp
->p_type
== PT_LOAD
6192 && (lm
->sections
[lm
->count
- 1]->vma
6193 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6194 ? lm
->sections
[lm
->count
- 1]->size
/ opb
6196 && lm
->sections
[0]->vma
< end
)
6202 /* Find the section starting the RELRO segment. */
6203 for (i
= 0; i
< lm
->count
; i
++)
6205 asection
*s
= lm
->sections
[i
];
6214 p
->p_vaddr
= lm
->sections
[i
]->vma
* opb
;
6215 p
->p_paddr
= lm
->sections
[i
]->lma
* opb
;
6216 p
->p_offset
= lm
->sections
[i
]->filepos
;
6217 p
->p_memsz
= end
* opb
- p
->p_vaddr
;
6218 p
->p_filesz
= p
->p_memsz
;
6220 /* The RELRO segment typically ends a few bytes
6221 into .got.plt but other layouts are possible.
6222 In cases where the end does not match any
6223 loaded section (for instance is in file
6224 padding), trim p_filesz back to correspond to
6225 the end of loaded section contents. */
6226 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6227 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6229 /* Preserve the alignment and flags if they are
6230 valid. The gold linker generates RW/4 for
6231 the PT_GNU_RELRO section. It is better for
6232 objcopy/strip to honor these attributes
6233 otherwise gdb will choke when using separate
6235 if (!m
->p_align_valid
)
6237 if (!m
->p_flags_valid
)
6246 if (link_info
!= NULL
)
6248 (_("%pB: warning: unable to allocate any sections to PT_GNU_RELRO segment"),
6250 memset (p
, 0, sizeof *p
);
6253 else if (p
->p_type
== PT_GNU_STACK
)
6255 if (m
->p_size_valid
)
6256 p
->p_memsz
= m
->p_size
;
6258 else if (m
->count
!= 0)
6262 if (p
->p_type
!= PT_LOAD
6263 && (p
->p_type
!= PT_NOTE
6264 || bfd_get_format (abfd
) != bfd_core
))
6266 /* A user specified segment layout may include a PHDR
6267 segment that overlaps with a LOAD segment... */
6268 if (p
->p_type
== PT_PHDR
)
6274 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6276 /* PR 17512: file: 2195325e. */
6278 (_("%pB: error: non-load segment %d includes file header "
6279 "and/or program header"),
6280 abfd
, (int) (p
- phdrs
));
6285 p
->p_offset
= m
->sections
[0]->filepos
;
6286 for (i
= m
->count
; i
-- != 0;)
6288 asection
*sect
= m
->sections
[i
];
6289 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6290 if (hdr
->sh_type
!= SHT_NOBITS
)
6292 p
->p_filesz
= sect
->filepos
- p
->p_offset
+ hdr
->sh_size
;
6293 /* NB: p_memsz of the loadable PT_NOTE segment
6294 should be the same as p_filesz. */
6295 if (p
->p_type
== PT_NOTE
6296 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
6297 p
->p_memsz
= p
->p_filesz
;
6308 static elf_section_list
*
6309 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6311 for (;list
!= NULL
; list
= list
->next
)
6317 /* Work out the file positions of all the sections. This is called by
6318 _bfd_elf_compute_section_file_positions. All the section sizes and
6319 VMAs must be known before this is called.
6321 Reloc sections come in two flavours: Those processed specially as
6322 "side-channel" data attached to a section to which they apply, and those that
6323 bfd doesn't process as relocations. The latter sort are stored in a normal
6324 bfd section by bfd_section_from_shdr. We don't consider the former sort
6325 here, unless they form part of the loadable image. Reloc sections not
6326 assigned here (and compressed debugging sections and CTF sections which
6327 nothing else in the file can rely upon) will be handled later by
6328 assign_file_positions_for_relocs.
6330 We also don't set the positions of the .symtab and .strtab here. */
6333 assign_file_positions_except_relocs (bfd
*abfd
,
6334 struct bfd_link_info
*link_info
)
6336 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6337 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6338 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6341 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6342 && bfd_get_format (abfd
) != bfd_core
)
6344 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6345 unsigned int num_sec
= elf_numsections (abfd
);
6346 Elf_Internal_Shdr
**hdrpp
;
6350 /* Start after the ELF header. */
6351 off
= i_ehdrp
->e_ehsize
;
6353 /* We are not creating an executable, which means that we are
6354 not creating a program header, and that the actual order of
6355 the sections in the file is unimportant. */
6356 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6358 Elf_Internal_Shdr
*hdr
;
6361 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6362 && hdr
->bfd_section
== NULL
)
6363 /* Do not assign offsets for these sections yet: we don't know
6365 || (hdr
->bfd_section
!= NULL
6366 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6367 || (bfd_section_is_ctf (hdr
->bfd_section
)
6368 && abfd
->is_linker_output
)))
6369 || i
== elf_onesymtab (abfd
)
6370 || (elf_symtab_shndx_list (abfd
) != NULL
6371 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6372 || i
== elf_strtab_sec (abfd
)
6373 || i
== elf_shstrtab_sec (abfd
))
6375 hdr
->sh_offset
= -1;
6378 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6381 elf_next_file_pos (abfd
) = off
;
6382 elf_program_header_size (abfd
) = 0;
6386 /* Assign file positions for the loaded sections based on the
6387 assignment of sections to segments. */
6388 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6391 /* And for non-load sections. */
6392 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6396 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6399 /* Write out the program headers. */
6400 alloc
= i_ehdrp
->e_phnum
;
6403 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6404 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6412 _bfd_elf_init_file_header (bfd
*abfd
,
6413 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6415 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6416 struct elf_strtab_hash
*shstrtab
;
6417 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6419 i_ehdrp
= elf_elfheader (abfd
);
6421 shstrtab
= _bfd_elf_strtab_init ();
6422 if (shstrtab
== NULL
)
6425 elf_shstrtab (abfd
) = shstrtab
;
6427 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6428 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6429 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6430 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6432 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6433 i_ehdrp
->e_ident
[EI_DATA
] =
6434 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6435 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6437 if ((abfd
->flags
& DYNAMIC
) != 0)
6438 i_ehdrp
->e_type
= ET_DYN
;
6439 else if ((abfd
->flags
& EXEC_P
) != 0)
6440 i_ehdrp
->e_type
= ET_EXEC
;
6441 else if (bfd_get_format (abfd
) == bfd_core
)
6442 i_ehdrp
->e_type
= ET_CORE
;
6444 i_ehdrp
->e_type
= ET_REL
;
6446 switch (bfd_get_arch (abfd
))
6448 case bfd_arch_unknown
:
6449 i_ehdrp
->e_machine
= EM_NONE
;
6452 /* There used to be a long list of cases here, each one setting
6453 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6454 in the corresponding bfd definition. To avoid duplication,
6455 the switch was removed. Machines that need special handling
6456 can generally do it in elf_backend_final_write_processing(),
6457 unless they need the information earlier than the final write.
6458 Such need can generally be supplied by replacing the tests for
6459 e_machine with the conditions used to determine it. */
6461 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6464 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6465 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6467 /* No program header, for now. */
6468 i_ehdrp
->e_phoff
= 0;
6469 i_ehdrp
->e_phentsize
= 0;
6470 i_ehdrp
->e_phnum
= 0;
6472 /* Each bfd section is section header entry. */
6473 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6474 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6476 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6477 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
6478 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6479 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
6480 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6481 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
6482 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6483 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6484 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6490 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6492 FIXME: We used to have code here to sort the PT_LOAD segments into
6493 ascending order, as per the ELF spec. But this breaks some programs,
6494 including the Linux kernel. But really either the spec should be
6495 changed or the programs updated. */
6498 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6500 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6502 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6503 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6504 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6505 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6506 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6508 /* Find the lowest p_vaddr in PT_LOAD segments. */
6509 bfd_vma p_vaddr
= (bfd_vma
) -1;
6510 for (; segment
< end_segment
; segment
++)
6511 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6512 p_vaddr
= segment
->p_vaddr
;
6514 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6515 segments is non-zero. */
6517 i_ehdrp
->e_type
= ET_EXEC
;
6522 /* Assign file positions for all the reloc sections which are not part
6523 of the loadable file image, and the file position of section headers. */
6526 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6529 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6530 Elf_Internal_Shdr
*shdrp
;
6531 Elf_Internal_Ehdr
*i_ehdrp
;
6532 const struct elf_backend_data
*bed
;
6534 off
= elf_next_file_pos (abfd
);
6536 shdrpp
= elf_elfsections (abfd
);
6537 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6538 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6541 if (shdrp
->sh_offset
== -1)
6543 asection
*sec
= shdrp
->bfd_section
;
6544 bool is_rel
= (shdrp
->sh_type
== SHT_REL
6545 || shdrp
->sh_type
== SHT_RELA
);
6546 bool is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6549 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6551 if (!is_rel
&& !is_ctf
)
6553 const char *name
= sec
->name
;
6554 struct bfd_elf_section_data
*d
;
6556 /* Compress DWARF debug sections. */
6557 if (!bfd_compress_section (abfd
, sec
,
6561 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6562 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6564 /* If section is compressed with zlib-gnu, convert
6565 section name from .debug_* to .zdebug_*. */
6567 = convert_debug_to_zdebug (abfd
, name
);
6568 if (new_name
== NULL
)
6572 /* Add section name to section name section. */
6573 if (shdrp
->sh_name
!= (unsigned int) -1)
6576 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6578 d
= elf_section_data (sec
);
6580 /* Add reloc section name to section name section. */
6582 && !_bfd_elf_set_reloc_sh_name (abfd
,
6587 && !_bfd_elf_set_reloc_sh_name (abfd
,
6592 /* Update section size and contents. */
6593 shdrp
->sh_size
= sec
->size
;
6594 shdrp
->contents
= sec
->contents
;
6595 shdrp
->bfd_section
->contents
= NULL
;
6599 /* Update section size and contents. */
6600 shdrp
->sh_size
= sec
->size
;
6601 shdrp
->contents
= sec
->contents
;
6604 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6611 /* Place section name section after DWARF debug sections have been
6613 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6614 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6615 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6616 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
6618 /* Place the section headers. */
6619 i_ehdrp
= elf_elfheader (abfd
);
6620 bed
= get_elf_backend_data (abfd
);
6621 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6622 i_ehdrp
->e_shoff
= off
;
6623 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6624 elf_next_file_pos (abfd
) = off
;
6630 _bfd_elf_write_object_contents (bfd
*abfd
)
6632 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6633 Elf_Internal_Shdr
**i_shdrp
;
6635 unsigned int count
, num_sec
;
6636 struct elf_obj_tdata
*t
;
6638 if (! abfd
->output_has_begun
6639 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6641 /* Do not rewrite ELF data when the BFD has been opened for update.
6642 abfd->output_has_begun was set to TRUE on opening, so creation of new
6643 sections, and modification of existing section sizes was restricted.
6644 This means the ELF header, program headers and section headers can't have
6646 If the contents of any sections has been modified, then those changes have
6647 already been written to the BFD. */
6648 else if (abfd
->direction
== both_direction
)
6650 BFD_ASSERT (abfd
->output_has_begun
);
6654 i_shdrp
= elf_elfsections (abfd
);
6657 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6661 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6664 /* After writing the headers, we need to write the sections too... */
6665 num_sec
= elf_numsections (abfd
);
6666 for (count
= 1; count
< num_sec
; count
++)
6668 i_shdrp
[count
]->sh_name
6669 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6670 i_shdrp
[count
]->sh_name
);
6671 if (bed
->elf_backend_section_processing
)
6672 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6674 if (i_shdrp
[count
]->contents
)
6676 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6678 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6679 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6684 /* Write out the section header names. */
6685 t
= elf_tdata (abfd
);
6686 if (elf_shstrtab (abfd
) != NULL
6687 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6688 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6691 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6694 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6697 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6698 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6699 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6705 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6707 /* Hopefully this can be done just like an object file. */
6708 return _bfd_elf_write_object_contents (abfd
);
6711 /* Given a section, search the header to find them. */
6714 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6716 const struct elf_backend_data
*bed
;
6717 unsigned int sec_index
;
6719 if (elf_section_data (asect
) != NULL
6720 && elf_section_data (asect
)->this_idx
!= 0)
6721 return elf_section_data (asect
)->this_idx
;
6723 if (bfd_is_abs_section (asect
))
6724 sec_index
= SHN_ABS
;
6725 else if (bfd_is_com_section (asect
))
6726 sec_index
= SHN_COMMON
;
6727 else if (bfd_is_und_section (asect
))
6728 sec_index
= SHN_UNDEF
;
6730 sec_index
= SHN_BAD
;
6732 bed
= get_elf_backend_data (abfd
);
6733 if (bed
->elf_backend_section_from_bfd_section
)
6735 int retval
= sec_index
;
6737 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6741 if (sec_index
== SHN_BAD
)
6742 bfd_set_error (bfd_error_nonrepresentable_section
);
6747 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6751 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6753 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6755 flagword flags
= asym_ptr
->flags
;
6757 /* When gas creates relocations against local labels, it creates its
6758 own symbol for the section, but does put the symbol into the
6759 symbol chain, so udata is 0. When the linker is generating
6760 relocatable output, this section symbol may be for one of the
6761 input sections rather than the output section. */
6762 if (asym_ptr
->udata
.i
== 0
6763 && (flags
& BSF_SECTION_SYM
)
6764 && asym_ptr
->section
)
6768 sec
= asym_ptr
->section
;
6769 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6770 sec
= sec
->output_section
;
6771 if (sec
->owner
== abfd
6772 && sec
->index
< elf_num_section_syms (abfd
)
6773 && elf_section_syms (abfd
)[sec
->index
] != NULL
)
6774 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
6777 idx
= asym_ptr
->udata
.i
;
6781 /* This case can occur when using --strip-symbol on a symbol
6782 which is used in a relocation entry. */
6784 /* xgettext:c-format */
6785 (_("%pB: symbol `%s' required but not present"),
6786 abfd
, bfd_asymbol_name (asym_ptr
));
6787 bfd_set_error (bfd_error_no_symbols
);
6794 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6795 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6803 /* Rewrite program header information. */
6806 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
, bfd_vma maxpagesize
)
6808 Elf_Internal_Ehdr
*iehdr
;
6809 struct elf_segment_map
*map
;
6810 struct elf_segment_map
*map_first
;
6811 struct elf_segment_map
**pointer_to_map
;
6812 Elf_Internal_Phdr
*segment
;
6815 unsigned int num_segments
;
6816 bool phdr_included
= false;
6818 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6819 unsigned int phdr_adjust_num
= 0;
6820 const struct elf_backend_data
*bed
;
6821 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
6823 bed
= get_elf_backend_data (ibfd
);
6824 iehdr
= elf_elfheader (ibfd
);
6827 pointer_to_map
= &map_first
;
6829 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6831 /* Returns the end address of the segment + 1. */
6832 #define SEGMENT_END(segment, start) \
6833 (start + (segment->p_memsz > segment->p_filesz \
6834 ? segment->p_memsz : segment->p_filesz))
6836 #define SECTION_SIZE(section, segment) \
6837 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6838 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6839 ? section->size : 0)
6841 /* Returns TRUE if the given section is contained within
6842 the given segment. VMA addresses are compared. */
6843 #define IS_CONTAINED_BY_VMA(section, segment, opb) \
6844 (section->vma * (opb) >= segment->p_vaddr \
6845 && (section->vma * (opb) + SECTION_SIZE (section, segment) \
6846 <= (SEGMENT_END (segment, segment->p_vaddr))))
6848 /* Returns TRUE if the given section is contained within
6849 the given segment. LMA addresses are compared. */
6850 #define IS_CONTAINED_BY_LMA(section, segment, base, opb) \
6851 (section->lma * (opb) >= base \
6852 && (section->lma + SECTION_SIZE (section, segment) / (opb) >= section->lma) \
6853 && (section->lma * (opb) + SECTION_SIZE (section, segment) \
6854 <= SEGMENT_END (segment, base)))
6856 /* Handle PT_NOTE segment. */
6857 #define IS_NOTE(p, s) \
6858 (p->p_type == PT_NOTE \
6859 && elf_section_type (s) == SHT_NOTE \
6860 && (bfd_vma) s->filepos >= p->p_offset \
6861 && ((bfd_vma) s->filepos + s->size \
6862 <= p->p_offset + p->p_filesz))
6864 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6866 #define IS_COREFILE_NOTE(p, s) \
6868 && bfd_get_format (ibfd) == bfd_core \
6872 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6873 linker, which generates a PT_INTERP section with p_vaddr and
6874 p_memsz set to 0. */
6875 #define IS_SOLARIS_PT_INTERP(p, s) \
6877 && p->p_paddr == 0 \
6878 && p->p_memsz == 0 \
6879 && p->p_filesz > 0 \
6880 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6882 && (bfd_vma) s->filepos >= p->p_offset \
6883 && ((bfd_vma) s->filepos + s->size \
6884 <= p->p_offset + p->p_filesz))
6886 /* Decide if the given section should be included in the given segment.
6887 A section will be included if:
6888 1. It is within the address space of the segment -- we use the LMA
6889 if that is set for the segment and the VMA otherwise,
6890 2. It is an allocated section or a NOTE section in a PT_NOTE
6892 3. There is an output section associated with it,
6893 4. The section has not already been allocated to a previous segment.
6894 5. PT_GNU_STACK segments do not include any sections.
6895 6. PT_TLS segment includes only SHF_TLS sections.
6896 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6897 8. PT_DYNAMIC should not contain empty sections at the beginning
6898 (with the possible exception of .dynamic). */
6899 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed, opb) \
6900 ((((segment->p_paddr \
6901 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr, opb) \
6902 : IS_CONTAINED_BY_VMA (section, segment, opb)) \
6903 && (section->flags & SEC_ALLOC) != 0) \
6904 || IS_NOTE (segment, section)) \
6905 && segment->p_type != PT_GNU_STACK \
6906 && (segment->p_type != PT_TLS \
6907 || (section->flags & SEC_THREAD_LOCAL)) \
6908 && (segment->p_type == PT_LOAD \
6909 || segment->p_type == PT_TLS \
6910 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6911 && (segment->p_type != PT_DYNAMIC \
6912 || SECTION_SIZE (section, segment) > 0 \
6913 || (segment->p_paddr \
6914 ? segment->p_paddr != section->lma * (opb) \
6915 : segment->p_vaddr != section->vma * (opb)) \
6916 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6917 && (segment->p_type != PT_LOAD || !section->segment_mark))
6919 /* If the output section of a section in the input segment is NULL,
6920 it is removed from the corresponding output segment. */
6921 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed, opb) \
6922 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed, opb) \
6923 && section->output_section != NULL)
6925 /* Returns TRUE iff seg1 starts after the end of seg2. */
6926 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6927 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6929 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6930 their VMA address ranges and their LMA address ranges overlap.
6931 It is possible to have overlapping VMA ranges without overlapping LMA
6932 ranges. RedBoot images for example can have both .data and .bss mapped
6933 to the same VMA range, but with the .data section mapped to a different
6935 #define SEGMENT_OVERLAPS(seg1, seg2) \
6936 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6937 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6938 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6939 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6941 /* Initialise the segment mark field, and discard stupid alignment. */
6942 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6944 asection
*o
= section
->output_section
;
6945 if (o
!= NULL
&& o
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
6946 o
->alignment_power
= 0;
6947 section
->segment_mark
= false;
6950 /* The Solaris linker creates program headers in which all the
6951 p_paddr fields are zero. When we try to objcopy or strip such a
6952 file, we get confused. Check for this case, and if we find it
6953 don't set the p_paddr_valid fields. */
6954 p_paddr_valid
= false;
6955 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6958 if (segment
->p_paddr
!= 0)
6960 p_paddr_valid
= true;
6964 /* Scan through the segments specified in the program header
6965 of the input BFD. For this first scan we look for overlaps
6966 in the loadable segments. These can be created by weird
6967 parameters to objcopy. Also, fix some solaris weirdness. */
6968 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6973 Elf_Internal_Phdr
*segment2
;
6975 if (segment
->p_type
== PT_INTERP
)
6976 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6977 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6979 /* Mininal change so that the normal section to segment
6980 assignment code will work. */
6981 segment
->p_vaddr
= section
->vma
* opb
;
6985 if (segment
->p_type
!= PT_LOAD
)
6987 /* Remove PT_GNU_RELRO segment. */
6988 if (segment
->p_type
== PT_GNU_RELRO
)
6989 segment
->p_type
= PT_NULL
;
6993 /* Determine if this segment overlaps any previous segments. */
6994 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6996 bfd_signed_vma extra_length
;
6998 if (segment2
->p_type
!= PT_LOAD
6999 || !SEGMENT_OVERLAPS (segment
, segment2
))
7002 /* Merge the two segments together. */
7003 if (segment2
->p_vaddr
< segment
->p_vaddr
)
7005 /* Extend SEGMENT2 to include SEGMENT and then delete
7007 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
7008 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
7010 if (extra_length
> 0)
7012 segment2
->p_memsz
+= extra_length
;
7013 segment2
->p_filesz
+= extra_length
;
7016 segment
->p_type
= PT_NULL
;
7018 /* Since we have deleted P we must restart the outer loop. */
7020 segment
= elf_tdata (ibfd
)->phdr
;
7025 /* Extend SEGMENT to include SEGMENT2 and then delete
7027 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7028 - SEGMENT_END (segment
, segment
->p_vaddr
));
7030 if (extra_length
> 0)
7032 segment
->p_memsz
+= extra_length
;
7033 segment
->p_filesz
+= extra_length
;
7036 segment2
->p_type
= PT_NULL
;
7041 /* The second scan attempts to assign sections to segments. */
7042 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7046 unsigned int section_count
;
7047 asection
**sections
;
7048 asection
*output_section
;
7050 asection
*matching_lma
;
7051 asection
*suggested_lma
;
7054 asection
*first_section
;
7056 if (segment
->p_type
== PT_NULL
)
7059 first_section
= NULL
;
7060 /* Compute how many sections might be placed into this segment. */
7061 for (section
= ibfd
->sections
, section_count
= 0;
7063 section
= section
->next
)
7065 /* Find the first section in the input segment, which may be
7066 removed from the corresponding output segment. */
7067 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
, opb
))
7069 if (first_section
== NULL
)
7070 first_section
= section
;
7071 if (section
->output_section
!= NULL
)
7076 /* Allocate a segment map big enough to contain
7077 all of the sections we have selected. */
7078 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7079 amt
+= section_count
* sizeof (asection
*);
7080 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7084 /* Initialise the fields of the segment map. Default to
7085 using the physical address of the segment in the input BFD. */
7087 map
->p_type
= segment
->p_type
;
7088 map
->p_flags
= segment
->p_flags
;
7089 map
->p_flags_valid
= 1;
7091 if (map
->p_type
== PT_LOAD
7092 && (ibfd
->flags
& D_PAGED
) != 0
7094 && segment
->p_align
> 1)
7096 map
->p_align
= segment
->p_align
;
7097 if (segment
->p_align
> maxpagesize
)
7098 map
->p_align
= maxpagesize
;
7099 map
->p_align_valid
= 1;
7102 /* If the first section in the input segment is removed, there is
7103 no need to preserve segment physical address in the corresponding
7105 if (!first_section
|| first_section
->output_section
!= NULL
)
7107 map
->p_paddr
= segment
->p_paddr
;
7108 map
->p_paddr_valid
= p_paddr_valid
;
7111 /* Determine if this segment contains the ELF file header
7112 and if it contains the program headers themselves. */
7113 map
->includes_filehdr
= (segment
->p_offset
== 0
7114 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7115 map
->includes_phdrs
= 0;
7117 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7119 map
->includes_phdrs
=
7120 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7121 && (segment
->p_offset
+ segment
->p_filesz
7122 >= ((bfd_vma
) iehdr
->e_phoff
7123 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7125 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7126 phdr_included
= true;
7129 if (section_count
== 0)
7131 /* Special segments, such as the PT_PHDR segment, may contain
7132 no sections, but ordinary, loadable segments should contain
7133 something. They are allowed by the ELF spec however, so only
7134 a warning is produced.
7135 There is however the valid use case of embedded systems which
7136 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7137 flash memory with zeros. No warning is shown for that case. */
7138 if (segment
->p_type
== PT_LOAD
7139 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7140 /* xgettext:c-format */
7142 (_("%pB: warning: empty loadable segment detected"
7143 " at vaddr=%#" PRIx64
", is this intentional?"),
7144 ibfd
, (uint64_t) segment
->p_vaddr
);
7146 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7148 *pointer_to_map
= map
;
7149 pointer_to_map
= &map
->next
;
7154 /* Now scan the sections in the input BFD again and attempt
7155 to add their corresponding output sections to the segment map.
7156 The problem here is how to handle an output section which has
7157 been moved (ie had its LMA changed). There are four possibilities:
7159 1. None of the sections have been moved.
7160 In this case we can continue to use the segment LMA from the
7163 2. All of the sections have been moved by the same amount.
7164 In this case we can change the segment's LMA to match the LMA
7165 of the first section.
7167 3. Some of the sections have been moved, others have not.
7168 In this case those sections which have not been moved can be
7169 placed in the current segment which will have to have its size,
7170 and possibly its LMA changed, and a new segment or segments will
7171 have to be created to contain the other sections.
7173 4. The sections have been moved, but not by the same amount.
7174 In this case we can change the segment's LMA to match the LMA
7175 of the first section and we will have to create a new segment
7176 or segments to contain the other sections.
7178 In order to save time, we allocate an array to hold the section
7179 pointers that we are interested in. As these sections get assigned
7180 to a segment, they are removed from this array. */
7182 amt
= section_count
* sizeof (asection
*);
7183 sections
= (asection
**) bfd_malloc (amt
);
7184 if (sections
== NULL
)
7187 /* Step One: Scan for segment vs section LMA conflicts.
7188 Also add the sections to the section array allocated above.
7189 Also add the sections to the current segment. In the common
7190 case, where the sections have not been moved, this means that
7191 we have completely filled the segment, and there is nothing
7194 matching_lma
= NULL
;
7195 suggested_lma
= NULL
;
7197 for (section
= first_section
, j
= 0;
7199 section
= section
->next
)
7201 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
, opb
))
7203 output_section
= section
->output_section
;
7205 sections
[j
++] = section
;
7207 /* The Solaris native linker always sets p_paddr to 0.
7208 We try to catch that case here, and set it to the
7209 correct value. Note - some backends require that
7210 p_paddr be left as zero. */
7212 && segment
->p_vaddr
!= 0
7213 && !bed
->want_p_paddr_set_to_zero
7215 && output_section
->lma
!= 0
7216 && (align_power (segment
->p_vaddr
7217 + (map
->includes_filehdr
7218 ? iehdr
->e_ehsize
: 0)
7219 + (map
->includes_phdrs
7220 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7222 output_section
->alignment_power
* opb
)
7223 == (output_section
->vma
* opb
)))
7224 map
->p_paddr
= segment
->p_vaddr
;
7226 /* Match up the physical address of the segment with the
7227 LMA address of the output section. */
7228 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7230 || IS_COREFILE_NOTE (segment
, section
)
7231 || (bed
->want_p_paddr_set_to_zero
7232 && IS_CONTAINED_BY_VMA (output_section
, segment
, opb
)))
7234 if (matching_lma
== NULL
7235 || output_section
->lma
< matching_lma
->lma
)
7236 matching_lma
= output_section
;
7238 /* We assume that if the section fits within the segment
7239 then it does not overlap any other section within that
7241 map
->sections
[isec
++] = output_section
;
7243 else if (suggested_lma
== NULL
)
7244 suggested_lma
= output_section
;
7246 if (j
== section_count
)
7251 BFD_ASSERT (j
== section_count
);
7253 /* Step Two: Adjust the physical address of the current segment,
7255 if (isec
== section_count
)
7257 /* All of the sections fitted within the segment as currently
7258 specified. This is the default case. Add the segment to
7259 the list of built segments and carry on to process the next
7260 program header in the input BFD. */
7261 map
->count
= section_count
;
7262 *pointer_to_map
= map
;
7263 pointer_to_map
= &map
->next
;
7266 && !bed
->want_p_paddr_set_to_zero
)
7268 bfd_vma hdr_size
= 0;
7269 if (map
->includes_filehdr
)
7270 hdr_size
= iehdr
->e_ehsize
;
7271 if (map
->includes_phdrs
)
7272 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7274 /* Account for padding before the first section in the
7276 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7277 - matching_lma
->lma
);
7285 /* Change the current segment's physical address to match
7286 the LMA of the first section that fitted, or if no
7287 section fitted, the first section. */
7288 if (matching_lma
== NULL
)
7289 matching_lma
= suggested_lma
;
7291 map
->p_paddr
= matching_lma
->lma
* opb
;
7293 /* Offset the segment physical address from the lma
7294 to allow for space taken up by elf headers. */
7295 if (map
->includes_phdrs
)
7297 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7299 /* iehdr->e_phnum is just an estimate of the number
7300 of program headers that we will need. Make a note
7301 here of the number we used and the segment we chose
7302 to hold these headers, so that we can adjust the
7303 offset when we know the correct value. */
7304 phdr_adjust_num
= iehdr
->e_phnum
;
7305 phdr_adjust_seg
= map
;
7308 if (map
->includes_filehdr
)
7310 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7311 map
->p_paddr
-= iehdr
->e_ehsize
;
7312 /* We've subtracted off the size of headers from the
7313 first section lma, but there may have been some
7314 alignment padding before that section too. Try to
7315 account for that by adjusting the segment lma down to
7316 the same alignment. */
7317 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7318 align
= segment
->p_align
;
7319 map
->p_paddr
&= -(align
* opb
);
7323 /* Step Three: Loop over the sections again, this time assigning
7324 those that fit to the current segment and removing them from the
7325 sections array; but making sure not to leave large gaps. Once all
7326 possible sections have been assigned to the current segment it is
7327 added to the list of built segments and if sections still remain
7328 to be assigned, a new segment is constructed before repeating
7334 suggested_lma
= NULL
;
7336 /* Fill the current segment with sections that fit. */
7337 for (j
= 0; j
< section_count
; j
++)
7339 section
= sections
[j
];
7341 if (section
== NULL
)
7344 output_section
= section
->output_section
;
7346 BFD_ASSERT (output_section
!= NULL
);
7348 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7350 || IS_COREFILE_NOTE (segment
, section
))
7352 if (map
->count
== 0)
7354 /* If the first section in a segment does not start at
7355 the beginning of the segment, then something is
7357 if (align_power (map
->p_paddr
7358 + (map
->includes_filehdr
7359 ? iehdr
->e_ehsize
: 0)
7360 + (map
->includes_phdrs
7361 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7363 output_section
->alignment_power
* opb
)
7364 != output_section
->lma
* opb
)
7371 prev_sec
= map
->sections
[map
->count
- 1];
7373 /* If the gap between the end of the previous section
7374 and the start of this section is more than
7375 maxpagesize then we need to start a new segment. */
7376 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7378 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7379 || (prev_sec
->lma
+ prev_sec
->size
7380 > output_section
->lma
))
7382 if (suggested_lma
== NULL
)
7383 suggested_lma
= output_section
;
7389 map
->sections
[map
->count
++] = output_section
;
7392 if (segment
->p_type
== PT_LOAD
)
7393 section
->segment_mark
= true;
7395 else if (suggested_lma
== NULL
)
7396 suggested_lma
= output_section
;
7399 /* PR 23932. A corrupt input file may contain sections that cannot
7400 be assigned to any segment - because for example they have a
7401 negative size - or segments that do not contain any sections.
7402 But there are also valid reasons why a segment can be empty.
7403 So allow a count of zero. */
7405 /* Add the current segment to the list of built segments. */
7406 *pointer_to_map
= map
;
7407 pointer_to_map
= &map
->next
;
7409 if (isec
< section_count
)
7411 /* We still have not allocated all of the sections to
7412 segments. Create a new segment here, initialise it
7413 and carry on looping. */
7414 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7415 amt
+= section_count
* sizeof (asection
*);
7416 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7423 /* Initialise the fields of the segment map. Set the physical
7424 physical address to the LMA of the first section that has
7425 not yet been assigned. */
7427 map
->p_type
= segment
->p_type
;
7428 map
->p_flags
= segment
->p_flags
;
7429 map
->p_flags_valid
= 1;
7430 map
->p_paddr
= suggested_lma
->lma
* opb
;
7431 map
->p_paddr_valid
= p_paddr_valid
;
7432 map
->includes_filehdr
= 0;
7433 map
->includes_phdrs
= 0;
7438 bfd_set_error (bfd_error_sorry
);
7442 while (isec
< section_count
);
7447 elf_seg_map (obfd
) = map_first
;
7449 /* If we had to estimate the number of program headers that were
7450 going to be needed, then check our estimate now and adjust
7451 the offset if necessary. */
7452 if (phdr_adjust_seg
!= NULL
)
7456 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7459 if (count
> phdr_adjust_num
)
7460 phdr_adjust_seg
->p_paddr
7461 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7463 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7464 if (map
->p_type
== PT_PHDR
)
7467 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7468 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7475 #undef IS_CONTAINED_BY_VMA
7476 #undef IS_CONTAINED_BY_LMA
7478 #undef IS_COREFILE_NOTE
7479 #undef IS_SOLARIS_PT_INTERP
7480 #undef IS_SECTION_IN_INPUT_SEGMENT
7481 #undef INCLUDE_SECTION_IN_SEGMENT
7482 #undef SEGMENT_AFTER_SEGMENT
7483 #undef SEGMENT_OVERLAPS
7487 /* Copy ELF program header information. */
7490 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7492 Elf_Internal_Ehdr
*iehdr
;
7493 struct elf_segment_map
*map
;
7494 struct elf_segment_map
*map_first
;
7495 struct elf_segment_map
**pointer_to_map
;
7496 Elf_Internal_Phdr
*segment
;
7498 unsigned int num_segments
;
7499 bool phdr_included
= false;
7501 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
7503 iehdr
= elf_elfheader (ibfd
);
7506 pointer_to_map
= &map_first
;
7508 /* If all the segment p_paddr fields are zero, don't set
7509 map->p_paddr_valid. */
7510 p_paddr_valid
= false;
7511 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7512 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7515 if (segment
->p_paddr
!= 0)
7517 p_paddr_valid
= true;
7521 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7526 unsigned int section_count
;
7528 Elf_Internal_Shdr
*this_hdr
;
7529 asection
*first_section
= NULL
;
7530 asection
*lowest_section
;
7532 /* Compute how many sections are in this segment. */
7533 for (section
= ibfd
->sections
, section_count
= 0;
7535 section
= section
->next
)
7537 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7538 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7540 if (first_section
== NULL
)
7541 first_section
= section
;
7546 /* Allocate a segment map big enough to contain
7547 all of the sections we have selected. */
7548 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7549 amt
+= section_count
* sizeof (asection
*);
7550 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7554 /* Initialize the fields of the output segment map with the
7557 map
->p_type
= segment
->p_type
;
7558 map
->p_flags
= segment
->p_flags
;
7559 map
->p_flags_valid
= 1;
7560 map
->p_paddr
= segment
->p_paddr
;
7561 map
->p_paddr_valid
= p_paddr_valid
;
7562 map
->p_align
= segment
->p_align
;
7563 map
->p_align_valid
= 1;
7564 map
->p_vaddr_offset
= 0;
7566 if (map
->p_type
== PT_GNU_RELRO
7567 || map
->p_type
== PT_GNU_STACK
)
7569 /* The PT_GNU_RELRO segment may contain the first a few
7570 bytes in the .got.plt section even if the whole .got.plt
7571 section isn't in the PT_GNU_RELRO segment. We won't
7572 change the size of the PT_GNU_RELRO segment.
7573 Similarly, PT_GNU_STACK size is significant on uclinux
7575 map
->p_size
= segment
->p_memsz
;
7576 map
->p_size_valid
= 1;
7579 /* Determine if this segment contains the ELF file header
7580 and if it contains the program headers themselves. */
7581 map
->includes_filehdr
= (segment
->p_offset
== 0
7582 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7584 map
->includes_phdrs
= 0;
7585 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7587 map
->includes_phdrs
=
7588 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7589 && (segment
->p_offset
+ segment
->p_filesz
7590 >= ((bfd_vma
) iehdr
->e_phoff
7591 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7593 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7594 phdr_included
= true;
7597 lowest_section
= NULL
;
7598 if (section_count
!= 0)
7600 unsigned int isec
= 0;
7602 for (section
= first_section
;
7604 section
= section
->next
)
7606 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7607 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7609 map
->sections
[isec
++] = section
->output_section
;
7610 if ((section
->flags
& SEC_ALLOC
) != 0)
7614 if (lowest_section
== NULL
7615 || section
->lma
< lowest_section
->lma
)
7616 lowest_section
= section
;
7618 /* Section lmas are set up from PT_LOAD header
7619 p_paddr in _bfd_elf_make_section_from_shdr.
7620 If this header has a p_paddr that disagrees
7621 with the section lma, flag the p_paddr as
7623 if ((section
->flags
& SEC_LOAD
) != 0)
7624 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7626 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7627 if (section
->lma
* opb
- segment
->p_paddr
!= seg_off
)
7628 map
->p_paddr_valid
= false;
7630 if (isec
== section_count
)
7636 if (section_count
== 0)
7637 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7638 else if (map
->p_paddr_valid
)
7640 /* Account for padding before the first section in the segment. */
7641 bfd_vma hdr_size
= 0;
7642 if (map
->includes_filehdr
)
7643 hdr_size
= iehdr
->e_ehsize
;
7644 if (map
->includes_phdrs
)
7645 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7647 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7648 - (lowest_section
? lowest_section
->lma
: 0));
7651 map
->count
= section_count
;
7652 *pointer_to_map
= map
;
7653 pointer_to_map
= &map
->next
;
7656 elf_seg_map (obfd
) = map_first
;
7660 /* Copy private BFD data. This copies or rewrites ELF program header
7664 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7666 bfd_vma maxpagesize
;
7668 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7669 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7672 if (elf_tdata (ibfd
)->phdr
== NULL
)
7675 if (ibfd
->xvec
== obfd
->xvec
)
7677 /* Check to see if any sections in the input BFD
7678 covered by ELF program header have changed. */
7679 Elf_Internal_Phdr
*segment
;
7680 asection
*section
, *osec
;
7681 unsigned int i
, num_segments
;
7682 Elf_Internal_Shdr
*this_hdr
;
7683 const struct elf_backend_data
*bed
;
7685 bed
= get_elf_backend_data (ibfd
);
7687 /* Regenerate the segment map if p_paddr is set to 0. */
7688 if (bed
->want_p_paddr_set_to_zero
)
7691 /* Initialize the segment mark field. */
7692 for (section
= obfd
->sections
; section
!= NULL
;
7693 section
= section
->next
)
7694 section
->segment_mark
= false;
7696 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7697 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7701 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7702 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7703 which severly confuses things, so always regenerate the segment
7704 map in this case. */
7705 if (segment
->p_paddr
== 0
7706 && segment
->p_memsz
== 0
7707 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7710 for (section
= ibfd
->sections
;
7711 section
!= NULL
; section
= section
->next
)
7713 /* We mark the output section so that we know it comes
7714 from the input BFD. */
7715 osec
= section
->output_section
;
7717 osec
->segment_mark
= true;
7719 /* Check if this section is covered by the segment. */
7720 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7721 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7723 /* FIXME: Check if its output section is changed or
7724 removed. What else do we need to check? */
7726 || section
->flags
!= osec
->flags
7727 || section
->lma
!= osec
->lma
7728 || section
->vma
!= osec
->vma
7729 || section
->size
!= osec
->size
7730 || section
->rawsize
!= osec
->rawsize
7731 || section
->alignment_power
!= osec
->alignment_power
)
7737 /* Check to see if any output section do not come from the
7739 for (section
= obfd
->sections
; section
!= NULL
;
7740 section
= section
->next
)
7742 if (!section
->segment_mark
)
7745 section
->segment_mark
= false;
7748 return copy_elf_program_header (ibfd
, obfd
);
7753 if (ibfd
->xvec
== obfd
->xvec
)
7755 /* When rewriting program header, set the output maxpagesize to
7756 the maximum alignment of input PT_LOAD segments. */
7757 Elf_Internal_Phdr
*segment
;
7759 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7761 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7764 if (segment
->p_type
== PT_LOAD
7765 && maxpagesize
< segment
->p_align
)
7767 /* PR 17512: file: f17299af. */
7768 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7769 /* xgettext:c-format */
7770 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7771 PRIx64
" is too large"),
7772 ibfd
, (uint64_t) segment
->p_align
);
7774 maxpagesize
= segment
->p_align
;
7777 if (maxpagesize
== 0)
7778 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
7780 return rewrite_elf_program_header (ibfd
, obfd
, maxpagesize
);
7783 /* Initialize private output section information from input section. */
7786 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7790 struct bfd_link_info
*link_info
)
7793 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7794 bool final_link
= (link_info
!= NULL
7795 && !bfd_link_relocatable (link_info
));
7797 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7798 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7801 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7803 /* If this is a known ABI section, ELF section type and flags may
7804 have been set up when OSEC was created. For normal sections we
7805 allow the user to override the type and flags other than
7806 SHF_MASKOS and SHF_MASKPROC. */
7807 if (elf_section_type (osec
) == SHT_PROGBITS
7808 || elf_section_type (osec
) == SHT_NOTE
7809 || elf_section_type (osec
) == SHT_NOBITS
)
7810 elf_section_type (osec
) = SHT_NULL
;
7811 /* For objcopy and relocatable link, copy the ELF section type from
7812 the input file if the BFD section flags are the same. (If they
7813 are different the user may be doing something like
7814 "objcopy --set-section-flags .text=alloc,data".) For a final
7815 link allow some flags that the linker clears to differ. */
7816 if (elf_section_type (osec
) == SHT_NULL
7817 && (osec
->flags
== isec
->flags
7819 && ((osec
->flags
^ isec
->flags
)
7820 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7821 elf_section_type (osec
) = elf_section_type (isec
);
7823 /* FIXME: Is this correct for all OS/PROC specific flags? */
7824 elf_section_flags (osec
) = (elf_section_flags (isec
)
7825 & (SHF_MASKOS
| SHF_MASKPROC
));
7827 /* Copy sh_info from input for mbind section. */
7828 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7829 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7830 elf_section_data (osec
)->this_hdr
.sh_info
7831 = elf_section_data (isec
)->this_hdr
.sh_info
;
7833 /* Set things up for objcopy and relocatable link. The output
7834 SHT_GROUP section will have its elf_next_in_group pointing back
7835 to the input group members. Ignore linker created group section.
7836 See elfNN_ia64_object_p in elfxx-ia64.c. */
7837 if ((link_info
== NULL
7838 || !link_info
->resolve_section_groups
)
7839 && (elf_sec_group (isec
) == NULL
7840 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7842 if (elf_section_flags (isec
) & SHF_GROUP
)
7843 elf_section_flags (osec
) |= SHF_GROUP
;
7844 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7845 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7848 /* If not decompress, preserve SHF_COMPRESSED. */
7849 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7850 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7853 ihdr
= &elf_section_data (isec
)->this_hdr
;
7855 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7856 don't use the output section of the linked-to section since it
7857 may be NULL at this point. */
7858 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7860 ohdr
= &elf_section_data (osec
)->this_hdr
;
7861 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7862 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7865 osec
->use_rela_p
= isec
->use_rela_p
;
7870 /* Copy private section information. This copies over the entsize
7871 field, and sometimes the info field. */
7874 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7879 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7881 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7882 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7885 ihdr
= &elf_section_data (isec
)->this_hdr
;
7886 ohdr
= &elf_section_data (osec
)->this_hdr
;
7888 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7890 if (ihdr
->sh_type
== SHT_SYMTAB
7891 || ihdr
->sh_type
== SHT_DYNSYM
7892 || ihdr
->sh_type
== SHT_GNU_verneed
7893 || ihdr
->sh_type
== SHT_GNU_verdef
)
7894 ohdr
->sh_info
= ihdr
->sh_info
;
7896 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7900 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7901 necessary if we are removing either the SHT_GROUP section or any of
7902 the group member sections. DISCARDED is the value that a section's
7903 output_section has if the section will be discarded, NULL when this
7904 function is called from objcopy, bfd_abs_section_ptr when called
7908 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7912 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7913 if (elf_section_type (isec
) == SHT_GROUP
)
7915 asection
*first
= elf_next_in_group (isec
);
7916 asection
*s
= first
;
7917 bfd_size_type removed
= 0;
7921 /* If this member section is being output but the
7922 SHT_GROUP section is not, then clear the group info
7923 set up by _bfd_elf_copy_private_section_data. */
7924 if (s
->output_section
!= discarded
7925 && isec
->output_section
== discarded
)
7927 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7928 elf_group_name (s
->output_section
) = NULL
;
7932 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7933 if (s
->output_section
== discarded
7934 && isec
->output_section
!= discarded
)
7936 /* Conversely, if the member section is not being
7937 output but the SHT_GROUP section is, then adjust
7940 if (elf_sec
->rel
.hdr
!= NULL
7941 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7943 if (elf_sec
->rela
.hdr
!= NULL
7944 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7949 /* Also adjust for zero-sized relocation member
7951 if (elf_sec
->rel
.hdr
!= NULL
7952 && elf_sec
->rel
.hdr
->sh_size
== 0)
7954 if (elf_sec
->rela
.hdr
!= NULL
7955 && elf_sec
->rela
.hdr
->sh_size
== 0)
7959 s
= elf_next_in_group (s
);
7965 if (discarded
!= NULL
)
7967 /* If we've been called for ld -r, then we need to
7968 adjust the input section size. */
7969 if (isec
->rawsize
== 0)
7970 isec
->rawsize
= isec
->size
;
7971 isec
->size
= isec
->rawsize
- removed
;
7972 if (isec
->size
<= 4)
7975 isec
->flags
|= SEC_EXCLUDE
;
7978 else if (isec
->output_section
!= NULL
)
7980 /* Adjust the output section size when called from
7982 isec
->output_section
->size
-= removed
;
7983 if (isec
->output_section
->size
<= 4)
7985 isec
->output_section
->size
= 0;
7986 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7995 /* Copy private header information. */
7998 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
8000 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8001 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8004 /* Copy over private BFD data if it has not already been copied.
8005 This must be done here, rather than in the copy_private_bfd_data
8006 entry point, because the latter is called after the section
8007 contents have been set, which means that the program headers have
8008 already been worked out. */
8009 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
8011 if (! copy_private_bfd_data (ibfd
, obfd
))
8015 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
8018 /* Copy private symbol information. If this symbol is in a section
8019 which we did not map into a BFD section, try to map the section
8020 index correctly. We use special macro definitions for the mapped
8021 section indices; these definitions are interpreted by the
8022 swap_out_syms function. */
8024 #define MAP_ONESYMTAB (SHN_HIOS + 1)
8025 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
8026 #define MAP_STRTAB (SHN_HIOS + 3)
8027 #define MAP_SHSTRTAB (SHN_HIOS + 4)
8028 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
8031 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
8036 elf_symbol_type
*isym
, *osym
;
8038 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8039 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8042 isym
= elf_symbol_from (isymarg
);
8043 osym
= elf_symbol_from (osymarg
);
8046 && isym
->internal_elf_sym
.st_shndx
!= 0
8048 && bfd_is_abs_section (isym
->symbol
.section
))
8052 shndx
= isym
->internal_elf_sym
.st_shndx
;
8053 if (shndx
== elf_onesymtab (ibfd
))
8054 shndx
= MAP_ONESYMTAB
;
8055 else if (shndx
== elf_dynsymtab (ibfd
))
8056 shndx
= MAP_DYNSYMTAB
;
8057 else if (shndx
== elf_strtab_sec (ibfd
))
8059 else if (shndx
== elf_shstrtab_sec (ibfd
))
8060 shndx
= MAP_SHSTRTAB
;
8061 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
8062 shndx
= MAP_SYM_SHNDX
;
8063 osym
->internal_elf_sym
.st_shndx
= shndx
;
8069 /* Swap out the symbols. */
8072 swap_out_syms (bfd
*abfd
,
8073 struct elf_strtab_hash
**sttp
,
8075 struct bfd_link_info
*info
)
8077 const struct elf_backend_data
*bed
;
8078 unsigned int symcount
;
8080 struct elf_strtab_hash
*stt
;
8081 Elf_Internal_Shdr
*symtab_hdr
;
8082 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8083 Elf_Internal_Shdr
*symstrtab_hdr
;
8084 struct elf_sym_strtab
*symstrtab
;
8085 bfd_byte
*outbound_syms
;
8086 bfd_byte
*outbound_shndx
;
8087 unsigned long outbound_syms_index
;
8089 unsigned int num_locals
;
8091 bool name_local_sections
;
8093 if (!elf_map_symbols (abfd
, &num_locals
))
8096 /* Dump out the symtabs. */
8097 stt
= _bfd_elf_strtab_init ();
8101 bed
= get_elf_backend_data (abfd
);
8102 symcount
= bfd_get_symcount (abfd
);
8103 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8104 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8105 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8106 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8107 symtab_hdr
->sh_info
= num_locals
+ 1;
8108 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8110 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8111 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8113 /* Allocate buffer to swap out the .strtab section. */
8114 if (_bfd_mul_overflow (symcount
+ 1, sizeof (*symstrtab
), &amt
)
8115 || (symstrtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
)) == NULL
)
8117 bfd_set_error (bfd_error_no_memory
);
8118 _bfd_elf_strtab_free (stt
);
8122 if (_bfd_mul_overflow (symcount
+ 1, bed
->s
->sizeof_sym
, &amt
)
8123 || (outbound_syms
= (bfd_byte
*) bfd_alloc (abfd
, amt
)) == NULL
)
8126 bfd_set_error (bfd_error_no_memory
);
8129 _bfd_elf_strtab_free (stt
);
8132 symtab_hdr
->contents
= outbound_syms
;
8133 outbound_syms_index
= 0;
8135 outbound_shndx
= NULL
;
8137 if (elf_symtab_shndx_list (abfd
))
8139 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8140 if (symtab_shndx_hdr
->sh_name
!= 0)
8142 if (_bfd_mul_overflow (symcount
+ 1,
8143 sizeof (Elf_External_Sym_Shndx
), &amt
))
8145 outbound_shndx
= (bfd_byte
*) bfd_zalloc (abfd
, amt
);
8146 if (outbound_shndx
== NULL
)
8149 symtab_shndx_hdr
->contents
= outbound_shndx
;
8150 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8151 symtab_shndx_hdr
->sh_size
= amt
;
8152 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8153 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8155 /* FIXME: What about any other headers in the list ? */
8158 /* Now generate the data (for "contents"). */
8160 /* Fill in zeroth symbol and swap it out. */
8161 Elf_Internal_Sym sym
;
8167 sym
.st_shndx
= SHN_UNDEF
;
8168 sym
.st_target_internal
= 0;
8169 symstrtab
[0].sym
= sym
;
8170 symstrtab
[0].dest_index
= outbound_syms_index
;
8171 outbound_syms_index
++;
8175 = (bed
->elf_backend_name_local_section_symbols
8176 && bed
->elf_backend_name_local_section_symbols (abfd
));
8178 syms
= bfd_get_outsymbols (abfd
);
8179 for (idx
= 0; idx
< symcount
;)
8181 Elf_Internal_Sym sym
;
8182 bfd_vma value
= syms
[idx
]->value
;
8183 elf_symbol_type
*type_ptr
;
8184 flagword flags
= syms
[idx
]->flags
;
8187 if (!name_local_sections
8188 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8190 /* Local section symbols have no name. */
8191 sym
.st_name
= (unsigned long) -1;
8195 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8196 to get the final offset for st_name. */
8198 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8200 if (sym
.st_name
== (unsigned long) -1)
8204 type_ptr
= elf_symbol_from (syms
[idx
]);
8206 if ((flags
& BSF_SECTION_SYM
) == 0
8207 && bfd_is_com_section (syms
[idx
]->section
))
8209 /* ELF common symbols put the alignment into the `value' field,
8210 and the size into the `size' field. This is backwards from
8211 how BFD handles it, so reverse it here. */
8212 sym
.st_size
= value
;
8213 if (type_ptr
== NULL
8214 || type_ptr
->internal_elf_sym
.st_value
== 0)
8215 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8217 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8218 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8219 (abfd
, syms
[idx
]->section
);
8223 asection
*sec
= syms
[idx
]->section
;
8226 if (sec
->output_section
)
8228 value
+= sec
->output_offset
;
8229 sec
= sec
->output_section
;
8232 /* Don't add in the section vma for relocatable output. */
8233 if (! relocatable_p
)
8235 sym
.st_value
= value
;
8236 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8238 if (bfd_is_abs_section (sec
)
8240 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8242 /* This symbol is in a real ELF section which we did
8243 not create as a BFD section. Undo the mapping done
8244 by copy_private_symbol_data. */
8245 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8249 shndx
= elf_onesymtab (abfd
);
8252 shndx
= elf_dynsymtab (abfd
);
8255 shndx
= elf_strtab_sec (abfd
);
8258 shndx
= elf_shstrtab_sec (abfd
);
8261 if (elf_symtab_shndx_list (abfd
))
8262 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8269 if (shndx
>= SHN_LOPROC
&& shndx
<= SHN_HIOS
)
8271 if (bed
->symbol_section_index
)
8272 shndx
= bed
->symbol_section_index (abfd
, type_ptr
);
8273 /* Otherwise just leave the index alone. */
8277 if (shndx
> SHN_HIOS
&& shndx
< SHN_HIRESERVE
)
8278 _bfd_error_handler (_("%pB: \
8279 Unable to handle section index %x in ELF symbol. Using ABS instead."),
8288 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8290 if (shndx
== SHN_BAD
)
8294 /* Writing this would be a hell of a lot easier if
8295 we had some decent documentation on bfd, and
8296 knew what to expect of the library, and what to
8297 demand of applications. For example, it
8298 appears that `objcopy' might not set the
8299 section of a symbol to be a section that is
8300 actually in the output file. */
8301 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8303 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8304 if (shndx
== SHN_BAD
)
8306 /* xgettext:c-format */
8308 (_("unable to find equivalent output section"
8309 " for symbol '%s' from section '%s'"),
8310 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8312 bfd_set_error (bfd_error_invalid_operation
);
8318 sym
.st_shndx
= shndx
;
8321 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8323 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8324 type
= STT_GNU_IFUNC
;
8325 else if ((flags
& BSF_FUNCTION
) != 0)
8327 else if ((flags
& BSF_OBJECT
) != 0)
8329 else if ((flags
& BSF_RELC
) != 0)
8331 else if ((flags
& BSF_SRELC
) != 0)
8336 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8339 /* Processor-specific types. */
8340 if (type_ptr
!= NULL
8341 && bed
->elf_backend_get_symbol_type
)
8342 type
= ((*bed
->elf_backend_get_symbol_type
)
8343 (&type_ptr
->internal_elf_sym
, type
));
8345 if (flags
& BSF_SECTION_SYM
)
8347 if (flags
& BSF_GLOBAL
)
8348 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8350 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8352 else if (bfd_is_com_section (syms
[idx
]->section
))
8354 if (type
!= STT_TLS
)
8356 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8357 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8358 ? STT_COMMON
: STT_OBJECT
);
8360 type
= ((flags
& BSF_ELF_COMMON
) != 0
8361 ? STT_COMMON
: STT_OBJECT
);
8363 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8365 else if (bfd_is_und_section (syms
[idx
]->section
))
8366 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8370 else if (flags
& BSF_FILE
)
8371 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8374 int bind
= STB_LOCAL
;
8376 if (flags
& BSF_LOCAL
)
8378 else if (flags
& BSF_GNU_UNIQUE
)
8379 bind
= STB_GNU_UNIQUE
;
8380 else if (flags
& BSF_WEAK
)
8382 else if (flags
& BSF_GLOBAL
)
8385 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8388 if (type_ptr
!= NULL
)
8390 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8391 sym
.st_target_internal
8392 = type_ptr
->internal_elf_sym
.st_target_internal
;
8397 sym
.st_target_internal
= 0;
8401 symstrtab
[idx
].sym
= sym
;
8402 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8404 outbound_syms_index
++;
8407 /* Finalize the .strtab section. */
8408 _bfd_elf_strtab_finalize (stt
);
8410 /* Swap out the .strtab section. */
8411 for (idx
= 0; idx
<= symcount
; idx
++)
8413 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8414 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8415 elfsym
->sym
.st_name
= 0;
8417 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8418 elfsym
->sym
.st_name
);
8419 if (info
&& info
->callbacks
->ctf_new_symbol
)
8420 info
->callbacks
->ctf_new_symbol (elfsym
->dest_index
,
8423 /* Inform the linker of the addition of this symbol. */
8425 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8427 + (elfsym
->dest_index
8428 * bed
->s
->sizeof_sym
)),
8429 NPTR_ADD (outbound_shndx
,
8431 * sizeof (Elf_External_Sym_Shndx
))));
8436 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8437 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8438 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8439 symstrtab_hdr
->sh_addr
= 0;
8440 symstrtab_hdr
->sh_entsize
= 0;
8441 symstrtab_hdr
->sh_link
= 0;
8442 symstrtab_hdr
->sh_info
= 0;
8443 symstrtab_hdr
->sh_addralign
= 1;
8448 /* Return the number of bytes required to hold the symtab vector.
8450 Note that we base it on the count plus 1, since we will null terminate
8451 the vector allocated based on this size. However, the ELF symbol table
8452 always has a dummy entry as symbol #0, so it ends up even. */
8455 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8457 bfd_size_type symcount
;
8459 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8461 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8462 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8464 bfd_set_error (bfd_error_file_too_big
);
8467 symtab_size
= symcount
* (sizeof (asymbol
*));
8469 symtab_size
= sizeof (asymbol
*);
8470 else if (!bfd_write_p (abfd
))
8472 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8474 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8476 bfd_set_error (bfd_error_file_truncated
);
8485 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8487 bfd_size_type symcount
;
8489 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8491 if (elf_dynsymtab (abfd
) == 0)
8493 bfd_set_error (bfd_error_invalid_operation
);
8497 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8498 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8500 bfd_set_error (bfd_error_file_too_big
);
8503 symtab_size
= symcount
* (sizeof (asymbol
*));
8505 symtab_size
= sizeof (asymbol
*);
8506 else if (!bfd_write_p (abfd
))
8508 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8510 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8512 bfd_set_error (bfd_error_file_truncated
);
8521 _bfd_elf_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
8523 if (asect
->reloc_count
!= 0 && !bfd_write_p (abfd
))
8525 /* Sanity check reloc section size. */
8526 struct bfd_elf_section_data
*d
= elf_section_data (asect
);
8527 Elf_Internal_Shdr
*rel_hdr
= &d
->this_hdr
;
8528 bfd_size_type ext_rel_size
= rel_hdr
->sh_size
;
8529 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8531 if (filesize
!= 0 && ext_rel_size
> filesize
)
8533 bfd_set_error (bfd_error_file_truncated
);
8538 #if SIZEOF_LONG == SIZEOF_INT
8539 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8541 bfd_set_error (bfd_error_file_too_big
);
8545 return (asect
->reloc_count
+ 1L) * sizeof (arelent
*);
8548 /* Canonicalize the relocs. */
8551 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8558 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8560 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
8563 tblptr
= section
->relocation
;
8564 for (i
= 0; i
< section
->reloc_count
; i
++)
8565 *relptr
++ = tblptr
++;
8569 return section
->reloc_count
;
8573 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8575 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8576 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, false);
8579 abfd
->symcount
= symcount
;
8584 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8585 asymbol
**allocation
)
8587 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8588 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, true);
8591 abfd
->dynsymcount
= symcount
;
8595 /* Return the size required for the dynamic reloc entries. Any loadable
8596 section that was actually installed in the BFD, and has type SHT_REL
8597 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8598 dynamic reloc section. */
8601 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8603 bfd_size_type count
, ext_rel_size
;
8606 if (elf_dynsymtab (abfd
) == 0)
8608 bfd_set_error (bfd_error_invalid_operation
);
8614 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8615 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8616 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8617 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8619 ext_rel_size
+= s
->size
;
8620 if (ext_rel_size
< s
->size
)
8622 bfd_set_error (bfd_error_file_truncated
);
8625 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8626 if (count
> LONG_MAX
/ sizeof (arelent
*))
8628 bfd_set_error (bfd_error_file_too_big
);
8632 if (count
> 1 && !bfd_write_p (abfd
))
8634 /* Sanity check reloc section sizes. */
8635 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8636 if (filesize
!= 0 && ext_rel_size
> filesize
)
8638 bfd_set_error (bfd_error_file_truncated
);
8642 return count
* sizeof (arelent
*);
8645 /* Canonicalize the dynamic relocation entries. Note that we return the
8646 dynamic relocations as a single block, although they are actually
8647 associated with particular sections; the interface, which was
8648 designed for SunOS style shared libraries, expects that there is only
8649 one set of dynamic relocs. Any loadable section that was actually
8650 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8651 dynamic symbol table, is considered to be a dynamic reloc section. */
8654 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8658 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
8662 if (elf_dynsymtab (abfd
) == 0)
8664 bfd_set_error (bfd_error_invalid_operation
);
8668 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8670 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8672 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8673 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8674 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8679 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
8681 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8683 for (i
= 0; i
< count
; i
++)
8694 /* Read in the version information. */
8697 _bfd_elf_slurp_version_tables (bfd
*abfd
, bool default_imported_symver
)
8699 bfd_byte
*contents
= NULL
;
8700 unsigned int freeidx
= 0;
8703 if (elf_dynverref (abfd
) != 0)
8705 Elf_Internal_Shdr
*hdr
;
8706 Elf_External_Verneed
*everneed
;
8707 Elf_Internal_Verneed
*iverneed
;
8709 bfd_byte
*contents_end
;
8711 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8713 if (hdr
->sh_info
== 0
8714 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8716 error_return_bad_verref
:
8718 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8719 bfd_set_error (bfd_error_bad_value
);
8720 error_return_verref
:
8721 elf_tdata (abfd
)->verref
= NULL
;
8722 elf_tdata (abfd
)->cverrefs
= 0;
8726 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8727 goto error_return_verref
;
8728 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8729 if (contents
== NULL
)
8730 goto error_return_verref
;
8732 if (_bfd_mul_overflow (hdr
->sh_info
, sizeof (Elf_Internal_Verneed
), &amt
))
8734 bfd_set_error (bfd_error_file_too_big
);
8735 goto error_return_verref
;
8737 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*) bfd_alloc (abfd
, amt
);
8738 if (elf_tdata (abfd
)->verref
== NULL
)
8739 goto error_return_verref
;
8741 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8742 == sizeof (Elf_External_Vernaux
));
8743 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8744 everneed
= (Elf_External_Verneed
*) contents
;
8745 iverneed
= elf_tdata (abfd
)->verref
;
8746 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8748 Elf_External_Vernaux
*evernaux
;
8749 Elf_Internal_Vernaux
*ivernaux
;
8752 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8754 iverneed
->vn_bfd
= abfd
;
8756 iverneed
->vn_filename
=
8757 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8759 if (iverneed
->vn_filename
== NULL
)
8760 goto error_return_bad_verref
;
8762 if (iverneed
->vn_cnt
== 0)
8763 iverneed
->vn_auxptr
= NULL
;
8766 if (_bfd_mul_overflow (iverneed
->vn_cnt
,
8767 sizeof (Elf_Internal_Vernaux
), &amt
))
8769 bfd_set_error (bfd_error_file_too_big
);
8770 goto error_return_verref
;
8772 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8773 bfd_alloc (abfd
, amt
);
8774 if (iverneed
->vn_auxptr
== NULL
)
8775 goto error_return_verref
;
8778 if (iverneed
->vn_aux
8779 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8780 goto error_return_bad_verref
;
8782 evernaux
= ((Elf_External_Vernaux
*)
8783 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8784 ivernaux
= iverneed
->vn_auxptr
;
8785 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8787 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8789 ivernaux
->vna_nodename
=
8790 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8791 ivernaux
->vna_name
);
8792 if (ivernaux
->vna_nodename
== NULL
)
8793 goto error_return_bad_verref
;
8795 if (ivernaux
->vna_other
> freeidx
)
8796 freeidx
= ivernaux
->vna_other
;
8798 ivernaux
->vna_nextptr
= NULL
;
8799 if (ivernaux
->vna_next
== 0)
8801 iverneed
->vn_cnt
= j
+ 1;
8804 if (j
+ 1 < iverneed
->vn_cnt
)
8805 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8807 if (ivernaux
->vna_next
8808 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8809 goto error_return_bad_verref
;
8811 evernaux
= ((Elf_External_Vernaux
*)
8812 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8815 iverneed
->vn_nextref
= NULL
;
8816 if (iverneed
->vn_next
== 0)
8818 if (i
+ 1 < hdr
->sh_info
)
8819 iverneed
->vn_nextref
= iverneed
+ 1;
8821 if (iverneed
->vn_next
8822 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8823 goto error_return_bad_verref
;
8825 everneed
= ((Elf_External_Verneed
*)
8826 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8828 elf_tdata (abfd
)->cverrefs
= i
;
8834 if (elf_dynverdef (abfd
) != 0)
8836 Elf_Internal_Shdr
*hdr
;
8837 Elf_External_Verdef
*everdef
;
8838 Elf_Internal_Verdef
*iverdef
;
8839 Elf_Internal_Verdef
*iverdefarr
;
8840 Elf_Internal_Verdef iverdefmem
;
8842 unsigned int maxidx
;
8843 bfd_byte
*contents_end_def
, *contents_end_aux
;
8845 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8847 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8849 error_return_bad_verdef
:
8851 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8852 bfd_set_error (bfd_error_bad_value
);
8853 error_return_verdef
:
8854 elf_tdata (abfd
)->verdef
= NULL
;
8855 elf_tdata (abfd
)->cverdefs
= 0;
8859 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8860 goto error_return_verdef
;
8861 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8862 if (contents
== NULL
)
8863 goto error_return_verdef
;
8865 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8866 >= sizeof (Elf_External_Verdaux
));
8867 contents_end_def
= contents
+ hdr
->sh_size
8868 - sizeof (Elf_External_Verdef
);
8869 contents_end_aux
= contents
+ hdr
->sh_size
8870 - sizeof (Elf_External_Verdaux
);
8872 /* We know the number of entries in the section but not the maximum
8873 index. Therefore we have to run through all entries and find
8875 everdef
= (Elf_External_Verdef
*) contents
;
8877 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8879 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8881 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8882 goto error_return_bad_verdef
;
8883 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8884 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8886 if (iverdefmem
.vd_next
== 0)
8889 if (iverdefmem
.vd_next
8890 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8891 goto error_return_bad_verdef
;
8893 everdef
= ((Elf_External_Verdef
*)
8894 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8897 if (default_imported_symver
)
8899 if (freeidx
> maxidx
)
8904 if (_bfd_mul_overflow (maxidx
, sizeof (Elf_Internal_Verdef
), &amt
))
8906 bfd_set_error (bfd_error_file_too_big
);
8907 goto error_return_verdef
;
8909 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
8910 if (elf_tdata (abfd
)->verdef
== NULL
)
8911 goto error_return_verdef
;
8913 elf_tdata (abfd
)->cverdefs
= maxidx
;
8915 everdef
= (Elf_External_Verdef
*) contents
;
8916 iverdefarr
= elf_tdata (abfd
)->verdef
;
8917 for (i
= 0; i
< hdr
->sh_info
; i
++)
8919 Elf_External_Verdaux
*everdaux
;
8920 Elf_Internal_Verdaux
*iverdaux
;
8923 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8925 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8926 goto error_return_bad_verdef
;
8928 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8929 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8931 iverdef
->vd_bfd
= abfd
;
8933 if (iverdef
->vd_cnt
== 0)
8934 iverdef
->vd_auxptr
= NULL
;
8937 if (_bfd_mul_overflow (iverdef
->vd_cnt
,
8938 sizeof (Elf_Internal_Verdaux
), &amt
))
8940 bfd_set_error (bfd_error_file_too_big
);
8941 goto error_return_verdef
;
8943 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8944 bfd_alloc (abfd
, amt
);
8945 if (iverdef
->vd_auxptr
== NULL
)
8946 goto error_return_verdef
;
8950 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8951 goto error_return_bad_verdef
;
8953 everdaux
= ((Elf_External_Verdaux
*)
8954 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8955 iverdaux
= iverdef
->vd_auxptr
;
8956 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8958 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8960 iverdaux
->vda_nodename
=
8961 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8962 iverdaux
->vda_name
);
8963 if (iverdaux
->vda_nodename
== NULL
)
8964 goto error_return_bad_verdef
;
8966 iverdaux
->vda_nextptr
= NULL
;
8967 if (iverdaux
->vda_next
== 0)
8969 iverdef
->vd_cnt
= j
+ 1;
8972 if (j
+ 1 < iverdef
->vd_cnt
)
8973 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8975 if (iverdaux
->vda_next
8976 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8977 goto error_return_bad_verdef
;
8979 everdaux
= ((Elf_External_Verdaux
*)
8980 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8983 iverdef
->vd_nodename
= NULL
;
8984 if (iverdef
->vd_cnt
)
8985 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8987 iverdef
->vd_nextdef
= NULL
;
8988 if (iverdef
->vd_next
== 0)
8990 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8991 iverdef
->vd_nextdef
= iverdef
+ 1;
8993 everdef
= ((Elf_External_Verdef
*)
8994 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
9000 else if (default_imported_symver
)
9007 if (_bfd_mul_overflow (freeidx
, sizeof (Elf_Internal_Verdef
), &amt
))
9009 bfd_set_error (bfd_error_file_too_big
);
9012 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
9013 if (elf_tdata (abfd
)->verdef
== NULL
)
9016 elf_tdata (abfd
)->cverdefs
= freeidx
;
9019 /* Create a default version based on the soname. */
9020 if (default_imported_symver
)
9022 Elf_Internal_Verdef
*iverdef
;
9023 Elf_Internal_Verdaux
*iverdaux
;
9025 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
9027 iverdef
->vd_version
= VER_DEF_CURRENT
;
9028 iverdef
->vd_flags
= 0;
9029 iverdef
->vd_ndx
= freeidx
;
9030 iverdef
->vd_cnt
= 1;
9032 iverdef
->vd_bfd
= abfd
;
9034 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
9035 if (iverdef
->vd_nodename
== NULL
)
9036 goto error_return_verdef
;
9037 iverdef
->vd_nextdef
= NULL
;
9038 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
9039 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
9040 if (iverdef
->vd_auxptr
== NULL
)
9041 goto error_return_verdef
;
9043 iverdaux
= iverdef
->vd_auxptr
;
9044 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
9055 _bfd_elf_make_empty_symbol (bfd
*abfd
)
9057 elf_symbol_type
*newsym
;
9059 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
9062 newsym
->symbol
.the_bfd
= abfd
;
9063 return &newsym
->symbol
;
9067 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
9071 bfd_symbol_info (symbol
, ret
);
9074 /* Return whether a symbol name implies a local symbol. Most targets
9075 use this function for the is_local_label_name entry point, but some
9079 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
9082 /* Normal local symbols start with ``.L''. */
9083 if (name
[0] == '.' && name
[1] == 'L')
9086 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
9087 DWARF debugging symbols starting with ``..''. */
9088 if (name
[0] == '.' && name
[1] == '.')
9091 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
9092 emitting DWARF debugging output. I suspect this is actually a
9093 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
9094 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
9095 underscore to be emitted on some ELF targets). For ease of use,
9096 we treat such symbols as local. */
9097 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
9100 /* Treat assembler generated fake symbols, dollar local labels and
9101 forward-backward labels (aka local labels) as locals.
9102 These labels have the form:
9104 L0^A.* (fake symbols)
9106 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
9108 Versions which start with .L will have already been matched above,
9109 so we only need to match the rest. */
9110 if (name
[0] == 'L' && ISDIGIT (name
[1]))
9116 for (p
= name
+ 2; (c
= *p
); p
++)
9118 if (c
== 1 || c
== 2)
9120 if (c
== 1 && p
== name
+ 2)
9121 /* A fake symbol. */
9124 /* FIXME: We are being paranoid here and treating symbols like
9125 L0^Bfoo as if there were non-local, on the grounds that the
9126 assembler will never generate them. But can any symbol
9127 containing an ASCII value in the range 1-31 ever be anything
9128 other than some kind of local ? */
9145 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9146 asymbol
*symbol ATTRIBUTE_UNUSED
)
9153 _bfd_elf_set_arch_mach (bfd
*abfd
,
9154 enum bfd_architecture arch
,
9155 unsigned long machine
)
9157 /* If this isn't the right architecture for this backend, and this
9158 isn't the generic backend, fail. */
9159 if (arch
!= get_elf_backend_data (abfd
)->arch
9160 && arch
!= bfd_arch_unknown
9161 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9164 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9167 /* Find the nearest line to a particular section and offset,
9168 for error reporting. */
9171 _bfd_elf_find_nearest_line (bfd
*abfd
,
9175 const char **filename_ptr
,
9176 const char **functionname_ptr
,
9177 unsigned int *line_ptr
,
9178 unsigned int *discriminator_ptr
)
9182 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9183 filename_ptr
, functionname_ptr
,
9184 line_ptr
, discriminator_ptr
,
9185 dwarf_debug_sections
,
9186 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9189 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9190 filename_ptr
, functionname_ptr
, line_ptr
))
9192 if (!*functionname_ptr
)
9193 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9194 *filename_ptr
? NULL
: filename_ptr
,
9199 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9200 &found
, filename_ptr
,
9201 functionname_ptr
, line_ptr
,
9202 &elf_tdata (abfd
)->line_info
))
9204 if (found
&& (*functionname_ptr
|| *line_ptr
))
9207 if (symbols
== NULL
)
9210 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9211 filename_ptr
, functionname_ptr
))
9218 /* Find the line for a symbol. */
9221 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9222 const char **filename_ptr
, unsigned int *line_ptr
)
9224 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9225 filename_ptr
, NULL
, line_ptr
, NULL
,
9226 dwarf_debug_sections
,
9227 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9230 /* After a call to bfd_find_nearest_line, successive calls to
9231 bfd_find_inliner_info can be used to get source information about
9232 each level of function inlining that terminated at the address
9233 passed to bfd_find_nearest_line. Currently this is only supported
9234 for DWARF2 with appropriate DWARF3 extensions. */
9237 _bfd_elf_find_inliner_info (bfd
*abfd
,
9238 const char **filename_ptr
,
9239 const char **functionname_ptr
,
9240 unsigned int *line_ptr
)
9243 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9244 functionname_ptr
, line_ptr
,
9245 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9250 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9252 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9253 int ret
= bed
->s
->sizeof_ehdr
;
9255 if (!bfd_link_relocatable (info
))
9257 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9259 if (phdr_size
== (bfd_size_type
) -1)
9261 struct elf_segment_map
*m
;
9264 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9265 phdr_size
+= bed
->s
->sizeof_phdr
;
9268 phdr_size
= get_program_header_size (abfd
, info
);
9271 elf_program_header_size (abfd
) = phdr_size
;
9279 _bfd_elf_set_section_contents (bfd
*abfd
,
9281 const void *location
,
9283 bfd_size_type count
)
9285 Elf_Internal_Shdr
*hdr
;
9288 if (! abfd
->output_has_begun
9289 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9295 hdr
= &elf_section_data (section
)->this_hdr
;
9296 if (hdr
->sh_offset
== (file_ptr
) -1)
9298 unsigned char *contents
;
9300 if (bfd_section_is_ctf (section
))
9301 /* Nothing to do with this section: the contents are generated
9305 if ((section
->flags
& SEC_ELF_COMPRESS
) == 0)
9308 (_("%pB:%pA: error: attempting to write into an unallocated compressed section"),
9310 bfd_set_error (bfd_error_invalid_operation
);
9314 if ((offset
+ count
) > hdr
->sh_size
)
9317 (_("%pB:%pA: error: attempting to write over the end of the section"),
9320 bfd_set_error (bfd_error_invalid_operation
);
9324 contents
= hdr
->contents
;
9325 if (contents
== NULL
)
9328 (_("%pB:%pA: error: attempting to write section into an empty buffer"),
9331 bfd_set_error (bfd_error_invalid_operation
);
9335 memcpy (contents
+ offset
, location
, count
);
9339 pos
= hdr
->sh_offset
+ offset
;
9340 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9341 || bfd_bwrite (location
, count
, abfd
) != count
)
9348 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9349 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9350 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9356 /* Try to convert a non-ELF reloc into an ELF one. */
9359 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9361 /* Check whether we really have an ELF howto. */
9363 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9365 bfd_reloc_code_real_type code
;
9366 reloc_howto_type
*howto
;
9368 /* Alien reloc: Try to determine its type to replace it with an
9369 equivalent ELF reloc. */
9371 if (areloc
->howto
->pc_relative
)
9373 switch (areloc
->howto
->bitsize
)
9376 code
= BFD_RELOC_8_PCREL
;
9379 code
= BFD_RELOC_12_PCREL
;
9382 code
= BFD_RELOC_16_PCREL
;
9385 code
= BFD_RELOC_24_PCREL
;
9388 code
= BFD_RELOC_32_PCREL
;
9391 code
= BFD_RELOC_64_PCREL
;
9397 howto
= bfd_reloc_type_lookup (abfd
, code
);
9399 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9401 if (howto
->pcrel_offset
)
9402 areloc
->addend
+= areloc
->address
;
9404 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9409 switch (areloc
->howto
->bitsize
)
9415 code
= BFD_RELOC_14
;
9418 code
= BFD_RELOC_16
;
9421 code
= BFD_RELOC_26
;
9424 code
= BFD_RELOC_32
;
9427 code
= BFD_RELOC_64
;
9433 howto
= bfd_reloc_type_lookup (abfd
, code
);
9437 areloc
->howto
= howto
;
9445 /* xgettext:c-format */
9446 _bfd_error_handler (_("%pB: %s unsupported"),
9447 abfd
, areloc
->howto
->name
);
9448 bfd_set_error (bfd_error_sorry
);
9453 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9455 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9457 && (bfd_get_format (abfd
) == bfd_object
9458 || bfd_get_format (abfd
) == bfd_core
))
9460 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9461 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9462 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9465 return _bfd_generic_close_and_cleanup (abfd
);
9468 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9469 in the relocation's offset. Thus we cannot allow any sort of sanity
9470 range-checking to interfere. There is nothing else to do in processing
9473 bfd_reloc_status_type
9474 _bfd_elf_rel_vtable_reloc_fn
9475 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9476 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9477 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9478 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9480 return bfd_reloc_ok
;
9483 /* Elf core file support. Much of this only works on native
9484 toolchains, since we rely on knowing the
9485 machine-dependent procfs structure in order to pick
9486 out details about the corefile. */
9488 #ifdef HAVE_SYS_PROCFS_H
9489 # include <sys/procfs.h>
9492 /* Return a PID that identifies a "thread" for threaded cores, or the
9493 PID of the main process for non-threaded cores. */
9496 elfcore_make_pid (bfd
*abfd
)
9500 pid
= elf_tdata (abfd
)->core
->lwpid
;
9502 pid
= elf_tdata (abfd
)->core
->pid
;
9507 /* If there isn't a section called NAME, make one, using
9508 data from SECT. Note, this function will generate a
9509 reference to NAME, so you shouldn't deallocate or
9513 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9517 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9520 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9524 sect2
->size
= sect
->size
;
9525 sect2
->filepos
= sect
->filepos
;
9526 sect2
->alignment_power
= sect
->alignment_power
;
9530 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9531 actually creates up to two pseudosections:
9532 - For the single-threaded case, a section named NAME, unless
9533 such a section already exists.
9534 - For the multi-threaded case, a section named "NAME/PID", where
9535 PID is elfcore_make_pid (abfd).
9536 Both pseudosections have identical contents. */
9538 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9544 char *threaded_name
;
9548 /* Build the section name. */
9550 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9551 len
= strlen (buf
) + 1;
9552 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9553 if (threaded_name
== NULL
)
9555 memcpy (threaded_name
, buf
, len
);
9557 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9562 sect
->filepos
= filepos
;
9563 sect
->alignment_power
= 2;
9565 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9569 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9572 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9578 sect
->size
= note
->descsz
- offs
;
9579 sect
->filepos
= note
->descpos
+ offs
;
9580 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9585 /* prstatus_t exists on:
9587 linux 2.[01] + glibc
9591 #if defined (HAVE_PRSTATUS_T)
9594 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9599 if (note
->descsz
== sizeof (prstatus_t
))
9603 size
= sizeof (prstat
.pr_reg
);
9604 offset
= offsetof (prstatus_t
, pr_reg
);
9605 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9607 /* Do not overwrite the core signal if it
9608 has already been set by another thread. */
9609 if (elf_tdata (abfd
)->core
->signal
== 0)
9610 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9611 if (elf_tdata (abfd
)->core
->pid
== 0)
9612 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9614 /* pr_who exists on:
9617 pr_who doesn't exist on:
9620 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9621 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9623 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9626 #if defined (HAVE_PRSTATUS32_T)
9627 else if (note
->descsz
== sizeof (prstatus32_t
))
9629 /* 64-bit host, 32-bit corefile */
9630 prstatus32_t prstat
;
9632 size
= sizeof (prstat
.pr_reg
);
9633 offset
= offsetof (prstatus32_t
, pr_reg
);
9634 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9636 /* Do not overwrite the core signal if it
9637 has already been set by another thread. */
9638 if (elf_tdata (abfd
)->core
->signal
== 0)
9639 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9640 if (elf_tdata (abfd
)->core
->pid
== 0)
9641 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9643 /* pr_who exists on:
9646 pr_who doesn't exist on:
9649 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9650 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9652 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9655 #endif /* HAVE_PRSTATUS32_T */
9658 /* Fail - we don't know how to handle any other
9659 note size (ie. data object type). */
9663 /* Make a ".reg/999" section and a ".reg" section. */
9664 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9665 size
, note
->descpos
+ offset
);
9667 #endif /* defined (HAVE_PRSTATUS_T) */
9669 /* Create a pseudosection containing the exact contents of NOTE. */
9671 elfcore_make_note_pseudosection (bfd
*abfd
,
9673 Elf_Internal_Note
*note
)
9675 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9676 note
->descsz
, note
->descpos
);
9679 /* There isn't a consistent prfpregset_t across platforms,
9680 but it doesn't matter, because we don't have to pick this
9681 data structure apart. */
9684 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9686 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9689 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9690 type of NT_PRXFPREG. Just include the whole note's contents
9694 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9696 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9699 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9700 with a note type of NT_X86_XSTATE. Just include the whole note's
9701 contents literally. */
9704 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9706 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9710 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9712 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9716 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9718 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9722 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9724 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9728 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9730 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9734 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9736 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9740 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9742 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9746 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9748 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9752 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9754 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9758 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9760 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9764 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9766 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9770 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9772 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9776 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9778 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9782 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9784 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9788 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9790 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9794 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9796 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9800 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9802 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9806 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9808 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9812 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9814 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9818 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9820 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9824 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9826 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9830 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9832 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9836 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9838 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9842 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9844 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9848 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9850 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9854 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9856 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9860 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9862 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9866 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9868 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9872 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9874 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9878 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9880 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9884 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9886 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9890 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9892 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9896 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9898 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9902 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9904 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9908 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9910 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9914 elfcore_grok_aarch_mte (bfd
*abfd
, Elf_Internal_Note
*note
)
9916 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-mte",
9921 elfcore_grok_arc_v2 (bfd
*abfd
, Elf_Internal_Note
*note
)
9923 return elfcore_make_note_pseudosection (abfd
, ".reg-arc-v2", note
);
9926 /* Convert NOTE into a bfd_section called ".reg-riscv-csr". Return TRUE if
9927 successful otherwise, return FALSE. */
9930 elfcore_grok_riscv_csr (bfd
*abfd
, Elf_Internal_Note
*note
)
9932 return elfcore_make_note_pseudosection (abfd
, ".reg-riscv-csr", note
);
9935 /* Convert NOTE into a bfd_section called ".gdb-tdesc". Return TRUE if
9936 successful otherwise, return FALSE. */
9939 elfcore_grok_gdb_tdesc (bfd
*abfd
, Elf_Internal_Note
*note
)
9941 return elfcore_make_note_pseudosection (abfd
, ".gdb-tdesc", note
);
9945 elfcore_grok_loongarch_cpucfg (bfd
*abfd
, Elf_Internal_Note
*note
)
9947 return elfcore_make_note_pseudosection (abfd
, ".reg-loongarch-cpucfg", note
);
9951 elfcore_grok_loongarch_lbt (bfd
*abfd
, Elf_Internal_Note
*note
)
9953 return elfcore_make_note_pseudosection (abfd
, ".reg-loongarch-lbt", note
);
9957 elfcore_grok_loongarch_lsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9959 return elfcore_make_note_pseudosection (abfd
, ".reg-loongarch-lsx", note
);
9963 elfcore_grok_loongarch_lasx (bfd
*abfd
, Elf_Internal_Note
*note
)
9965 return elfcore_make_note_pseudosection (abfd
, ".reg-loongarch-lasx", note
);
9968 #if defined (HAVE_PRPSINFO_T)
9969 typedef prpsinfo_t elfcore_psinfo_t
;
9970 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9971 typedef prpsinfo32_t elfcore_psinfo32_t
;
9975 #if defined (HAVE_PSINFO_T)
9976 typedef psinfo_t elfcore_psinfo_t
;
9977 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9978 typedef psinfo32_t elfcore_psinfo32_t
;
9982 /* return a malloc'ed copy of a string at START which is at
9983 most MAX bytes long, possibly without a terminating '\0'.
9984 the copy will always have a terminating '\0'. */
9987 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9990 char *end
= (char *) memchr (start
, '\0', max
);
9998 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
10002 memcpy (dups
, start
, len
);
10008 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10010 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10012 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
10014 elfcore_psinfo_t psinfo
;
10016 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10018 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
10019 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10021 elf_tdata (abfd
)->core
->program
10022 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10023 sizeof (psinfo
.pr_fname
));
10025 elf_tdata (abfd
)->core
->command
10026 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10027 sizeof (psinfo
.pr_psargs
));
10029 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10030 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
10032 /* 64-bit host, 32-bit corefile */
10033 elfcore_psinfo32_t psinfo
;
10035 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10037 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
10038 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10040 elf_tdata (abfd
)->core
->program
10041 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10042 sizeof (psinfo
.pr_fname
));
10044 elf_tdata (abfd
)->core
->command
10045 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10046 sizeof (psinfo
.pr_psargs
));
10052 /* Fail - we don't know how to handle any other
10053 note size (ie. data object type). */
10057 /* Note that for some reason, a spurious space is tacked
10058 onto the end of the args in some (at least one anyway)
10059 implementations, so strip it off if it exists. */
10062 char *command
= elf_tdata (abfd
)->core
->command
;
10063 int n
= strlen (command
);
10065 if (0 < n
&& command
[n
- 1] == ' ')
10066 command
[n
- 1] = '\0';
10071 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
10073 #if defined (HAVE_PSTATUS_T)
10075 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10077 if (note
->descsz
== sizeof (pstatus_t
)
10078 #if defined (HAVE_PXSTATUS_T)
10079 || note
->descsz
== sizeof (pxstatus_t
)
10085 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10087 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10089 #if defined (HAVE_PSTATUS32_T)
10090 else if (note
->descsz
== sizeof (pstatus32_t
))
10092 /* 64-bit host, 32-bit corefile */
10095 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10097 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10100 /* Could grab some more details from the "representative"
10101 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
10102 NT_LWPSTATUS note, presumably. */
10106 #endif /* defined (HAVE_PSTATUS_T) */
10108 #if defined (HAVE_LWPSTATUS_T)
10110 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10112 lwpstatus_t lwpstat
;
10118 if (note
->descsz
!= sizeof (lwpstat
)
10119 #if defined (HAVE_LWPXSTATUS_T)
10120 && note
->descsz
!= sizeof (lwpxstatus_t
)
10125 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
10127 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
10128 /* Do not overwrite the core signal if it has already been set by
10130 if (elf_tdata (abfd
)->core
->signal
== 0)
10131 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
10133 /* Make a ".reg/999" section. */
10135 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
10136 len
= strlen (buf
) + 1;
10137 name
= bfd_alloc (abfd
, len
);
10140 memcpy (name
, buf
, len
);
10142 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10146 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10147 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
10148 sect
->filepos
= note
->descpos
10149 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
10152 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10153 sect
->size
= sizeof (lwpstat
.pr_reg
);
10154 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
10157 sect
->alignment_power
= 2;
10159 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10162 /* Make a ".reg2/999" section */
10164 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
10165 len
= strlen (buf
) + 1;
10166 name
= bfd_alloc (abfd
, len
);
10169 memcpy (name
, buf
, len
);
10171 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10175 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10176 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
10177 sect
->filepos
= note
->descpos
10178 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
10181 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
10182 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
10183 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
10186 sect
->alignment_power
= 2;
10188 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
10190 #endif /* defined (HAVE_LWPSTATUS_T) */
10192 /* These constants, and the structure offsets used below, are defined by
10193 Cygwin's core_dump.h */
10194 #define NOTE_INFO_PROCESS 1
10195 #define NOTE_INFO_THREAD 2
10196 #define NOTE_INFO_MODULE 3
10197 #define NOTE_INFO_MODULE64 4
10200 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10205 unsigned int name_size
;
10208 int is_active_thread
;
10211 if (note
->descsz
< 4)
10214 if (! startswith (note
->namedata
, "win32"))
10217 type
= bfd_get_32 (abfd
, note
->descdata
);
10221 const char *type_name
;
10222 unsigned long min_size
;
10225 { "NOTE_INFO_PROCESS", 12 },
10226 { "NOTE_INFO_THREAD", 12 },
10227 { "NOTE_INFO_MODULE", 12 },
10228 { "NOTE_INFO_MODULE64", 16 },
10231 if (type
== 0 || type
> (sizeof(size_check
)/sizeof(size_check
[0])))
10234 if (note
->descsz
< size_check
[type
- 1].min_size
)
10236 _bfd_error_handler (_("%pB: warning: win32pstatus %s of size %lu bytes is too small"),
10237 abfd
, size_check
[type
- 1].type_name
, note
->descsz
);
10243 case NOTE_INFO_PROCESS
:
10244 /* FIXME: need to add ->core->command. */
10245 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10246 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10249 case NOTE_INFO_THREAD
:
10250 /* Make a ".reg/<tid>" section containing the Win32 API thread CONTEXT
10252 /* thread_info.tid */
10253 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 4));
10255 len
= strlen (buf
) + 1;
10256 name
= (char *) bfd_alloc (abfd
, len
);
10260 memcpy (name
, buf
, len
);
10262 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10266 /* sizeof (thread_info.thread_context) */
10267 sect
->size
= note
->descsz
- 12;
10268 /* offsetof (thread_info.thread_context) */
10269 sect
->filepos
= note
->descpos
+ 12;
10270 sect
->alignment_power
= 2;
10272 /* thread_info.is_active_thread */
10273 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10275 if (is_active_thread
)
10276 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10280 case NOTE_INFO_MODULE
:
10281 case NOTE_INFO_MODULE64
:
10282 /* Make a ".module/xxxxxxxx" section. */
10283 if (type
== NOTE_INFO_MODULE
)
10285 /* module_info.base_address */
10286 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10287 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10288 /* module_info.module_name_size */
10289 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10291 else /* NOTE_INFO_MODULE64 */
10293 /* module_info.base_address */
10294 base_addr
= bfd_get_64 (abfd
, note
->descdata
+ 4);
10295 sprintf (buf
, ".module/%016lx", (unsigned long) base_addr
);
10296 /* module_info.module_name_size */
10297 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10300 len
= strlen (buf
) + 1;
10301 name
= (char *) bfd_alloc (abfd
, len
);
10305 memcpy (name
, buf
, len
);
10307 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10312 if (note
->descsz
< 12 + name_size
)
10314 _bfd_error_handler (_("%pB: win32pstatus NOTE_INFO_MODULE of size %lu is too small to contain a name of size %u"),
10315 abfd
, note
->descsz
, name_size
);
10319 sect
->size
= note
->descsz
;
10320 sect
->filepos
= note
->descpos
;
10321 sect
->alignment_power
= 2;
10332 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10334 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10336 switch (note
->type
)
10342 if (bed
->elf_backend_grok_prstatus
)
10343 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10345 #if defined (HAVE_PRSTATUS_T)
10346 return elfcore_grok_prstatus (abfd
, note
);
10351 #if defined (HAVE_PSTATUS_T)
10353 return elfcore_grok_pstatus (abfd
, note
);
10356 #if defined (HAVE_LWPSTATUS_T)
10358 return elfcore_grok_lwpstatus (abfd
, note
);
10361 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10362 return elfcore_grok_prfpreg (abfd
, note
);
10364 case NT_WIN32PSTATUS
:
10365 return elfcore_grok_win32pstatus (abfd
, note
);
10367 case NT_PRXFPREG
: /* Linux SSE extension */
10368 if (note
->namesz
== 6
10369 && strcmp (note
->namedata
, "LINUX") == 0)
10370 return elfcore_grok_prxfpreg (abfd
, note
);
10374 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10375 if (note
->namesz
== 6
10376 && strcmp (note
->namedata
, "LINUX") == 0)
10377 return elfcore_grok_xstatereg (abfd
, note
);
10382 if (note
->namesz
== 6
10383 && strcmp (note
->namedata
, "LINUX") == 0)
10384 return elfcore_grok_ppc_vmx (abfd
, note
);
10389 if (note
->namesz
== 6
10390 && strcmp (note
->namedata
, "LINUX") == 0)
10391 return elfcore_grok_ppc_vsx (abfd
, note
);
10396 if (note
->namesz
== 6
10397 && strcmp (note
->namedata
, "LINUX") == 0)
10398 return elfcore_grok_ppc_tar (abfd
, note
);
10403 if (note
->namesz
== 6
10404 && strcmp (note
->namedata
, "LINUX") == 0)
10405 return elfcore_grok_ppc_ppr (abfd
, note
);
10410 if (note
->namesz
== 6
10411 && strcmp (note
->namedata
, "LINUX") == 0)
10412 return elfcore_grok_ppc_dscr (abfd
, note
);
10417 if (note
->namesz
== 6
10418 && strcmp (note
->namedata
, "LINUX") == 0)
10419 return elfcore_grok_ppc_ebb (abfd
, note
);
10424 if (note
->namesz
== 6
10425 && strcmp (note
->namedata
, "LINUX") == 0)
10426 return elfcore_grok_ppc_pmu (abfd
, note
);
10430 case NT_PPC_TM_CGPR
:
10431 if (note
->namesz
== 6
10432 && strcmp (note
->namedata
, "LINUX") == 0)
10433 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10437 case NT_PPC_TM_CFPR
:
10438 if (note
->namesz
== 6
10439 && strcmp (note
->namedata
, "LINUX") == 0)
10440 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10444 case NT_PPC_TM_CVMX
:
10445 if (note
->namesz
== 6
10446 && strcmp (note
->namedata
, "LINUX") == 0)
10447 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10451 case NT_PPC_TM_CVSX
:
10452 if (note
->namesz
== 6
10453 && strcmp (note
->namedata
, "LINUX") == 0)
10454 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10458 case NT_PPC_TM_SPR
:
10459 if (note
->namesz
== 6
10460 && strcmp (note
->namedata
, "LINUX") == 0)
10461 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10465 case NT_PPC_TM_CTAR
:
10466 if (note
->namesz
== 6
10467 && strcmp (note
->namedata
, "LINUX") == 0)
10468 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10472 case NT_PPC_TM_CPPR
:
10473 if (note
->namesz
== 6
10474 && strcmp (note
->namedata
, "LINUX") == 0)
10475 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10479 case NT_PPC_TM_CDSCR
:
10480 if (note
->namesz
== 6
10481 && strcmp (note
->namedata
, "LINUX") == 0)
10482 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10486 case NT_S390_HIGH_GPRS
:
10487 if (note
->namesz
== 6
10488 && strcmp (note
->namedata
, "LINUX") == 0)
10489 return elfcore_grok_s390_high_gprs (abfd
, note
);
10493 case NT_S390_TIMER
:
10494 if (note
->namesz
== 6
10495 && strcmp (note
->namedata
, "LINUX") == 0)
10496 return elfcore_grok_s390_timer (abfd
, note
);
10500 case NT_S390_TODCMP
:
10501 if (note
->namesz
== 6
10502 && strcmp (note
->namedata
, "LINUX") == 0)
10503 return elfcore_grok_s390_todcmp (abfd
, note
);
10507 case NT_S390_TODPREG
:
10508 if (note
->namesz
== 6
10509 && strcmp (note
->namedata
, "LINUX") == 0)
10510 return elfcore_grok_s390_todpreg (abfd
, note
);
10515 if (note
->namesz
== 6
10516 && strcmp (note
->namedata
, "LINUX") == 0)
10517 return elfcore_grok_s390_ctrs (abfd
, note
);
10521 case NT_S390_PREFIX
:
10522 if (note
->namesz
== 6
10523 && strcmp (note
->namedata
, "LINUX") == 0)
10524 return elfcore_grok_s390_prefix (abfd
, note
);
10528 case NT_S390_LAST_BREAK
:
10529 if (note
->namesz
== 6
10530 && strcmp (note
->namedata
, "LINUX") == 0)
10531 return elfcore_grok_s390_last_break (abfd
, note
);
10535 case NT_S390_SYSTEM_CALL
:
10536 if (note
->namesz
== 6
10537 && strcmp (note
->namedata
, "LINUX") == 0)
10538 return elfcore_grok_s390_system_call (abfd
, note
);
10543 if (note
->namesz
== 6
10544 && strcmp (note
->namedata
, "LINUX") == 0)
10545 return elfcore_grok_s390_tdb (abfd
, note
);
10549 case NT_S390_VXRS_LOW
:
10550 if (note
->namesz
== 6
10551 && strcmp (note
->namedata
, "LINUX") == 0)
10552 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10556 case NT_S390_VXRS_HIGH
:
10557 if (note
->namesz
== 6
10558 && strcmp (note
->namedata
, "LINUX") == 0)
10559 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10563 case NT_S390_GS_CB
:
10564 if (note
->namesz
== 6
10565 && strcmp (note
->namedata
, "LINUX") == 0)
10566 return elfcore_grok_s390_gs_cb (abfd
, note
);
10570 case NT_S390_GS_BC
:
10571 if (note
->namesz
== 6
10572 && strcmp (note
->namedata
, "LINUX") == 0)
10573 return elfcore_grok_s390_gs_bc (abfd
, note
);
10578 if (note
->namesz
== 6
10579 && strcmp (note
->namedata
, "LINUX") == 0)
10580 return elfcore_grok_arc_v2 (abfd
, note
);
10585 if (note
->namesz
== 6
10586 && strcmp (note
->namedata
, "LINUX") == 0)
10587 return elfcore_grok_arm_vfp (abfd
, note
);
10592 if (note
->namesz
== 6
10593 && strcmp (note
->namedata
, "LINUX") == 0)
10594 return elfcore_grok_aarch_tls (abfd
, note
);
10598 case NT_ARM_HW_BREAK
:
10599 if (note
->namesz
== 6
10600 && strcmp (note
->namedata
, "LINUX") == 0)
10601 return elfcore_grok_aarch_hw_break (abfd
, note
);
10605 case NT_ARM_HW_WATCH
:
10606 if (note
->namesz
== 6
10607 && strcmp (note
->namedata
, "LINUX") == 0)
10608 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10613 if (note
->namesz
== 6
10614 && strcmp (note
->namedata
, "LINUX") == 0)
10615 return elfcore_grok_aarch_sve (abfd
, note
);
10619 case NT_ARM_PAC_MASK
:
10620 if (note
->namesz
== 6
10621 && strcmp (note
->namedata
, "LINUX") == 0)
10622 return elfcore_grok_aarch_pauth (abfd
, note
);
10626 case NT_ARM_TAGGED_ADDR_CTRL
:
10627 if (note
->namesz
== 6
10628 && strcmp (note
->namedata
, "LINUX") == 0)
10629 return elfcore_grok_aarch_mte (abfd
, note
);
10634 if (note
->namesz
== 4
10635 && strcmp (note
->namedata
, "GDB") == 0)
10636 return elfcore_grok_gdb_tdesc (abfd
, note
);
10641 if (note
->namesz
== 4
10642 && strcmp (note
->namedata
, "GDB") == 0)
10643 return elfcore_grok_riscv_csr (abfd
, note
);
10647 case NT_LARCH_CPUCFG
:
10648 if (note
->namesz
== 6
10649 && strcmp (note
->namedata
, "LINUX") == 0)
10650 return elfcore_grok_loongarch_cpucfg (abfd
, note
);
10655 if (note
->namesz
== 6
10656 && strcmp (note
->namedata
, "LINUX") == 0)
10657 return elfcore_grok_loongarch_lbt (abfd
, note
);
10662 if (note
->namesz
== 6
10663 && strcmp (note
->namedata
, "LINUX") == 0)
10664 return elfcore_grok_loongarch_lsx (abfd
, note
);
10668 case NT_LARCH_LASX
:
10669 if (note
->namesz
== 6
10670 && strcmp (note
->namedata
, "LINUX") == 0)
10671 return elfcore_grok_loongarch_lasx (abfd
, note
);
10677 if (bed
->elf_backend_grok_psinfo
)
10678 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10680 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10681 return elfcore_grok_psinfo (abfd
, note
);
10687 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10690 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10694 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10701 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10703 struct bfd_build_id
* build_id
;
10705 if (note
->descsz
== 0)
10708 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10709 if (build_id
== NULL
)
10712 build_id
->size
= note
->descsz
;
10713 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10714 abfd
->build_id
= build_id
;
10720 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10722 switch (note
->type
)
10727 case NT_GNU_PROPERTY_TYPE_0
:
10728 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10730 case NT_GNU_BUILD_ID
:
10731 return elfobj_grok_gnu_build_id (abfd
, note
);
10736 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10738 struct sdt_note
*cur
=
10739 (struct sdt_note
*) bfd_alloc (abfd
,
10740 sizeof (struct sdt_note
) + note
->descsz
);
10742 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10743 cur
->size
= (bfd_size_type
) note
->descsz
;
10744 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10746 elf_tdata (abfd
)->sdt_note_head
= cur
;
10752 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10754 switch (note
->type
)
10757 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10765 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10769 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10772 if (note
->descsz
< 108)
10777 if (note
->descsz
< 120)
10785 /* Check for version 1 in pr_version. */
10786 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10791 /* Skip over pr_psinfosz. */
10792 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10796 offset
+= 4; /* Padding before pr_psinfosz. */
10800 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10801 elf_tdata (abfd
)->core
->program
10802 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10805 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10806 elf_tdata (abfd
)->core
->command
10807 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10810 /* Padding before pr_pid. */
10813 /* The pr_pid field was added in version "1a". */
10814 if (note
->descsz
< offset
+ 4)
10817 elf_tdata (abfd
)->core
->pid
10818 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10824 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10830 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10831 Also compute minimum size of this note. */
10832 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10836 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10840 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10841 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10848 if (note
->descsz
< min_size
)
10851 /* Check for version 1 in pr_version. */
10852 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10855 /* Extract size of pr_reg from pr_gregsetsz. */
10856 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10857 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10859 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10864 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10868 /* Skip over pr_osreldate. */
10871 /* Read signal from pr_cursig. */
10872 if (elf_tdata (abfd
)->core
->signal
== 0)
10873 elf_tdata (abfd
)->core
->signal
10874 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10877 /* Read TID from pr_pid. */
10878 elf_tdata (abfd
)->core
->lwpid
10879 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10882 /* Padding before pr_reg. */
10883 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10886 /* Make sure that there is enough data remaining in the note. */
10887 if ((note
->descsz
- offset
) < size
)
10890 /* Make a ".reg/999" section and a ".reg" section. */
10891 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10892 size
, note
->descpos
+ offset
);
10896 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10898 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10900 switch (note
->type
)
10903 if (bed
->elf_backend_grok_freebsd_prstatus
)
10904 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10906 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10909 return elfcore_grok_prfpreg (abfd
, note
);
10912 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10914 case NT_FREEBSD_THRMISC
:
10915 if (note
->namesz
== 8)
10916 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10920 case NT_FREEBSD_PROCSTAT_PROC
:
10921 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10924 case NT_FREEBSD_PROCSTAT_FILES
:
10925 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10928 case NT_FREEBSD_PROCSTAT_VMMAP
:
10929 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10932 case NT_FREEBSD_PROCSTAT_AUXV
:
10933 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10935 case NT_X86_XSTATE
:
10936 if (note
->namesz
== 8)
10937 return elfcore_grok_xstatereg (abfd
, note
);
10941 case NT_FREEBSD_PTLWPINFO
:
10942 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10946 return elfcore_grok_arm_vfp (abfd
, note
);
10954 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10958 cp
= strchr (note
->namedata
, '@');
10961 *lwpidp
= atoi(cp
+ 1);
10968 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10970 if (note
->descsz
<= 0x7c + 31)
10973 /* Signal number at offset 0x08. */
10974 elf_tdata (abfd
)->core
->signal
10975 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10977 /* Process ID at offset 0x50. */
10978 elf_tdata (abfd
)->core
->pid
10979 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10981 /* Command name at 0x7c (max 32 bytes, including nul). */
10982 elf_tdata (abfd
)->core
->command
10983 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10985 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10990 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10994 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10995 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10997 switch (note
->type
)
10999 case NT_NETBSDCORE_PROCINFO
:
11000 /* NetBSD-specific core "procinfo". Note that we expect to
11001 find this note before any of the others, which is fine,
11002 since the kernel writes this note out first when it
11003 creates a core file. */
11004 return elfcore_grok_netbsd_procinfo (abfd
, note
);
11005 case NT_NETBSDCORE_AUXV
:
11006 /* NetBSD-specific Elf Auxiliary Vector data. */
11007 return elfcore_make_auxv_note_section (abfd
, note
, 4);
11008 case NT_NETBSDCORE_LWPSTATUS
:
11009 return elfcore_make_note_pseudosection (abfd
,
11010 ".note.netbsdcore.lwpstatus",
11016 /* As of March 2020 there are no other machine-independent notes
11017 defined for NetBSD core files. If the note type is less
11018 than the start of the machine-dependent note types, we don't
11021 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
11025 switch (bfd_get_arch (abfd
))
11027 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
11028 PT_GETFPREGS == mach+2. */
11030 case bfd_arch_aarch64
:
11031 case bfd_arch_alpha
:
11032 case bfd_arch_sparc
:
11033 switch (note
->type
)
11035 case NT_NETBSDCORE_FIRSTMACH
+0:
11036 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11038 case NT_NETBSDCORE_FIRSTMACH
+2:
11039 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11045 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
11046 There's also old PT___GETREGS40 == mach + 1 for old reg
11047 structure which lacks GBR. */
11050 switch (note
->type
)
11052 case NT_NETBSDCORE_FIRSTMACH
+3:
11053 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11055 case NT_NETBSDCORE_FIRSTMACH
+5:
11056 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11062 /* On all other arch's, PT_GETREGS == mach+1 and
11063 PT_GETFPREGS == mach+3. */
11066 switch (note
->type
)
11068 case NT_NETBSDCORE_FIRSTMACH
+1:
11069 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11071 case NT_NETBSDCORE_FIRSTMACH
+3:
11072 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11082 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
11084 if (note
->descsz
<= 0x48 + 31)
11087 /* Signal number at offset 0x08. */
11088 elf_tdata (abfd
)->core
->signal
11089 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
11091 /* Process ID at offset 0x20. */
11092 elf_tdata (abfd
)->core
->pid
11093 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
11095 /* Command name at 0x48 (max 32 bytes, including nul). */
11096 elf_tdata (abfd
)->core
->command
11097 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
11102 /* Processes Solaris's process status note.
11103 sig_off ~ offsetof(prstatus_t, pr_cursig)
11104 pid_off ~ offsetof(prstatus_t, pr_pid)
11105 lwpid_off ~ offsetof(prstatus_t, pr_who)
11106 gregset_size ~ sizeof(gregset_t)
11107 gregset_offset ~ offsetof(prstatus_t, pr_reg) */
11110 elfcore_grok_solaris_prstatus (bfd
*abfd
, Elf_Internal_Note
* note
, int sig_off
,
11111 int pid_off
, int lwpid_off
, size_t gregset_size
,
11112 size_t gregset_offset
)
11114 asection
*sect
= NULL
;
11115 elf_tdata (abfd
)->core
->signal
11116 = bfd_get_16 (abfd
, note
->descdata
+ sig_off
);
11117 elf_tdata (abfd
)->core
->pid
11118 = bfd_get_32 (abfd
, note
->descdata
+ pid_off
);
11119 elf_tdata (abfd
)->core
->lwpid
11120 = bfd_get_32 (abfd
, note
->descdata
+ lwpid_off
);
11122 sect
= bfd_get_section_by_name (abfd
, ".reg");
11124 sect
->size
= gregset_size
;
11126 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", gregset_size
,
11127 note
->descpos
+ gregset_offset
);
11130 /* Gets program and arguments from a core.
11131 prog_off ~ offsetof(prpsinfo | psinfo_t, pr_fname)
11132 comm_off ~ offsetof(prpsinfo | psinfo_t, pr_psargs) */
11135 elfcore_grok_solaris_info(bfd
*abfd
, Elf_Internal_Note
* note
,
11136 int prog_off
, int comm_off
)
11138 elf_tdata (abfd
)->core
->program
11139 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ prog_off
, 16);
11140 elf_tdata (abfd
)->core
->command
11141 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ comm_off
, 80);
11146 /* Processes Solaris's LWP status note.
11147 gregset_size ~ sizeof(gregset_t)
11148 gregset_off ~ offsetof(lwpstatus_t, pr_reg)
11149 fpregset_size ~ sizeof(fpregset_t)
11150 fpregset_off ~ offsetof(lwpstatus_t, pr_fpreg) */
11153 elfcore_grok_solaris_lwpstatus (bfd
*abfd
, Elf_Internal_Note
* note
,
11154 size_t gregset_size
, int gregset_off
,
11155 size_t fpregset_size
, int fpregset_off
)
11157 asection
*sect
= NULL
;
11158 char reg2_section_name
[16] = { 0 };
11160 (void) snprintf (reg2_section_name
, 16, "%s/%i", ".reg2",
11161 elf_tdata (abfd
)->core
->lwpid
);
11163 /* offsetof(lwpstatus_t, pr_lwpid) */
11164 elf_tdata (abfd
)->core
->lwpid
11165 = bfd_get_32 (abfd
, note
->descdata
+ 4);
11166 /* offsetof(lwpstatus_t, pr_cursig) */
11167 elf_tdata (abfd
)->core
->signal
11168 = bfd_get_16 (abfd
, note
->descdata
+ 12);
11170 sect
= bfd_get_section_by_name (abfd
, ".reg");
11172 sect
->size
= gregset_size
;
11173 else if (!_bfd_elfcore_make_pseudosection (abfd
, ".reg", gregset_size
,
11174 note
->descpos
+ gregset_off
))
11177 sect
= bfd_get_section_by_name (abfd
, reg2_section_name
);
11180 sect
->size
= fpregset_size
;
11181 sect
->filepos
= note
->descpos
+ fpregset_off
;
11182 sect
->alignment_power
= 2;
11184 else if (!_bfd_elfcore_make_pseudosection (abfd
, ".reg2", fpregset_size
,
11185 note
->descpos
+ fpregset_off
))
11192 elfcore_grok_solaris_note_impl (bfd
*abfd
, Elf_Internal_Note
*note
)
11197 /* core files are identified as 32- or 64-bit, SPARC or x86,
11198 by the size of the descsz which matches the sizeof()
11199 the type appropriate for that note type (e.g., prstatus_t for
11200 SOLARIS_NT_PRSTATUS) for the corresponding architecture
11201 on Solaris. The core file bitness may differ from the bitness of
11202 gdb itself, so fixed values are used instead of sizeof().
11203 Appropriate fixed offsets are also used to obtain data from
11206 switch ((int) note
->type
)
11208 case SOLARIS_NT_PRSTATUS
:
11209 switch (note
->descsz
)
11211 case 508: /* sizeof(prstatus_t) SPARC 32-bit */
11212 return elfcore_grok_solaris_prstatus(abfd
, note
,
11213 136, 216, 308, 152, 356);
11214 case 904: /* sizeof(prstatus_t) SPARC 64-bit */
11215 return elfcore_grok_solaris_prstatus(abfd
, note
,
11216 264, 360, 520, 304, 600);
11217 case 432: /* sizeof(prstatus_t) Intel 32-bit */
11218 return elfcore_grok_solaris_prstatus(abfd
, note
,
11219 136, 216, 308, 76, 356);
11220 case 824: /* sizeof(prstatus_t) Intel 64-bit */
11221 return elfcore_grok_solaris_prstatus(abfd
, note
,
11222 264, 360, 520, 224, 600);
11227 case SOLARIS_NT_PSINFO
:
11228 case SOLARIS_NT_PRPSINFO
:
11229 switch (note
->descsz
)
11231 case 260: /* sizeof(prpsinfo_t) SPARC and Intel 32-bit */
11232 return elfcore_grok_solaris_info(abfd
, note
, 84, 100);
11233 case 328: /* sizeof(prpsinfo_t) SPARC and Intel 64-bit */
11234 return elfcore_grok_solaris_info(abfd
, note
, 120, 136);
11235 case 360: /* sizeof(psinfo_t) SPARC and Intel 32-bit */
11236 return elfcore_grok_solaris_info(abfd
, note
, 88, 104);
11237 case 440: /* sizeof(psinfo_t) SPARC and Intel 64-bit */
11238 return elfcore_grok_solaris_info(abfd
, note
, 136, 152);
11243 case SOLARIS_NT_LWPSTATUS
:
11244 switch (note
->descsz
)
11246 case 896: /* sizeof(lwpstatus_t) SPARC 32-bit */
11247 return elfcore_grok_solaris_lwpstatus(abfd
, note
,
11248 152, 344, 400, 496);
11249 case 1392: /* sizeof(lwpstatus_t) SPARC 64-bit */
11250 return elfcore_grok_solaris_lwpstatus(abfd
, note
,
11251 304, 544, 544, 848);
11252 case 800: /* sizeof(lwpstatus_t) Intel 32-bit */
11253 return elfcore_grok_solaris_lwpstatus(abfd
, note
,
11254 76, 344, 380, 420);
11255 case 1296: /* sizeof(lwpstatus_t) Intel 64-bit */
11256 return elfcore_grok_solaris_lwpstatus(abfd
, note
,
11257 224, 544, 528, 768);
11262 case SOLARIS_NT_LWPSINFO
:
11263 /* sizeof(lwpsinfo_t) on 32- and 64-bit, respectively */
11264 if (note
->descsz
== 128 || note
->descsz
== 152)
11265 elf_tdata (abfd
)->core
->lwpid
=
11266 bfd_get_32 (abfd
, note
->descdata
+ 4);
11276 /* For name starting with "CORE" this may be either a Solaris
11277 core file or a gdb-generated core file. Do Solaris-specific
11278 processing on selected note types first with
11279 elfcore_grok_solaris_note(), then process the note
11280 in elfcore_grok_note(). */
11283 elfcore_grok_solaris_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11285 if (!elfcore_grok_solaris_note_impl (abfd
, note
))
11288 return elfcore_grok_note (abfd
, note
);
11292 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11294 if (note
->type
== NT_OPENBSD_PROCINFO
)
11295 return elfcore_grok_openbsd_procinfo (abfd
, note
);
11297 if (note
->type
== NT_OPENBSD_REGS
)
11298 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11300 if (note
->type
== NT_OPENBSD_FPREGS
)
11301 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11303 if (note
->type
== NT_OPENBSD_XFPREGS
)
11304 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
11306 if (note
->type
== NT_OPENBSD_AUXV
)
11307 return elfcore_make_auxv_note_section (abfd
, note
, 0);
11309 if (note
->type
== NT_OPENBSD_WCOOKIE
)
11311 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
11316 sect
->size
= note
->descsz
;
11317 sect
->filepos
= note
->descpos
;
11318 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
11327 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
11329 void *ddata
= note
->descdata
;
11336 if (note
->descsz
< 16)
11339 /* nto_procfs_status 'pid' field is at offset 0. */
11340 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
11342 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
11343 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
11345 /* nto_procfs_status 'flags' field is at offset 8. */
11346 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
11348 /* nto_procfs_status 'what' field is at offset 14. */
11349 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
11351 elf_tdata (abfd
)->core
->signal
= sig
;
11352 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11355 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
11356 do not come from signals so we make sure we set the current
11357 thread just in case. */
11358 if (flags
& 0x00000080)
11359 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11361 /* Make a ".qnx_core_status/%d" section. */
11362 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
11364 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11367 strcpy (name
, buf
);
11369 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11373 sect
->size
= note
->descsz
;
11374 sect
->filepos
= note
->descpos
;
11375 sect
->alignment_power
= 2;
11377 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
11381 elfcore_grok_nto_regs (bfd
*abfd
,
11382 Elf_Internal_Note
*note
,
11390 /* Make a "(base)/%d" section. */
11391 sprintf (buf
, "%s/%ld", base
, tid
);
11393 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11396 strcpy (name
, buf
);
11398 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11402 sect
->size
= note
->descsz
;
11403 sect
->filepos
= note
->descpos
;
11404 sect
->alignment_power
= 2;
11406 /* This is the current thread. */
11407 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
11408 return elfcore_maybe_make_sect (abfd
, base
, sect
);
11413 #define BFD_QNT_CORE_INFO 7
11414 #define BFD_QNT_CORE_STATUS 8
11415 #define BFD_QNT_CORE_GREG 9
11416 #define BFD_QNT_CORE_FPREG 10
11419 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11421 /* Every GREG section has a STATUS section before it. Store the
11422 tid from the previous call to pass down to the next gregs
11424 static long tid
= 1;
11426 switch (note
->type
)
11428 case BFD_QNT_CORE_INFO
:
11429 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
11430 case BFD_QNT_CORE_STATUS
:
11431 return elfcore_grok_nto_status (abfd
, note
, &tid
);
11432 case BFD_QNT_CORE_GREG
:
11433 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
11434 case BFD_QNT_CORE_FPREG
:
11435 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
11442 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11448 /* Use note name as section name. */
11449 len
= note
->namesz
;
11450 name
= (char *) bfd_alloc (abfd
, len
);
11453 memcpy (name
, note
->namedata
, len
);
11454 name
[len
- 1] = '\0';
11456 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11460 sect
->size
= note
->descsz
;
11461 sect
->filepos
= note
->descpos
;
11462 sect
->alignment_power
= 1;
11467 /* Function: elfcore_write_note
11470 buffer to hold note, and current size of buffer
11474 size of data for note
11476 Writes note to end of buffer. ELF64 notes are written exactly as
11477 for ELF32, despite the current (as of 2006) ELF gabi specifying
11478 that they ought to have 8-byte namesz and descsz field, and have
11479 8-byte alignment. Other writers, eg. Linux kernel, do the same.
11482 Pointer to realloc'd buffer, *BUFSIZ updated. */
11485 elfcore_write_note (bfd
*abfd
,
11493 Elf_External_Note
*xnp
;
11500 namesz
= strlen (name
) + 1;
11502 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
11504 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
11507 dest
= buf
+ *bufsiz
;
11508 *bufsiz
+= newspace
;
11509 xnp
= (Elf_External_Note
*) dest
;
11510 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
11511 H_PUT_32 (abfd
, size
, xnp
->descsz
);
11512 H_PUT_32 (abfd
, type
, xnp
->type
);
11516 memcpy (dest
, name
, namesz
);
11524 memcpy (dest
, input
, size
);
11534 /* gcc-8 warns (*) on all the strncpy calls in this function about
11535 possible string truncation. The "truncation" is not a bug. We
11536 have an external representation of structs with fields that are not
11537 necessarily NULL terminated and corresponding internal
11538 representation fields that are one larger so that they can always
11539 be NULL terminated.
11540 gcc versions between 4.2 and 4.6 do not allow pragma control of
11541 diagnostics inside functions, giving a hard error if you try to use
11542 the finer control available with later versions.
11543 gcc prior to 4.2 warns about diagnostic push and pop.
11544 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11545 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11546 (*) Depending on your system header files! */
11547 #if GCC_VERSION >= 8000
11548 # pragma GCC diagnostic push
11549 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11552 elfcore_write_prpsinfo (bfd
*abfd
,
11556 const char *psargs
)
11558 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11560 if (bed
->elf_backend_write_core_note
!= NULL
)
11563 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11564 NT_PRPSINFO
, fname
, psargs
);
11569 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11570 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11571 if (bed
->s
->elfclass
== ELFCLASS32
)
11573 # if defined (HAVE_PSINFO32_T)
11575 int note_type
= NT_PSINFO
;
11578 int note_type
= NT_PRPSINFO
;
11581 memset (&data
, 0, sizeof (data
));
11582 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11583 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11584 return elfcore_write_note (abfd
, buf
, bufsiz
,
11585 "CORE", note_type
, &data
, sizeof (data
));
11590 # if defined (HAVE_PSINFO_T)
11592 int note_type
= NT_PSINFO
;
11595 int note_type
= NT_PRPSINFO
;
11598 memset (&data
, 0, sizeof (data
));
11599 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11600 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11601 return elfcore_write_note (abfd
, buf
, bufsiz
,
11602 "CORE", note_type
, &data
, sizeof (data
));
11604 #endif /* PSINFO_T or PRPSINFO_T */
11609 #if GCC_VERSION >= 8000
11610 # pragma GCC diagnostic pop
11614 elfcore_write_linux_prpsinfo32
11615 (bfd
*abfd
, char *buf
, int *bufsiz
,
11616 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11618 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11620 struct elf_external_linux_prpsinfo32_ugid16 data
;
11622 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11623 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11624 &data
, sizeof (data
));
11628 struct elf_external_linux_prpsinfo32_ugid32 data
;
11630 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11631 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11632 &data
, sizeof (data
));
11637 elfcore_write_linux_prpsinfo64
11638 (bfd
*abfd
, char *buf
, int *bufsiz
,
11639 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11641 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11643 struct elf_external_linux_prpsinfo64_ugid16 data
;
11645 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11646 return elfcore_write_note (abfd
, buf
, bufsiz
,
11647 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11651 struct elf_external_linux_prpsinfo64_ugid32 data
;
11653 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11654 return elfcore_write_note (abfd
, buf
, bufsiz
,
11655 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11660 elfcore_write_prstatus (bfd
*abfd
,
11667 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11669 if (bed
->elf_backend_write_core_note
!= NULL
)
11672 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11674 pid
, cursig
, gregs
);
11679 #if defined (HAVE_PRSTATUS_T)
11680 #if defined (HAVE_PRSTATUS32_T)
11681 if (bed
->s
->elfclass
== ELFCLASS32
)
11683 prstatus32_t prstat
;
11685 memset (&prstat
, 0, sizeof (prstat
));
11686 prstat
.pr_pid
= pid
;
11687 prstat
.pr_cursig
= cursig
;
11688 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11689 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11690 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11697 memset (&prstat
, 0, sizeof (prstat
));
11698 prstat
.pr_pid
= pid
;
11699 prstat
.pr_cursig
= cursig
;
11700 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11701 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11702 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11704 #endif /* HAVE_PRSTATUS_T */
11710 #if defined (HAVE_LWPSTATUS_T)
11712 elfcore_write_lwpstatus (bfd
*abfd
,
11719 lwpstatus_t lwpstat
;
11720 const char *note_name
= "CORE";
11722 memset (&lwpstat
, 0, sizeof (lwpstat
));
11723 lwpstat
.pr_lwpid
= pid
>> 16;
11724 lwpstat
.pr_cursig
= cursig
;
11725 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11726 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11727 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11728 #if !defined(gregs)
11729 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11730 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11732 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11733 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11736 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11737 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11739 #endif /* HAVE_LWPSTATUS_T */
11741 #if defined (HAVE_PSTATUS_T)
11743 elfcore_write_pstatus (bfd
*abfd
,
11747 int cursig ATTRIBUTE_UNUSED
,
11748 const void *gregs ATTRIBUTE_UNUSED
)
11750 const char *note_name
= "CORE";
11751 #if defined (HAVE_PSTATUS32_T)
11752 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11754 if (bed
->s
->elfclass
== ELFCLASS32
)
11758 memset (&pstat
, 0, sizeof (pstat
));
11759 pstat
.pr_pid
= pid
& 0xffff;
11760 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11761 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11769 memset (&pstat
, 0, sizeof (pstat
));
11770 pstat
.pr_pid
= pid
& 0xffff;
11771 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11772 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11776 #endif /* HAVE_PSTATUS_T */
11779 elfcore_write_prfpreg (bfd
*abfd
,
11782 const void *fpregs
,
11785 const char *note_name
= "CORE";
11786 return elfcore_write_note (abfd
, buf
, bufsiz
,
11787 note_name
, NT_FPREGSET
, fpregs
, size
);
11791 elfcore_write_prxfpreg (bfd
*abfd
,
11794 const void *xfpregs
,
11797 char *note_name
= "LINUX";
11798 return elfcore_write_note (abfd
, buf
, bufsiz
,
11799 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11803 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11804 const void *xfpregs
, int size
)
11807 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11808 note_name
= "FreeBSD";
11810 note_name
= "LINUX";
11811 return elfcore_write_note (abfd
, buf
, bufsiz
,
11812 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11816 elfcore_write_ppc_vmx (bfd
*abfd
,
11819 const void *ppc_vmx
,
11822 char *note_name
= "LINUX";
11823 return elfcore_write_note (abfd
, buf
, bufsiz
,
11824 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11828 elfcore_write_ppc_vsx (bfd
*abfd
,
11831 const void *ppc_vsx
,
11834 char *note_name
= "LINUX";
11835 return elfcore_write_note (abfd
, buf
, bufsiz
,
11836 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11840 elfcore_write_ppc_tar (bfd
*abfd
,
11843 const void *ppc_tar
,
11846 char *note_name
= "LINUX";
11847 return elfcore_write_note (abfd
, buf
, bufsiz
,
11848 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11852 elfcore_write_ppc_ppr (bfd
*abfd
,
11855 const void *ppc_ppr
,
11858 char *note_name
= "LINUX";
11859 return elfcore_write_note (abfd
, buf
, bufsiz
,
11860 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11864 elfcore_write_ppc_dscr (bfd
*abfd
,
11867 const void *ppc_dscr
,
11870 char *note_name
= "LINUX";
11871 return elfcore_write_note (abfd
, buf
, bufsiz
,
11872 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11876 elfcore_write_ppc_ebb (bfd
*abfd
,
11879 const void *ppc_ebb
,
11882 char *note_name
= "LINUX";
11883 return elfcore_write_note (abfd
, buf
, bufsiz
,
11884 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11888 elfcore_write_ppc_pmu (bfd
*abfd
,
11891 const void *ppc_pmu
,
11894 char *note_name
= "LINUX";
11895 return elfcore_write_note (abfd
, buf
, bufsiz
,
11896 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11900 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11903 const void *ppc_tm_cgpr
,
11906 char *note_name
= "LINUX";
11907 return elfcore_write_note (abfd
, buf
, bufsiz
,
11908 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11912 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11915 const void *ppc_tm_cfpr
,
11918 char *note_name
= "LINUX";
11919 return elfcore_write_note (abfd
, buf
, bufsiz
,
11920 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11924 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11927 const void *ppc_tm_cvmx
,
11930 char *note_name
= "LINUX";
11931 return elfcore_write_note (abfd
, buf
, bufsiz
,
11932 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11936 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11939 const void *ppc_tm_cvsx
,
11942 char *note_name
= "LINUX";
11943 return elfcore_write_note (abfd
, buf
, bufsiz
,
11944 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11948 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11951 const void *ppc_tm_spr
,
11954 char *note_name
= "LINUX";
11955 return elfcore_write_note (abfd
, buf
, bufsiz
,
11956 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11960 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11963 const void *ppc_tm_ctar
,
11966 char *note_name
= "LINUX";
11967 return elfcore_write_note (abfd
, buf
, bufsiz
,
11968 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11972 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11975 const void *ppc_tm_cppr
,
11978 char *note_name
= "LINUX";
11979 return elfcore_write_note (abfd
, buf
, bufsiz
,
11980 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11984 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11987 const void *ppc_tm_cdscr
,
11990 char *note_name
= "LINUX";
11991 return elfcore_write_note (abfd
, buf
, bufsiz
,
11992 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11996 elfcore_write_s390_high_gprs (bfd
*abfd
,
11999 const void *s390_high_gprs
,
12002 char *note_name
= "LINUX";
12003 return elfcore_write_note (abfd
, buf
, bufsiz
,
12004 note_name
, NT_S390_HIGH_GPRS
,
12005 s390_high_gprs
, size
);
12009 elfcore_write_s390_timer (bfd
*abfd
,
12012 const void *s390_timer
,
12015 char *note_name
= "LINUX";
12016 return elfcore_write_note (abfd
, buf
, bufsiz
,
12017 note_name
, NT_S390_TIMER
, s390_timer
, size
);
12021 elfcore_write_s390_todcmp (bfd
*abfd
,
12024 const void *s390_todcmp
,
12027 char *note_name
= "LINUX";
12028 return elfcore_write_note (abfd
, buf
, bufsiz
,
12029 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
12033 elfcore_write_s390_todpreg (bfd
*abfd
,
12036 const void *s390_todpreg
,
12039 char *note_name
= "LINUX";
12040 return elfcore_write_note (abfd
, buf
, bufsiz
,
12041 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
12045 elfcore_write_s390_ctrs (bfd
*abfd
,
12048 const void *s390_ctrs
,
12051 char *note_name
= "LINUX";
12052 return elfcore_write_note (abfd
, buf
, bufsiz
,
12053 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
12057 elfcore_write_s390_prefix (bfd
*abfd
,
12060 const void *s390_prefix
,
12063 char *note_name
= "LINUX";
12064 return elfcore_write_note (abfd
, buf
, bufsiz
,
12065 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
12069 elfcore_write_s390_last_break (bfd
*abfd
,
12072 const void *s390_last_break
,
12075 char *note_name
= "LINUX";
12076 return elfcore_write_note (abfd
, buf
, bufsiz
,
12077 note_name
, NT_S390_LAST_BREAK
,
12078 s390_last_break
, size
);
12082 elfcore_write_s390_system_call (bfd
*abfd
,
12085 const void *s390_system_call
,
12088 char *note_name
= "LINUX";
12089 return elfcore_write_note (abfd
, buf
, bufsiz
,
12090 note_name
, NT_S390_SYSTEM_CALL
,
12091 s390_system_call
, size
);
12095 elfcore_write_s390_tdb (bfd
*abfd
,
12098 const void *s390_tdb
,
12101 char *note_name
= "LINUX";
12102 return elfcore_write_note (abfd
, buf
, bufsiz
,
12103 note_name
, NT_S390_TDB
, s390_tdb
, size
);
12107 elfcore_write_s390_vxrs_low (bfd
*abfd
,
12110 const void *s390_vxrs_low
,
12113 char *note_name
= "LINUX";
12114 return elfcore_write_note (abfd
, buf
, bufsiz
,
12115 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
12119 elfcore_write_s390_vxrs_high (bfd
*abfd
,
12122 const void *s390_vxrs_high
,
12125 char *note_name
= "LINUX";
12126 return elfcore_write_note (abfd
, buf
, bufsiz
,
12127 note_name
, NT_S390_VXRS_HIGH
,
12128 s390_vxrs_high
, size
);
12132 elfcore_write_s390_gs_cb (bfd
*abfd
,
12135 const void *s390_gs_cb
,
12138 char *note_name
= "LINUX";
12139 return elfcore_write_note (abfd
, buf
, bufsiz
,
12140 note_name
, NT_S390_GS_CB
,
12145 elfcore_write_s390_gs_bc (bfd
*abfd
,
12148 const void *s390_gs_bc
,
12151 char *note_name
= "LINUX";
12152 return elfcore_write_note (abfd
, buf
, bufsiz
,
12153 note_name
, NT_S390_GS_BC
,
12158 elfcore_write_arm_vfp (bfd
*abfd
,
12161 const void *arm_vfp
,
12164 char *note_name
= "LINUX";
12165 return elfcore_write_note (abfd
, buf
, bufsiz
,
12166 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
12170 elfcore_write_aarch_tls (bfd
*abfd
,
12173 const void *aarch_tls
,
12176 char *note_name
= "LINUX";
12177 return elfcore_write_note (abfd
, buf
, bufsiz
,
12178 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
12182 elfcore_write_aarch_hw_break (bfd
*abfd
,
12185 const void *aarch_hw_break
,
12188 char *note_name
= "LINUX";
12189 return elfcore_write_note (abfd
, buf
, bufsiz
,
12190 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
12194 elfcore_write_aarch_hw_watch (bfd
*abfd
,
12197 const void *aarch_hw_watch
,
12200 char *note_name
= "LINUX";
12201 return elfcore_write_note (abfd
, buf
, bufsiz
,
12202 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
12206 elfcore_write_aarch_sve (bfd
*abfd
,
12209 const void *aarch_sve
,
12212 char *note_name
= "LINUX";
12213 return elfcore_write_note (abfd
, buf
, bufsiz
,
12214 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
12218 elfcore_write_aarch_pauth (bfd
*abfd
,
12221 const void *aarch_pauth
,
12224 char *note_name
= "LINUX";
12225 return elfcore_write_note (abfd
, buf
, bufsiz
,
12226 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
12230 elfcore_write_aarch_mte (bfd
*abfd
,
12233 const void *aarch_mte
,
12236 char *note_name
= "LINUX";
12237 return elfcore_write_note (abfd
, buf
, bufsiz
,
12238 note_name
, NT_ARM_TAGGED_ADDR_CTRL
,
12244 elfcore_write_arc_v2 (bfd
*abfd
,
12247 const void *arc_v2
,
12250 char *note_name
= "LINUX";
12251 return elfcore_write_note (abfd
, buf
, bufsiz
,
12252 note_name
, NT_ARC_V2
, arc_v2
, size
);
12256 elfcore_write_loongarch_cpucfg (bfd
*abfd
,
12259 const void *loongarch_cpucfg
,
12262 char *note_name
= "LINUX";
12263 return elfcore_write_note (abfd
, buf
, bufsiz
,
12264 note_name
, NT_LARCH_CPUCFG
,
12265 loongarch_cpucfg
, size
);
12269 elfcore_write_loongarch_lbt (bfd
*abfd
,
12272 const void *loongarch_lbt
,
12275 char *note_name
= "LINUX";
12276 return elfcore_write_note (abfd
, buf
, bufsiz
,
12277 note_name
, NT_LARCH_LBT
, loongarch_lbt
, size
);
12281 elfcore_write_loongarch_lsx (bfd
*abfd
,
12284 const void *loongarch_lsx
,
12287 char *note_name
= "LINUX";
12288 return elfcore_write_note (abfd
, buf
, bufsiz
,
12289 note_name
, NT_LARCH_LSX
, loongarch_lsx
, size
);
12293 elfcore_write_loongarch_lasx (bfd
*abfd
,
12296 const void *loongarch_lasx
,
12299 char *note_name
= "LINUX";
12300 return elfcore_write_note (abfd
, buf
, bufsiz
,
12301 note_name
, NT_LARCH_LASX
, loongarch_lasx
, size
);
12304 /* Write the buffer of csr values in CSRS (length SIZE) into the note
12305 buffer BUF and update *BUFSIZ. ABFD is the bfd the note is being
12306 written into. Return a pointer to the new start of the note buffer, to
12307 replace BUF which may no longer be valid. */
12310 elfcore_write_riscv_csr (bfd
*abfd
,
12316 const char *note_name
= "GDB";
12317 return elfcore_write_note (abfd
, buf
, bufsiz
,
12318 note_name
, NT_RISCV_CSR
, csrs
, size
);
12321 /* Write the target description (a string) pointed to by TDESC, length
12322 SIZE, into the note buffer BUF, and update *BUFSIZ. ABFD is the bfd the
12323 note is being written into. Return a pointer to the new start of the
12324 note buffer, to replace BUF which may no longer be valid. */
12327 elfcore_write_gdb_tdesc (bfd
*abfd
,
12333 const char *note_name
= "GDB";
12334 return elfcore_write_note (abfd
, buf
, bufsiz
,
12335 note_name
, NT_GDB_TDESC
, tdesc
, size
);
12339 elfcore_write_register_note (bfd
*abfd
,
12342 const char *section
,
12346 if (strcmp (section
, ".reg2") == 0)
12347 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
12348 if (strcmp (section
, ".reg-xfp") == 0)
12349 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
12350 if (strcmp (section
, ".reg-xstate") == 0)
12351 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
12352 if (strcmp (section
, ".reg-ppc-vmx") == 0)
12353 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
12354 if (strcmp (section
, ".reg-ppc-vsx") == 0)
12355 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
12356 if (strcmp (section
, ".reg-ppc-tar") == 0)
12357 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
12358 if (strcmp (section
, ".reg-ppc-ppr") == 0)
12359 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
12360 if (strcmp (section
, ".reg-ppc-dscr") == 0)
12361 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
12362 if (strcmp (section
, ".reg-ppc-ebb") == 0)
12363 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
12364 if (strcmp (section
, ".reg-ppc-pmu") == 0)
12365 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
12366 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
12367 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
12368 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
12369 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
12370 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
12371 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
12372 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
12373 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
12374 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
12375 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
12376 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
12377 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
12378 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
12379 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
12380 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
12381 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
12382 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
12383 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
12384 if (strcmp (section
, ".reg-s390-timer") == 0)
12385 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
12386 if (strcmp (section
, ".reg-s390-todcmp") == 0)
12387 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
12388 if (strcmp (section
, ".reg-s390-todpreg") == 0)
12389 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
12390 if (strcmp (section
, ".reg-s390-ctrs") == 0)
12391 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
12392 if (strcmp (section
, ".reg-s390-prefix") == 0)
12393 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
12394 if (strcmp (section
, ".reg-s390-last-break") == 0)
12395 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
12396 if (strcmp (section
, ".reg-s390-system-call") == 0)
12397 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
12398 if (strcmp (section
, ".reg-s390-tdb") == 0)
12399 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
12400 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
12401 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
12402 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
12403 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
12404 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
12405 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
12406 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
12407 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
12408 if (strcmp (section
, ".reg-arm-vfp") == 0)
12409 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
12410 if (strcmp (section
, ".reg-aarch-tls") == 0)
12411 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
12412 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
12413 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
12414 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
12415 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
12416 if (strcmp (section
, ".reg-aarch-sve") == 0)
12417 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
12418 if (strcmp (section
, ".reg-aarch-pauth") == 0)
12419 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
12420 if (strcmp (section
, ".reg-aarch-mte") == 0)
12421 return elfcore_write_aarch_mte (abfd
, buf
, bufsiz
, data
, size
);
12422 if (strcmp (section
, ".reg-arc-v2") == 0)
12423 return elfcore_write_arc_v2 (abfd
, buf
, bufsiz
, data
, size
);
12424 if (strcmp (section
, ".gdb-tdesc") == 0)
12425 return elfcore_write_gdb_tdesc (abfd
, buf
, bufsiz
, data
, size
);
12426 if (strcmp (section
, ".reg-riscv-csr") == 0)
12427 return elfcore_write_riscv_csr (abfd
, buf
, bufsiz
, data
, size
);
12428 if (strcmp (section
, ".reg-loongarch-cpucfg") == 0)
12429 return elfcore_write_loongarch_cpucfg (abfd
, buf
, bufsiz
, data
, size
);
12430 if (strcmp (section
, ".reg-loongarch-lbt") == 0)
12431 return elfcore_write_loongarch_lbt (abfd
, buf
, bufsiz
, data
, size
);
12432 if (strcmp (section
, ".reg-loongarch-lsx") == 0)
12433 return elfcore_write_loongarch_lsx (abfd
, buf
, bufsiz
, data
, size
);
12434 if (strcmp (section
, ".reg-loongarch-lasx") == 0)
12435 return elfcore_write_loongarch_lasx (abfd
, buf
, bufsiz
, data
, size
);
12440 elfcore_write_file_note (bfd
*obfd
, char *note_data
, int *note_size
,
12441 const void *buf
, int bufsiz
)
12443 return elfcore_write_note (obfd
, note_data
, note_size
,
12444 "CORE", NT_FILE
, buf
, bufsiz
);
12448 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
12453 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
12454 gABI specifies that PT_NOTE alignment should be aligned to 4
12455 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
12456 align is less than 4, we use 4 byte alignment. */
12459 if (align
!= 4 && align
!= 8)
12463 while (p
< buf
+ size
)
12465 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
12466 Elf_Internal_Note in
;
12468 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
12471 in
.type
= H_GET_32 (abfd
, xnp
->type
);
12473 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
12474 in
.namedata
= xnp
->name
;
12475 if (in
.namesz
> buf
- in
.namedata
+ size
)
12478 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
12479 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
12480 in
.descpos
= offset
+ (in
.descdata
- buf
);
12482 && (in
.descdata
>= buf
+ size
12483 || in
.descsz
> buf
- in
.descdata
+ size
))
12486 switch (bfd_get_format (abfd
))
12493 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
12496 const char * string
;
12498 bool (*func
) (bfd
*, Elf_Internal_Note
*);
12502 GROKER_ELEMENT ("", elfcore_grok_note
),
12503 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
12504 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
12505 GROKER_ELEMENT ("OpenBSD", elfcore_grok_openbsd_note
),
12506 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
12507 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
12508 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
),
12509 GROKER_ELEMENT ("CORE", elfcore_grok_solaris_note
)
12511 #undef GROKER_ELEMENT
12514 for (i
= ARRAY_SIZE (grokers
); i
--;)
12516 if (in
.namesz
>= grokers
[i
].len
12517 && strncmp (in
.namedata
, grokers
[i
].string
,
12518 grokers
[i
].len
) == 0)
12520 if (! grokers
[i
].func (abfd
, & in
))
12529 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
12531 if (! elfobj_grok_gnu_note (abfd
, &in
))
12534 else if (in
.namesz
== sizeof "stapsdt"
12535 && strcmp (in
.namedata
, "stapsdt") == 0)
12537 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
12543 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
12550 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
12555 if (size
== 0 || (size
+ 1) == 0)
12558 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
12561 buf
= (char *) _bfd_malloc_and_read (abfd
, size
+ 1, size
);
12565 /* PR 17512: file: ec08f814
12566 0-termintate the buffer so that string searches will not overflow. */
12569 if (!elf_parse_notes (abfd
, buf
, size
, offset
, align
))
12579 /* Providing external access to the ELF program header table. */
12581 /* Return an upper bound on the number of bytes required to store a
12582 copy of ABFD's program header table entries. Return -1 if an error
12583 occurs; bfd_get_error will return an appropriate code. */
12586 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
12588 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12590 bfd_set_error (bfd_error_wrong_format
);
12594 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
12597 /* Copy ABFD's program header table entries to *PHDRS. The entries
12598 will be stored as an array of Elf_Internal_Phdr structures, as
12599 defined in include/elf/internal.h. To find out how large the
12600 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
12602 Return the number of program header table entries read, or -1 if an
12603 error occurs; bfd_get_error will return an appropriate code. */
12606 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
12610 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12612 bfd_set_error (bfd_error_wrong_format
);
12616 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
12617 if (num_phdrs
!= 0)
12618 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
12619 num_phdrs
* sizeof (Elf_Internal_Phdr
));
12624 enum elf_reloc_type_class
12625 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12626 const asection
*rel_sec ATTRIBUTE_UNUSED
,
12627 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
12629 return reloc_class_normal
;
12632 /* For RELA architectures, return the relocation value for a
12633 relocation against a local symbol. */
12636 _bfd_elf_rela_local_sym (bfd
*abfd
,
12637 Elf_Internal_Sym
*sym
,
12639 Elf_Internal_Rela
*rel
)
12641 asection
*sec
= *psec
;
12642 bfd_vma relocation
;
12644 relocation
= (sec
->output_section
->vma
12645 + sec
->output_offset
12647 if ((sec
->flags
& SEC_MERGE
)
12648 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
12649 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12652 _bfd_merged_section_offset (abfd
, psec
,
12653 elf_section_data (sec
)->sec_info
,
12654 sym
->st_value
+ rel
->r_addend
);
12657 /* If we have changed the section, and our original section is
12658 marked with SEC_EXCLUDE, it means that the original
12659 SEC_MERGE section has been completely subsumed in some
12660 other SEC_MERGE section. In this case, we need to leave
12661 some info around for --emit-relocs. */
12662 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12663 sec
->kept_section
= *psec
;
12666 rel
->r_addend
-= relocation
;
12667 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12673 _bfd_elf_rel_local_sym (bfd
*abfd
,
12674 Elf_Internal_Sym
*sym
,
12678 asection
*sec
= *psec
;
12680 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12681 return sym
->st_value
+ addend
;
12683 return _bfd_merged_section_offset (abfd
, psec
,
12684 elf_section_data (sec
)->sec_info
,
12685 sym
->st_value
+ addend
);
12688 /* Adjust an address within a section. Given OFFSET within SEC, return
12689 the new offset within the section, based upon changes made to the
12690 section. Returns -1 if the offset is now invalid.
12691 The offset (in abnd out) is in target sized bytes, however big a
12695 _bfd_elf_section_offset (bfd
*abfd
,
12696 struct bfd_link_info
*info
,
12700 switch (sec
->sec_info_type
)
12702 case SEC_INFO_TYPE_STABS
:
12703 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12705 case SEC_INFO_TYPE_EH_FRAME
:
12706 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12709 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12711 /* Reverse the offset. */
12712 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12713 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12715 /* address_size and sec->size are in octets. Convert
12716 to bytes before subtracting the original offset. */
12717 offset
= ((sec
->size
- address_size
)
12718 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12724 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12725 reconstruct an ELF file by reading the segments out of remote memory
12726 based on the ELF file header at EHDR_VMA and the ELF program headers it
12727 points to. If not null, *LOADBASEP is filled in with the difference
12728 between the VMAs from which the segments were read, and the VMAs the
12729 file headers (and hence BFD's idea of each section's VMA) put them at.
12731 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12732 remote memory at target address VMA into the local buffer at MYADDR; it
12733 should return zero on success or an `errno' code on failure. TEMPL must
12734 be a BFD for an ELF target with the word size and byte order found in
12735 the remote memory. */
12738 bfd_elf_bfd_from_remote_memory
12741 bfd_size_type size
,
12742 bfd_vma
*loadbasep
,
12743 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12745 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12746 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12750 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12751 long symcount ATTRIBUTE_UNUSED
,
12752 asymbol
**syms ATTRIBUTE_UNUSED
,
12757 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12760 const char *relplt_name
;
12761 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
12765 Elf_Internal_Shdr
*hdr
;
12771 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12774 if (dynsymcount
<= 0)
12777 if (!bed
->plt_sym_val
)
12780 relplt_name
= bed
->relplt_name
;
12781 if (relplt_name
== NULL
)
12782 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12783 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12784 if (relplt
== NULL
)
12787 hdr
= &elf_section_data (relplt
)->this_hdr
;
12788 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12789 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12792 plt
= bfd_get_section_by_name (abfd
, ".plt");
12796 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12797 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, true))
12800 count
= relplt
->size
/ hdr
->sh_entsize
;
12801 size
= count
* sizeof (asymbol
);
12802 p
= relplt
->relocation
;
12803 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12805 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12806 if (p
->addend
!= 0)
12809 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12811 size
+= sizeof ("+0x") - 1 + 8;
12816 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12820 names
= (char *) (s
+ count
);
12821 p
= relplt
->relocation
;
12823 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12828 addr
= bed
->plt_sym_val (i
, plt
, p
);
12829 if (addr
== (bfd_vma
) -1)
12832 *s
= **p
->sym_ptr_ptr
;
12833 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12834 we are defining a symbol, ensure one of them is set. */
12835 if ((s
->flags
& BSF_LOCAL
) == 0)
12836 s
->flags
|= BSF_GLOBAL
;
12837 s
->flags
|= BSF_SYNTHETIC
;
12839 s
->value
= addr
- plt
->vma
;
12842 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12843 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12845 if (p
->addend
!= 0)
12849 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12850 names
+= sizeof ("+0x") - 1;
12851 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12852 for (a
= buf
; *a
== '0'; ++a
)
12855 memcpy (names
, a
, len
);
12858 memcpy (names
, "@plt", sizeof ("@plt"));
12859 names
+= sizeof ("@plt");
12866 /* It is only used by x86-64 so far.
12867 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12868 but current usage would allow all of _bfd_std_section to be zero. */
12869 static const asymbol lcomm_sym
12870 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12871 asection _bfd_elf_large_com_section
12872 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12873 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12876 _bfd_elf_final_write_processing (bfd
*abfd
)
12878 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12880 i_ehdrp
= elf_elfheader (abfd
);
12882 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12883 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12885 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12886 SHF_GNU_MBIND or SHF_GNU_RETAIN sections or symbols of STT_GNU_IFUNC type
12887 or STB_GNU_UNIQUE binding. */
12888 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12890 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12891 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12892 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12893 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12895 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12896 _bfd_error_handler (_("GNU_MBIND section is supported only by GNU "
12897 "and FreeBSD targets"));
12898 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12899 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is supported "
12900 "only by GNU and FreeBSD targets"));
12901 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12902 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is supported "
12903 "only by GNU and FreeBSD targets"));
12904 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_retain
)
12905 _bfd_error_handler (_("GNU_RETAIN section is supported "
12906 "only by GNU and FreeBSD targets"));
12907 bfd_set_error (bfd_error_sorry
);
12915 /* Return TRUE for ELF symbol types that represent functions.
12916 This is the default version of this function, which is sufficient for
12917 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12920 _bfd_elf_is_function_type (unsigned int type
)
12922 return (type
== STT_FUNC
12923 || type
== STT_GNU_IFUNC
);
12926 /* If the ELF symbol SYM might be a function in SEC, return the
12927 function size and set *CODE_OFF to the function's entry point,
12928 otherwise return zero. */
12931 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12934 bfd_size_type size
;
12935 elf_symbol_type
* elf_sym
= (elf_symbol_type
*) sym
;
12937 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12938 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12939 || sym
->section
!= sec
)
12942 size
= (sym
->flags
& BSF_SYNTHETIC
) ? 0 : elf_sym
->internal_elf_sym
.st_size
;
12944 /* In theory we should check that the symbol's type satisfies
12945 _bfd_elf_is_function_type(), but there are some function-like
12946 symbols which would fail this test. (eg _start). Instead
12947 we check for hidden, local, notype symbols with zero size.
12948 This type of symbol is generated by the annobin plugin for gcc
12949 and clang, and should not be considered to be a function symbol. */
12951 && ((sym
->flags
& (BSF_SYNTHETIC
| BSF_LOCAL
)) == BSF_LOCAL
)
12952 && ELF_ST_TYPE (elf_sym
->internal_elf_sym
.st_info
) == STT_NOTYPE
12953 && ELF_ST_VISIBILITY (elf_sym
->internal_elf_sym
.st_other
) == STV_HIDDEN
)
12956 *code_off
= sym
->value
;
12957 /* Do not return 0 for the function's size. */
12958 return size
? size
: 1;
12961 /* Set to non-zero to enable some debug messages. */
12962 #define DEBUG_SECONDARY_RELOCS 0
12964 /* An internal-to-the-bfd-library only section type
12965 used to indicate a cached secondary reloc section. */
12966 #define SHT_SECONDARY_RELOC (SHT_LOOS + SHT_RELA)
12968 /* Create a BFD section to hold a secondary reloc section. */
12971 _bfd_elf_init_secondary_reloc_section (bfd
* abfd
,
12972 Elf_Internal_Shdr
*hdr
,
12974 unsigned int shindex
)
12976 /* We only support RELA secondary relocs. */
12977 if (hdr
->sh_type
!= SHT_RELA
)
12980 #if DEBUG_SECONDARY_RELOCS
12981 fprintf (stderr
, "secondary reloc section %s encountered\n", name
);
12983 hdr
->sh_type
= SHT_SECONDARY_RELOC
;
12984 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
12987 /* Read in any secondary relocs associated with SEC. */
12990 _bfd_elf_slurp_secondary_reloc_section (bfd
* abfd
,
12992 asymbol
** symbols
,
12995 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12997 bool result
= true;
12998 bfd_vma (*r_sym
) (bfd_vma
);
13000 #if BFD_DEFAULT_TARGET_SIZE > 32
13001 if (bfd_arch_bits_per_address (abfd
) != 32)
13002 r_sym
= elf64_r_sym
;
13005 r_sym
= elf32_r_sym
;
13007 if (!elf_section_data (sec
)->has_secondary_relocs
)
13010 /* Discover if there are any secondary reloc sections
13011 associated with SEC. */
13012 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
13014 Elf_Internal_Shdr
* hdr
= & elf_section_data (relsec
)->this_hdr
;
13016 if (hdr
->sh_type
== SHT_SECONDARY_RELOC
13017 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
13018 && (hdr
->sh_entsize
== ebd
->s
->sizeof_rel
13019 || hdr
->sh_entsize
== ebd
->s
->sizeof_rela
))
13021 bfd_byte
* native_relocs
;
13022 bfd_byte
* native_reloc
;
13023 arelent
* internal_relocs
;
13024 arelent
* internal_reloc
;
13026 unsigned int entsize
;
13027 unsigned int symcount
;
13028 unsigned int reloc_count
;
13031 if (ebd
->elf_info_to_howto
== NULL
)
13034 #if DEBUG_SECONDARY_RELOCS
13035 fprintf (stderr
, "read secondary relocs for %s from %s\n",
13036 sec
->name
, relsec
->name
);
13038 entsize
= hdr
->sh_entsize
;
13040 native_relocs
= bfd_malloc (hdr
->sh_size
);
13041 if (native_relocs
== NULL
)
13047 reloc_count
= NUM_SHDR_ENTRIES (hdr
);
13048 if (_bfd_mul_overflow (reloc_count
, sizeof (arelent
), & amt
))
13050 free (native_relocs
);
13051 bfd_set_error (bfd_error_file_too_big
);
13056 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
13057 if (internal_relocs
== NULL
)
13059 free (native_relocs
);
13064 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
13065 || (bfd_bread (native_relocs
, hdr
->sh_size
, abfd
)
13068 free (native_relocs
);
13069 /* The internal_relocs will be freed when
13070 the memory for the bfd is released. */
13076 symcount
= bfd_get_dynamic_symcount (abfd
);
13078 symcount
= bfd_get_symcount (abfd
);
13080 for (i
= 0, internal_reloc
= internal_relocs
,
13081 native_reloc
= native_relocs
;
13083 i
++, internal_reloc
++, native_reloc
+= entsize
)
13086 Elf_Internal_Rela rela
;
13088 if (entsize
== ebd
->s
->sizeof_rel
)
13089 ebd
->s
->swap_reloc_in (abfd
, native_reloc
, & rela
);
13090 else /* entsize == ebd->s->sizeof_rela */
13091 ebd
->s
->swap_reloca_in (abfd
, native_reloc
, & rela
);
13093 /* The address of an ELF reloc is section relative for an object
13094 file, and absolute for an executable file or shared library.
13095 The address of a normal BFD reloc is always section relative,
13096 and the address of a dynamic reloc is absolute.. */
13097 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
13098 internal_reloc
->address
= rela
.r_offset
;
13100 internal_reloc
->address
= rela
.r_offset
- sec
->vma
;
13102 if (r_sym (rela
.r_info
) == STN_UNDEF
)
13104 /* FIXME: This and the error case below mean that we
13105 have a symbol on relocs that is not elf_symbol_type. */
13106 internal_reloc
->sym_ptr_ptr
=
13107 bfd_abs_section_ptr
->symbol_ptr_ptr
;
13109 else if (r_sym (rela
.r_info
) > symcount
)
13112 /* xgettext:c-format */
13113 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
13114 abfd
, sec
, i
, (long) r_sym (rela
.r_info
));
13115 bfd_set_error (bfd_error_bad_value
);
13116 internal_reloc
->sym_ptr_ptr
=
13117 bfd_abs_section_ptr
->symbol_ptr_ptr
;
13124 ps
= symbols
+ r_sym (rela
.r_info
) - 1;
13125 internal_reloc
->sym_ptr_ptr
= ps
;
13126 /* Make sure that this symbol is not removed by strip. */
13127 (*ps
)->flags
|= BSF_KEEP
;
13130 internal_reloc
->addend
= rela
.r_addend
;
13132 res
= ebd
->elf_info_to_howto (abfd
, internal_reloc
, & rela
);
13133 if (! res
|| internal_reloc
->howto
== NULL
)
13135 #if DEBUG_SECONDARY_RELOCS
13136 fprintf (stderr
, "there is no howto associated with reloc %lx\n",
13143 free (native_relocs
);
13144 /* Store the internal relocs. */
13145 elf_section_data (relsec
)->sec_info
= internal_relocs
;
13152 /* Set the ELF section header fields of an output secondary reloc section. */
13155 _bfd_elf_copy_special_section_fields (const bfd
* ibfd ATTRIBUTE_UNUSED
,
13156 bfd
* obfd ATTRIBUTE_UNUSED
,
13157 const Elf_Internal_Shdr
* isection
,
13158 Elf_Internal_Shdr
* osection
)
13162 struct bfd_elf_section_data
* esd
;
13164 if (isection
== NULL
)
13167 if (isection
->sh_type
!= SHT_SECONDARY_RELOC
)
13170 isec
= isection
->bfd_section
;
13174 osec
= osection
->bfd_section
;
13178 esd
= elf_section_data (osec
);
13179 BFD_ASSERT (esd
->sec_info
== NULL
);
13180 esd
->sec_info
= elf_section_data (isec
)->sec_info
;
13181 osection
->sh_type
= SHT_RELA
;
13182 osection
->sh_link
= elf_onesymtab (obfd
);
13183 if (osection
->sh_link
== 0)
13185 /* There is no symbol table - we are hosed... */
13187 /* xgettext:c-format */
13188 (_("%pB(%pA): link section cannot be set because the output file does not have a symbol table"),
13190 bfd_set_error (bfd_error_bad_value
);
13194 /* Find the output section that corresponds to the isection's sh_info link. */
13195 if (isection
->sh_info
== 0
13196 || isection
->sh_info
>= elf_numsections (ibfd
))
13199 /* xgettext:c-format */
13200 (_("%pB(%pA): info section index is invalid"),
13202 bfd_set_error (bfd_error_bad_value
);
13206 isection
= elf_elfsections (ibfd
)[isection
->sh_info
];
13208 if (isection
== NULL
13209 || isection
->bfd_section
== NULL
13210 || isection
->bfd_section
->output_section
== NULL
)
13213 /* xgettext:c-format */
13214 (_("%pB(%pA): info section index cannot be set because the section is not in the output"),
13216 bfd_set_error (bfd_error_bad_value
);
13220 esd
= elf_section_data (isection
->bfd_section
->output_section
);
13221 BFD_ASSERT (esd
!= NULL
);
13222 osection
->sh_info
= esd
->this_idx
;
13223 esd
->has_secondary_relocs
= true;
13224 #if DEBUG_SECONDARY_RELOCS
13225 fprintf (stderr
, "update header of %s, sh_link = %u, sh_info = %u\n",
13226 osec
->name
, osection
->sh_link
, osection
->sh_info
);
13227 fprintf (stderr
, "mark section %s as having secondary relocs\n",
13228 bfd_section_name (isection
->bfd_section
->output_section
));
13234 /* Write out a secondary reloc section.
13236 FIXME: Currently this function can result in a serious performance penalty
13237 for files with secondary relocs and lots of sections. The proper way to
13238 fix this is for _bfd_elf_copy_special_section_fields() to chain secondary
13239 relocs together and then to have this function just walk that chain. */
13242 _bfd_elf_write_secondary_reloc_section (bfd
*abfd
, asection
*sec
)
13244 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
13245 bfd_vma addr_offset
;
13247 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
13248 bool result
= true;
13253 #if BFD_DEFAULT_TARGET_SIZE > 32
13254 if (bfd_arch_bits_per_address (abfd
) != 32)
13255 r_info
= elf64_r_info
;
13258 r_info
= elf32_r_info
;
13260 /* The address of an ELF reloc is section relative for an object
13261 file, and absolute for an executable file or shared library.
13262 The address of a BFD reloc is always section relative. */
13264 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
13265 addr_offset
= sec
->vma
;
13267 /* Discover if there are any secondary reloc sections
13268 associated with SEC. */
13269 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
13271 const struct bfd_elf_section_data
* const esd
= elf_section_data (relsec
);
13272 Elf_Internal_Shdr
* const hdr
= (Elf_Internal_Shdr
*) & esd
->this_hdr
;
13274 if (hdr
->sh_type
== SHT_RELA
13275 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
)
13277 asymbol
* last_sym
;
13279 unsigned int reloc_count
;
13281 unsigned int entsize
;
13282 arelent
* src_irel
;
13283 bfd_byte
* dst_rela
;
13285 if (hdr
->contents
!= NULL
)
13288 /* xgettext:c-format */
13289 (_("%pB(%pA): error: secondary reloc section processed twice"),
13291 bfd_set_error (bfd_error_bad_value
);
13296 entsize
= hdr
->sh_entsize
;
13300 /* xgettext:c-format */
13301 (_("%pB(%pA): error: secondary reloc section has zero sized entries"),
13303 bfd_set_error (bfd_error_bad_value
);
13307 else if (entsize
!= ebd
->s
->sizeof_rel
13308 && entsize
!= ebd
->s
->sizeof_rela
)
13311 /* xgettext:c-format */
13312 (_("%pB(%pA): error: secondary reloc section has non-standard sized entries"),
13314 bfd_set_error (bfd_error_bad_value
);
13319 reloc_count
= hdr
->sh_size
/ entsize
;
13320 if (reloc_count
<= 0)
13323 /* xgettext:c-format */
13324 (_("%pB(%pA): error: secondary reloc section is empty!"),
13326 bfd_set_error (bfd_error_bad_value
);
13331 hdr
->contents
= bfd_alloc (abfd
, hdr
->sh_size
);
13332 if (hdr
->contents
== NULL
)
13335 #if DEBUG_SECONDARY_RELOCS
13336 fprintf (stderr
, "write %u secondary relocs for %s from %s\n",
13337 reloc_count
, sec
->name
, relsec
->name
);
13341 dst_rela
= hdr
->contents
;
13342 src_irel
= (arelent
*) esd
->sec_info
;
13343 if (src_irel
== NULL
)
13346 /* xgettext:c-format */
13347 (_("%pB(%pA): error: internal relocs missing for secondary reloc section"),
13349 bfd_set_error (bfd_error_bad_value
);
13354 for (idx
= 0; idx
< reloc_count
; idx
++, dst_rela
+= entsize
)
13356 Elf_Internal_Rela src_rela
;
13361 ptr
= src_irel
+ idx
;
13365 /* xgettext:c-format */
13366 (_("%pB(%pA): error: reloc table entry %u is empty"),
13367 abfd
, relsec
, idx
);
13368 bfd_set_error (bfd_error_bad_value
);
13373 if (ptr
->sym_ptr_ptr
== NULL
)
13375 /* FIXME: Is this an error ? */
13380 sym
= *ptr
->sym_ptr_ptr
;
13382 if (sym
== last_sym
)
13386 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, & sym
);
13390 /* xgettext:c-format */
13391 (_("%pB(%pA): error: secondary reloc %u references a missing symbol"),
13392 abfd
, relsec
, idx
);
13393 bfd_set_error (bfd_error_bad_value
);
13402 if (sym
->the_bfd
!= NULL
13403 && sym
->the_bfd
->xvec
!= abfd
->xvec
13404 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
13407 /* xgettext:c-format */
13408 (_("%pB(%pA): error: secondary reloc %u references a deleted symbol"),
13409 abfd
, relsec
, idx
);
13410 bfd_set_error (bfd_error_bad_value
);
13416 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
13417 if (ptr
->howto
== NULL
)
13420 /* xgettext:c-format */
13421 (_("%pB(%pA): error: secondary reloc %u is of an unknown type"),
13422 abfd
, relsec
, idx
);
13423 bfd_set_error (bfd_error_bad_value
);
13425 src_rela
.r_info
= r_info (0, 0);
13428 src_rela
.r_info
= r_info (n
, ptr
->howto
->type
);
13429 src_rela
.r_addend
= ptr
->addend
;
13431 if (entsize
== ebd
->s
->sizeof_rel
)
13432 ebd
->s
->swap_reloc_out (abfd
, &src_rela
, dst_rela
);
13433 else /* entsize == ebd->s->sizeof_rela */
13434 ebd
->s
->swap_reloca_out (abfd
, &src_rela
, dst_rela
);