1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2021 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_PLTREL
: name
= "PLTREL"; break;
1777 case DT_DEBUG
: name
= "DEBUG"; break;
1778 case DT_TEXTREL
: name
= "TEXTREL"; break;
1779 case DT_JMPREL
: name
= "JMPREL"; break;
1780 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1781 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1782 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1783 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1784 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1785 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= true; break;
1786 case DT_FLAGS
: name
= "FLAGS"; break;
1787 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1788 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1789 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1790 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1791 case DT_MOVEENT
: name
= "MOVEENT"; break;
1792 case DT_MOVESZ
: name
= "MOVESZ"; break;
1793 case DT_FEATURE
: name
= "FEATURE"; break;
1794 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1795 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1796 case DT_SYMINENT
: name
= "SYMINENT"; break;
1797 case DT_CONFIG
: name
= "CONFIG"; stringp
= true; break;
1798 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= true; break;
1799 case DT_AUDIT
: name
= "AUDIT"; stringp
= true; break;
1800 case DT_PLTPAD
: name
= "PLTPAD"; break;
1801 case DT_MOVETAB
: name
= "MOVETAB"; break;
1802 case DT_SYMINFO
: name
= "SYMINFO"; break;
1803 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1804 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1805 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1806 case DT_VERSYM
: name
= "VERSYM"; break;
1807 case DT_VERDEF
: name
= "VERDEF"; break;
1808 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1809 case DT_VERNEED
: name
= "VERNEED"; break;
1810 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1811 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
1812 case DT_USED
: name
= "USED"; break;
1813 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
1814 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1817 fprintf (f
, " %-20s ", name
);
1821 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1826 unsigned int tagv
= dyn
.d_un
.d_val
;
1828 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1831 fprintf (f
, "%s", string
);
1840 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1841 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1843 if (! _bfd_elf_slurp_version_tables (abfd
, false))
1847 if (elf_dynverdef (abfd
) != 0)
1849 Elf_Internal_Verdef
*t
;
1851 fprintf (f
, _("\nVersion definitions:\n"));
1852 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1854 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1855 t
->vd_flags
, t
->vd_hash
,
1856 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1857 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1859 Elf_Internal_Verdaux
*a
;
1862 for (a
= t
->vd_auxptr
->vda_nextptr
;
1866 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1872 if (elf_dynverref (abfd
) != 0)
1874 Elf_Internal_Verneed
*t
;
1876 fprintf (f
, _("\nVersion References:\n"));
1877 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1879 Elf_Internal_Vernaux
*a
;
1881 fprintf (f
, _(" required from %s:\n"),
1882 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1883 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1884 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1885 a
->vna_flags
, a
->vna_other
,
1886 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1897 /* Get version name. If BASE_P is TRUE, return "Base" for VER_FLG_BASE
1898 and return symbol version for symbol version itself. */
1901 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1905 const char *version_string
= NULL
;
1906 if (elf_dynversym (abfd
) != 0
1907 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1909 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1911 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1912 vernum
&= VERSYM_VERSION
;
1915 version_string
= "";
1916 else if (vernum
== 1
1917 && (vernum
> elf_tdata (abfd
)->cverdefs
1918 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1920 version_string
= base_p
? "Base" : "";
1921 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1923 const char *nodename
1924 = elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1925 version_string
= "";
1928 || symbol
->name
== NULL
1929 || strcmp (symbol
->name
, nodename
) != 0)
1930 version_string
= nodename
;
1934 Elf_Internal_Verneed
*t
;
1936 version_string
= _("<corrupt>");
1937 for (t
= elf_tdata (abfd
)->verref
;
1941 Elf_Internal_Vernaux
*a
;
1943 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1945 if (a
->vna_other
== vernum
)
1947 version_string
= a
->vna_nodename
;
1954 return version_string
;
1957 /* Display ELF-specific fields of a symbol. */
1960 bfd_elf_print_symbol (bfd
*abfd
,
1963 bfd_print_symbol_type how
)
1965 FILE *file
= (FILE *) filep
;
1968 case bfd_print_symbol_name
:
1969 fprintf (file
, "%s", symbol
->name
);
1971 case bfd_print_symbol_more
:
1972 fprintf (file
, "elf ");
1973 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1974 fprintf (file
, " %x", symbol
->flags
);
1976 case bfd_print_symbol_all
:
1978 const char *section_name
;
1979 const char *name
= NULL
;
1980 const struct elf_backend_data
*bed
;
1981 unsigned char st_other
;
1983 const char *version_string
;
1986 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1988 bed
= get_elf_backend_data (abfd
);
1989 if (bed
->elf_backend_print_symbol_all
)
1990 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1994 name
= symbol
->name
;
1995 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1998 fprintf (file
, " %s\t", section_name
);
1999 /* Print the "other" value for a symbol. For common symbols,
2000 we've already printed the size; now print the alignment.
2001 For other symbols, we have no specified alignment, and
2002 we've printed the address; now print the size. */
2003 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
2004 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
2006 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
2007 bfd_fprintf_vma (abfd
, file
, val
);
2009 /* If we have version information, print it. */
2010 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
2017 fprintf (file
, " %-11s", version_string
);
2022 fprintf (file
, " (%s)", version_string
);
2023 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
2028 /* If the st_other field is not zero, print it. */
2029 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
2034 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
2035 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
2036 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
2038 /* Some other non-defined flags are also present, so print
2040 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
2043 fprintf (file
, " %s", name
);
2049 /* ELF .o/exec file reading */
2051 /* Create a new bfd section from an ELF section header. */
2054 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2056 Elf_Internal_Shdr
*hdr
;
2057 Elf_Internal_Ehdr
*ehdr
;
2058 const struct elf_backend_data
*bed
;
2062 if (shindex
>= elf_numsections (abfd
))
2065 /* PR17512: A corrupt ELF binary might contain a loop of sections via
2066 sh_link or sh_info. Detect this here, by refusing to load a
2067 section that we are already in the process of loading. */
2068 if (elf_tdata (abfd
)->being_created
[shindex
])
2071 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2074 elf_tdata (abfd
)->being_created
[shindex
] = true;
2076 hdr
= elf_elfsections (abfd
)[shindex
];
2077 ehdr
= elf_elfheader (abfd
);
2078 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2083 bed
= get_elf_backend_data (abfd
);
2084 switch (hdr
->sh_type
)
2087 /* Inactive section. Throw it away. */
2090 case SHT_PROGBITS
: /* Normal section with contents. */
2091 case SHT_NOBITS
: /* .bss section. */
2092 case SHT_HASH
: /* .hash section. */
2093 case SHT_NOTE
: /* .note section. */
2094 case SHT_INIT_ARRAY
: /* .init_array section. */
2095 case SHT_FINI_ARRAY
: /* .fini_array section. */
2096 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2097 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2098 case SHT_GNU_HASH
: /* .gnu.hash section. */
2099 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2102 case SHT_DYNAMIC
: /* Dynamic linking information. */
2103 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2106 if (hdr
->sh_link
> elf_numsections (abfd
))
2108 /* PR 10478: Accept Solaris binaries with a sh_link
2109 field set to SHN_BEFORE or SHN_AFTER. */
2110 switch (bfd_get_arch (abfd
))
2113 case bfd_arch_sparc
:
2114 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2115 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2117 /* Otherwise fall through. */
2122 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2124 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2126 Elf_Internal_Shdr
*dynsymhdr
;
2128 /* The shared libraries distributed with hpux11 have a bogus
2129 sh_link field for the ".dynamic" section. Find the
2130 string table for the ".dynsym" section instead. */
2131 if (elf_dynsymtab (abfd
) != 0)
2133 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2134 hdr
->sh_link
= dynsymhdr
->sh_link
;
2138 unsigned int i
, num_sec
;
2140 num_sec
= elf_numsections (abfd
);
2141 for (i
= 1; i
< num_sec
; i
++)
2143 dynsymhdr
= elf_elfsections (abfd
)[i
];
2144 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2146 hdr
->sh_link
= dynsymhdr
->sh_link
;
2154 case SHT_SYMTAB
: /* A symbol table. */
2155 if (elf_onesymtab (abfd
) == shindex
)
2158 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2161 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2163 if (hdr
->sh_size
!= 0)
2165 /* Some assemblers erroneously set sh_info to one with a
2166 zero sh_size. ld sees this as a global symbol count
2167 of (unsigned) -1. Fix it here. */
2172 /* PR 18854: A binary might contain more than one symbol table.
2173 Unusual, but possible. Warn, but continue. */
2174 if (elf_onesymtab (abfd
) != 0)
2177 /* xgettext:c-format */
2178 (_("%pB: warning: multiple symbol tables detected"
2179 " - ignoring the table in section %u"),
2183 elf_onesymtab (abfd
) = shindex
;
2184 elf_symtab_hdr (abfd
) = *hdr
;
2185 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2186 abfd
->flags
|= HAS_SYMS
;
2188 /* Sometimes a shared object will map in the symbol table. If
2189 SHF_ALLOC is set, and this is a shared object, then we also
2190 treat this section as a BFD section. We can not base the
2191 decision purely on SHF_ALLOC, because that flag is sometimes
2192 set in a relocatable object file, which would confuse the
2194 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2195 && (abfd
->flags
& DYNAMIC
) != 0
2196 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2200 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2201 can't read symbols without that section loaded as well. It
2202 is most likely specified by the next section header. */
2204 elf_section_list
* entry
;
2205 unsigned int i
, num_sec
;
2207 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2208 if (entry
->hdr
.sh_link
== shindex
)
2211 num_sec
= elf_numsections (abfd
);
2212 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2214 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2216 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2217 && hdr2
->sh_link
== shindex
)
2222 for (i
= 1; i
< shindex
; i
++)
2224 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2226 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2227 && hdr2
->sh_link
== shindex
)
2232 ret
= bfd_section_from_shdr (abfd
, i
);
2233 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2237 case SHT_DYNSYM
: /* A dynamic symbol table. */
2238 if (elf_dynsymtab (abfd
) == shindex
)
2241 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2244 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2246 if (hdr
->sh_size
!= 0)
2249 /* Some linkers erroneously set sh_info to one with a
2250 zero sh_size. ld sees this as a global symbol count
2251 of (unsigned) -1. Fix it here. */
2256 /* PR 18854: A binary might contain more than one dynamic symbol table.
2257 Unusual, but possible. Warn, but continue. */
2258 if (elf_dynsymtab (abfd
) != 0)
2261 /* xgettext:c-format */
2262 (_("%pB: warning: multiple dynamic symbol tables detected"
2263 " - ignoring the table in section %u"),
2267 elf_dynsymtab (abfd
) = shindex
;
2268 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2269 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2270 abfd
->flags
|= HAS_SYMS
;
2272 /* Besides being a symbol table, we also treat this as a regular
2273 section, so that objcopy can handle it. */
2274 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2277 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2279 elf_section_list
* entry
;
2281 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2282 if (entry
->ndx
== shindex
)
2285 entry
= bfd_alloc (abfd
, sizeof (*entry
));
2288 entry
->ndx
= shindex
;
2290 entry
->next
= elf_symtab_shndx_list (abfd
);
2291 elf_symtab_shndx_list (abfd
) = entry
;
2292 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2296 case SHT_STRTAB
: /* A string table. */
2297 if (hdr
->bfd_section
!= NULL
)
2300 if (ehdr
->e_shstrndx
== shindex
)
2302 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2303 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2307 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2310 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2311 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2315 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2318 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2319 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2320 elf_elfsections (abfd
)[shindex
] = hdr
;
2321 /* We also treat this as a regular section, so that objcopy
2323 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2328 /* If the string table isn't one of the above, then treat it as a
2329 regular section. We need to scan all the headers to be sure,
2330 just in case this strtab section appeared before the above. */
2331 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2333 unsigned int i
, num_sec
;
2335 num_sec
= elf_numsections (abfd
);
2336 for (i
= 1; i
< num_sec
; i
++)
2338 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2339 if (hdr2
->sh_link
== shindex
)
2341 /* Prevent endless recursion on broken objects. */
2344 if (! bfd_section_from_shdr (abfd
, i
))
2346 if (elf_onesymtab (abfd
) == i
)
2348 if (elf_dynsymtab (abfd
) == i
)
2349 goto dynsymtab_strtab
;
2353 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2358 /* *These* do a lot of work -- but build no sections! */
2360 asection
*target_sect
;
2361 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2362 unsigned int num_sec
= elf_numsections (abfd
);
2363 struct bfd_elf_section_data
*esdt
;
2366 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2367 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2370 /* Check for a bogus link to avoid crashing. */
2371 if (hdr
->sh_link
>= num_sec
)
2374 /* xgettext:c-format */
2375 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2376 abfd
, hdr
->sh_link
, name
, shindex
);
2377 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2382 /* For some incomprehensible reason Oracle distributes
2383 libraries for Solaris in which some of the objects have
2384 bogus sh_link fields. It would be nice if we could just
2385 reject them, but, unfortunately, some people need to use
2386 them. We scan through the section headers; if we find only
2387 one suitable symbol table, we clobber the sh_link to point
2388 to it. I hope this doesn't break anything.
2390 Don't do it on executable nor shared library. */
2391 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2392 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2393 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2399 for (scan
= 1; scan
< num_sec
; scan
++)
2401 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2402 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2413 hdr
->sh_link
= found
;
2416 /* Get the symbol table. */
2417 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2418 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2419 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2422 /* If this is an alloc section in an executable or shared
2423 library, or the reloc section does not use the main symbol
2424 table we don't treat it as a reloc section. BFD can't
2425 adequately represent such a section, so at least for now,
2426 we don't try. We just present it as a normal section. We
2427 also can't use it as a reloc section if it points to the
2428 null section, an invalid section, another reloc section, or
2429 its sh_link points to the null section. */
2430 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2431 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2432 || hdr
->sh_link
== SHN_UNDEF
2433 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2434 || hdr
->sh_info
== SHN_UNDEF
2435 || hdr
->sh_info
>= num_sec
2436 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2437 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2439 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2444 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2447 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2448 if (target_sect
== NULL
)
2451 esdt
= elf_section_data (target_sect
);
2452 if (hdr
->sh_type
== SHT_RELA
)
2453 p_hdr
= &esdt
->rela
.hdr
;
2455 p_hdr
= &esdt
->rel
.hdr
;
2457 /* PR 17512: file: 0b4f81b7.
2458 Also see PR 24456, for a file which deliberately has two reloc
2462 if (!bed
->init_secondary_reloc_section (abfd
, hdr
, name
, shindex
))
2465 /* xgettext:c-format */
2466 (_("%pB: warning: secondary relocation section '%s' "
2467 "for section %pA found - ignoring"),
2468 abfd
, name
, target_sect
);
2473 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2478 elf_elfsections (abfd
)[shindex
] = hdr2
;
2479 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2480 * bed
->s
->int_rels_per_ext_rel
);
2481 target_sect
->flags
|= SEC_RELOC
;
2482 target_sect
->relocation
= NULL
;
2483 target_sect
->rel_filepos
= hdr
->sh_offset
;
2484 /* In the section to which the relocations apply, mark whether
2485 its relocations are of the REL or RELA variety. */
2486 if (hdr
->sh_size
!= 0)
2488 if (hdr
->sh_type
== SHT_RELA
)
2489 target_sect
->use_rela_p
= 1;
2491 abfd
->flags
|= HAS_RELOC
;
2495 case SHT_GNU_verdef
:
2496 elf_dynverdef (abfd
) = shindex
;
2497 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2498 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2501 case SHT_GNU_versym
:
2502 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2505 elf_dynversym (abfd
) = shindex
;
2506 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2507 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2510 case SHT_GNU_verneed
:
2511 elf_dynverref (abfd
) = shindex
;
2512 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2513 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2520 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2523 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2529 /* Possibly an attributes section. */
2530 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2531 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2533 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2535 _bfd_elf_parse_attributes (abfd
, hdr
);
2539 /* Check for any processor-specific section types. */
2540 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2543 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2545 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2546 /* FIXME: How to properly handle allocated section reserved
2547 for applications? */
2549 /* xgettext:c-format */
2550 (_("%pB: unknown type [%#x] section `%s'"),
2551 abfd
, hdr
->sh_type
, name
);
2554 /* Allow sections reserved for applications. */
2555 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2560 else if (hdr
->sh_type
>= SHT_LOPROC
2561 && hdr
->sh_type
<= SHT_HIPROC
)
2562 /* FIXME: We should handle this section. */
2564 /* xgettext:c-format */
2565 (_("%pB: unknown type [%#x] section `%s'"),
2566 abfd
, hdr
->sh_type
, name
);
2567 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2569 /* Unrecognised OS-specific sections. */
2570 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2571 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2572 required to correctly process the section and the file should
2573 be rejected with an error message. */
2575 /* xgettext:c-format */
2576 (_("%pB: unknown type [%#x] section `%s'"),
2577 abfd
, hdr
->sh_type
, name
);
2580 /* Otherwise it should be processed. */
2581 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2586 /* FIXME: We should handle this section. */
2588 /* xgettext:c-format */
2589 (_("%pB: unknown type [%#x] section `%s'"),
2590 abfd
, hdr
->sh_type
, name
);
2598 elf_tdata (abfd
)->being_created
[shindex
] = false;
2602 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2605 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2607 unsigned long r_symndx
)
2609 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2611 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2613 Elf_Internal_Shdr
*symtab_hdr
;
2614 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2615 Elf_External_Sym_Shndx eshndx
;
2617 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2618 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2619 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2622 if (cache
->abfd
!= abfd
)
2624 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2627 cache
->indx
[ent
] = r_symndx
;
2630 return &cache
->sym
[ent
];
2633 /* Given an ELF section number, retrieve the corresponding BFD
2637 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2639 if (sec_index
>= elf_numsections (abfd
))
2641 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2644 static const struct bfd_elf_special_section special_sections_b
[] =
2646 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2647 { NULL
, 0, 0, 0, 0 }
2650 static const struct bfd_elf_special_section special_sections_c
[] =
2652 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2653 { STRING_COMMA_LEN (".ctf"), 0, SHT_PROGBITS
, 0 },
2654 { NULL
, 0, 0, 0, 0 }
2657 static const struct bfd_elf_special_section special_sections_d
[] =
2659 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2660 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2661 /* There are more DWARF sections than these, but they needn't be added here
2662 unless you have to cope with broken compilers that don't emit section
2663 attributes or you want to help the user writing assembler. */
2664 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2665 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2666 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2667 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2668 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2669 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2670 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2671 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2672 { NULL
, 0, 0, 0, 0 }
2675 static const struct bfd_elf_special_section special_sections_f
[] =
2677 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2678 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2679 { NULL
, 0 , 0, 0, 0 }
2682 static const struct bfd_elf_special_section special_sections_g
[] =
2684 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2685 { STRING_COMMA_LEN (".gnu.linkonce.n"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2686 { STRING_COMMA_LEN (".gnu.linkonce.p"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2687 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2688 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2689 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2690 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2691 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2692 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2693 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2694 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2695 { NULL
, 0, 0, 0, 0 }
2698 static const struct bfd_elf_special_section special_sections_h
[] =
2700 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2701 { NULL
, 0, 0, 0, 0 }
2704 static const struct bfd_elf_special_section special_sections_i
[] =
2706 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2707 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2708 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2709 { NULL
, 0, 0, 0, 0 }
2712 static const struct bfd_elf_special_section special_sections_l
[] =
2714 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2715 { NULL
, 0, 0, 0, 0 }
2718 static const struct bfd_elf_special_section special_sections_n
[] =
2720 { STRING_COMMA_LEN (".noinit"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2721 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2722 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2723 { NULL
, 0, 0, 0, 0 }
2726 static const struct bfd_elf_special_section special_sections_p
[] =
2728 { STRING_COMMA_LEN (".persistent.bss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2729 { STRING_COMMA_LEN (".persistent"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2730 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2731 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2732 { NULL
, 0, 0, 0, 0 }
2735 static const struct bfd_elf_special_section special_sections_r
[] =
2737 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2738 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2739 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2740 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2741 { NULL
, 0, 0, 0, 0 }
2744 static const struct bfd_elf_special_section special_sections_s
[] =
2746 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2747 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2748 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2749 /* See struct bfd_elf_special_section declaration for the semantics of
2750 this special case where .prefix_length != strlen (.prefix). */
2751 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2752 { NULL
, 0, 0, 0, 0 }
2755 static const struct bfd_elf_special_section special_sections_t
[] =
2757 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2758 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2759 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2760 { NULL
, 0, 0, 0, 0 }
2763 static const struct bfd_elf_special_section special_sections_z
[] =
2765 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2766 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2767 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2768 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2769 { NULL
, 0, 0, 0, 0 }
2772 static const struct bfd_elf_special_section
* const special_sections
[] =
2774 special_sections_b
, /* 'b' */
2775 special_sections_c
, /* 'c' */
2776 special_sections_d
, /* 'd' */
2778 special_sections_f
, /* 'f' */
2779 special_sections_g
, /* 'g' */
2780 special_sections_h
, /* 'h' */
2781 special_sections_i
, /* 'i' */
2784 special_sections_l
, /* 'l' */
2786 special_sections_n
, /* 'n' */
2788 special_sections_p
, /* 'p' */
2790 special_sections_r
, /* 'r' */
2791 special_sections_s
, /* 's' */
2792 special_sections_t
, /* 't' */
2798 special_sections_z
/* 'z' */
2801 const struct bfd_elf_special_section
*
2802 _bfd_elf_get_special_section (const char *name
,
2803 const struct bfd_elf_special_section
*spec
,
2809 len
= strlen (name
);
2811 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2814 int prefix_len
= spec
[i
].prefix_length
;
2816 if (len
< prefix_len
)
2818 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2821 suffix_len
= spec
[i
].suffix_length
;
2822 if (suffix_len
<= 0)
2824 if (name
[prefix_len
] != 0)
2826 if (suffix_len
== 0)
2828 if (name
[prefix_len
] != '.'
2829 && (suffix_len
== -2
2830 || (rela
&& spec
[i
].type
== SHT_REL
)))
2836 if (len
< prefix_len
+ suffix_len
)
2838 if (memcmp (name
+ len
- suffix_len
,
2839 spec
[i
].prefix
+ prefix_len
,
2849 const struct bfd_elf_special_section
*
2850 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2853 const struct bfd_elf_special_section
*spec
;
2854 const struct elf_backend_data
*bed
;
2856 /* See if this is one of the special sections. */
2857 if (sec
->name
== NULL
)
2860 bed
= get_elf_backend_data (abfd
);
2861 spec
= bed
->special_sections
;
2864 spec
= _bfd_elf_get_special_section (sec
->name
,
2865 bed
->special_sections
,
2871 if (sec
->name
[0] != '.')
2874 i
= sec
->name
[1] - 'b';
2875 if (i
< 0 || i
> 'z' - 'b')
2878 spec
= special_sections
[i
];
2883 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2887 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2889 struct bfd_elf_section_data
*sdata
;
2890 const struct elf_backend_data
*bed
;
2891 const struct bfd_elf_special_section
*ssect
;
2893 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2896 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2900 sec
->used_by_bfd
= sdata
;
2903 /* Indicate whether or not this section should use RELA relocations. */
2904 bed
= get_elf_backend_data (abfd
);
2905 sec
->use_rela_p
= bed
->default_use_rela_p
;
2907 /* Set up ELF section type and flags for newly created sections, if
2908 there is an ABI mandated section. */
2909 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2912 elf_section_type (sec
) = ssect
->type
;
2913 elf_section_flags (sec
) = ssect
->attr
;
2916 return _bfd_generic_new_section_hook (abfd
, sec
);
2919 /* Create a new bfd section from an ELF program header.
2921 Since program segments have no names, we generate a synthetic name
2922 of the form segment<NUM>, where NUM is generally the index in the
2923 program header table. For segments that are split (see below) we
2924 generate the names segment<NUM>a and segment<NUM>b.
2926 Note that some program segments may have a file size that is different than
2927 (less than) the memory size. All this means is that at execution the
2928 system must allocate the amount of memory specified by the memory size,
2929 but only initialize it with the first "file size" bytes read from the
2930 file. This would occur for example, with program segments consisting
2931 of combined data+bss.
2933 To handle the above situation, this routine generates TWO bfd sections
2934 for the single program segment. The first has the length specified by
2935 the file size of the segment, and the second has the length specified
2936 by the difference between the two sizes. In effect, the segment is split
2937 into its initialized and uninitialized parts.
2942 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2943 Elf_Internal_Phdr
*hdr
,
2945 const char *type_name
)
2952 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
2954 split
= ((hdr
->p_memsz
> 0)
2955 && (hdr
->p_filesz
> 0)
2956 && (hdr
->p_memsz
> hdr
->p_filesz
));
2958 if (hdr
->p_filesz
> 0)
2960 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2961 len
= strlen (namebuf
) + 1;
2962 name
= (char *) bfd_alloc (abfd
, len
);
2965 memcpy (name
, namebuf
, len
);
2966 newsect
= bfd_make_section (abfd
, name
);
2967 if (newsect
== NULL
)
2969 newsect
->vma
= hdr
->p_vaddr
/ opb
;
2970 newsect
->lma
= hdr
->p_paddr
/ opb
;
2971 newsect
->size
= hdr
->p_filesz
;
2972 newsect
->filepos
= hdr
->p_offset
;
2973 newsect
->flags
|= SEC_HAS_CONTENTS
;
2974 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2975 if (hdr
->p_type
== PT_LOAD
)
2977 newsect
->flags
|= SEC_ALLOC
;
2978 newsect
->flags
|= SEC_LOAD
;
2979 if (hdr
->p_flags
& PF_X
)
2981 /* FIXME: all we known is that it has execute PERMISSION,
2983 newsect
->flags
|= SEC_CODE
;
2986 if (!(hdr
->p_flags
& PF_W
))
2988 newsect
->flags
|= SEC_READONLY
;
2992 if (hdr
->p_memsz
> hdr
->p_filesz
)
2996 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2997 len
= strlen (namebuf
) + 1;
2998 name
= (char *) bfd_alloc (abfd
, len
);
3001 memcpy (name
, namebuf
, len
);
3002 newsect
= bfd_make_section (abfd
, name
);
3003 if (newsect
== NULL
)
3005 newsect
->vma
= (hdr
->p_vaddr
+ hdr
->p_filesz
) / opb
;
3006 newsect
->lma
= (hdr
->p_paddr
+ hdr
->p_filesz
) / opb
;
3007 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
3008 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
3009 align
= newsect
->vma
& -newsect
->vma
;
3010 if (align
== 0 || align
> hdr
->p_align
)
3011 align
= hdr
->p_align
;
3012 newsect
->alignment_power
= bfd_log2 (align
);
3013 if (hdr
->p_type
== PT_LOAD
)
3015 newsect
->flags
|= SEC_ALLOC
;
3016 if (hdr
->p_flags
& PF_X
)
3017 newsect
->flags
|= SEC_CODE
;
3019 if (!(hdr
->p_flags
& PF_W
))
3020 newsect
->flags
|= SEC_READONLY
;
3027 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3029 /* The return value is ignored. Build-ids are considered optional. */
3030 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3031 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3037 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3039 const struct elf_backend_data
*bed
;
3041 switch (hdr
->p_type
)
3044 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3047 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3049 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3050 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3054 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3057 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3060 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3062 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3068 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3071 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3073 case PT_GNU_EH_FRAME
:
3074 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3078 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3081 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3084 /* Check for any processor-specific program segment types. */
3085 bed
= get_elf_backend_data (abfd
);
3086 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3090 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3094 _bfd_elf_single_rel_hdr (asection
*sec
)
3096 if (elf_section_data (sec
)->rel
.hdr
)
3098 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3099 return elf_section_data (sec
)->rel
.hdr
;
3102 return elf_section_data (sec
)->rela
.hdr
;
3106 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3107 Elf_Internal_Shdr
*rel_hdr
,
3108 const char *sec_name
,
3111 char *name
= (char *) bfd_alloc (abfd
,
3112 sizeof ".rela" + strlen (sec_name
));
3116 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3118 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3120 if (rel_hdr
->sh_name
== (unsigned int) -1)
3126 /* Allocate and initialize a section-header for a new reloc section,
3127 containing relocations against ASECT. It is stored in RELDATA. If
3128 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3132 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3133 struct bfd_elf_section_reloc_data
*reldata
,
3134 const char *sec_name
,
3136 bool delay_st_name_p
)
3138 Elf_Internal_Shdr
*rel_hdr
;
3139 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3141 BFD_ASSERT (reldata
->hdr
== NULL
);
3142 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3143 reldata
->hdr
= rel_hdr
;
3145 if (delay_st_name_p
)
3146 rel_hdr
->sh_name
= (unsigned int) -1;
3147 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3150 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3151 rel_hdr
->sh_entsize
= (use_rela_p
3152 ? bed
->s
->sizeof_rela
3153 : bed
->s
->sizeof_rel
);
3154 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3155 rel_hdr
->sh_flags
= 0;
3156 rel_hdr
->sh_addr
= 0;
3157 rel_hdr
->sh_size
= 0;
3158 rel_hdr
->sh_offset
= 0;
3163 /* Return the default section type based on the passed in section flags. */
3166 bfd_elf_get_default_section_type (flagword flags
)
3168 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3169 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3171 return SHT_PROGBITS
;
3174 struct fake_section_arg
3176 struct bfd_link_info
*link_info
;
3180 /* Set up an ELF internal section header for a section. */
3183 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3185 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3186 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3187 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3188 Elf_Internal_Shdr
*this_hdr
;
3189 unsigned int sh_type
;
3190 const char *name
= asect
->name
;
3191 bool delay_st_name_p
= false;
3196 /* We already failed; just get out of the bfd_map_over_sections
3201 this_hdr
= &esd
->this_hdr
;
3205 /* ld: compress DWARF debug sections with names: .debug_*. */
3206 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3207 && (asect
->flags
& SEC_DEBUGGING
)
3211 /* Set SEC_ELF_COMPRESS to indicate this section should be
3213 asect
->flags
|= SEC_ELF_COMPRESS
;
3214 /* If this section will be compressed, delay adding section
3215 name to section name section after it is compressed in
3216 _bfd_elf_assign_file_positions_for_non_load. */
3217 delay_st_name_p
= true;
3220 else if ((asect
->flags
& SEC_ELF_RENAME
))
3222 /* objcopy: rename output DWARF debug section. */
3223 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3225 /* When we decompress or compress with SHF_COMPRESSED,
3226 convert section name from .zdebug_* to .debug_* if
3230 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3231 if (new_name
== NULL
)
3239 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3241 /* PR binutils/18087: Compression does not always make a
3242 section smaller. So only rename the section when
3243 compression has actually taken place. If input section
3244 name is .zdebug_*, we should never compress it again. */
3245 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3246 if (new_name
== NULL
)
3251 BFD_ASSERT (name
[1] != 'z');
3256 if (delay_st_name_p
)
3257 this_hdr
->sh_name
= (unsigned int) -1;
3261 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3263 if (this_hdr
->sh_name
== (unsigned int) -1)
3270 /* Don't clear sh_flags. Assembler may set additional bits. */
3272 if ((asect
->flags
& SEC_ALLOC
) != 0
3273 || asect
->user_set_vma
)
3274 this_hdr
->sh_addr
= asect
->vma
* bfd_octets_per_byte (abfd
, asect
);
3276 this_hdr
->sh_addr
= 0;
3278 this_hdr
->sh_offset
= 0;
3279 this_hdr
->sh_size
= asect
->size
;
3280 this_hdr
->sh_link
= 0;
3281 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3282 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3285 /* xgettext:c-format */
3286 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3287 abfd
, asect
->alignment_power
, asect
);
3291 /* Set sh_addralign to the highest power of two given by alignment
3292 consistent with the section VMA. Linker scripts can force VMA. */
3293 mask
= ((bfd_vma
) 1 << asect
->alignment_power
) | this_hdr
->sh_addr
;
3294 this_hdr
->sh_addralign
= mask
& -mask
;
3295 /* The sh_entsize and sh_info fields may have been set already by
3296 copy_private_section_data. */
3298 this_hdr
->bfd_section
= asect
;
3299 this_hdr
->contents
= NULL
;
3301 /* If the section type is unspecified, we set it based on
3303 if ((asect
->flags
& SEC_GROUP
) != 0)
3304 sh_type
= SHT_GROUP
;
3306 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3308 if (this_hdr
->sh_type
== SHT_NULL
)
3309 this_hdr
->sh_type
= sh_type
;
3310 else if (this_hdr
->sh_type
== SHT_NOBITS
3311 && sh_type
== SHT_PROGBITS
3312 && (asect
->flags
& SEC_ALLOC
) != 0)
3314 /* Warn if we are changing a NOBITS section to PROGBITS, but
3315 allow the link to proceed. This can happen when users link
3316 non-bss input sections to bss output sections, or emit data
3317 to a bss output section via a linker script. */
3319 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3320 this_hdr
->sh_type
= sh_type
;
3323 switch (this_hdr
->sh_type
)
3334 case SHT_INIT_ARRAY
:
3335 case SHT_FINI_ARRAY
:
3336 case SHT_PREINIT_ARRAY
:
3337 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3341 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3345 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3349 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3353 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3354 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3358 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3359 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3362 case SHT_GNU_versym
:
3363 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3366 case SHT_GNU_verdef
:
3367 this_hdr
->sh_entsize
= 0;
3368 /* objcopy or strip will copy over sh_info, but may not set
3369 cverdefs. The linker will set cverdefs, but sh_info will be
3371 if (this_hdr
->sh_info
== 0)
3372 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3374 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3375 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3378 case SHT_GNU_verneed
:
3379 this_hdr
->sh_entsize
= 0;
3380 /* objcopy or strip will copy over sh_info, but may not set
3381 cverrefs. The linker will set cverrefs, but sh_info will be
3383 if (this_hdr
->sh_info
== 0)
3384 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3386 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3387 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3391 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3395 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3399 if ((asect
->flags
& SEC_ALLOC
) != 0)
3400 this_hdr
->sh_flags
|= SHF_ALLOC
;
3401 if ((asect
->flags
& SEC_READONLY
) == 0)
3402 this_hdr
->sh_flags
|= SHF_WRITE
;
3403 if ((asect
->flags
& SEC_CODE
) != 0)
3404 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3405 if ((asect
->flags
& SEC_MERGE
) != 0)
3407 this_hdr
->sh_flags
|= SHF_MERGE
;
3408 this_hdr
->sh_entsize
= asect
->entsize
;
3410 if ((asect
->flags
& SEC_STRINGS
) != 0)
3411 this_hdr
->sh_flags
|= SHF_STRINGS
;
3412 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3413 this_hdr
->sh_flags
|= SHF_GROUP
;
3414 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3416 this_hdr
->sh_flags
|= SHF_TLS
;
3417 if (asect
->size
== 0
3418 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3420 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3422 this_hdr
->sh_size
= 0;
3425 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3426 if (this_hdr
->sh_size
!= 0)
3427 this_hdr
->sh_type
= SHT_NOBITS
;
3431 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3432 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3434 /* If the section has relocs, set up a section header for the
3435 SHT_REL[A] section. If two relocation sections are required for
3436 this section, it is up to the processor-specific back-end to
3437 create the other. */
3438 if ((asect
->flags
& SEC_RELOC
) != 0)
3440 /* When doing a relocatable link, create both REL and RELA sections if
3443 /* Do the normal setup if we wouldn't create any sections here. */
3444 && esd
->rel
.count
+ esd
->rela
.count
> 0
3445 && (bfd_link_relocatable (arg
->link_info
)
3446 || arg
->link_info
->emitrelocations
))
3448 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3449 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3450 false, delay_st_name_p
))
3455 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3456 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3457 true, delay_st_name_p
))
3463 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3465 ? &esd
->rela
: &esd
->rel
),
3475 /* Check for processor-specific section types. */
3476 sh_type
= this_hdr
->sh_type
;
3477 if (bed
->elf_backend_fake_sections
3478 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3484 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3486 /* Don't change the header type from NOBITS if we are being
3487 called for objcopy --only-keep-debug. */
3488 this_hdr
->sh_type
= sh_type
;
3492 /* Fill in the contents of a SHT_GROUP section. Called from
3493 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3494 when ELF targets use the generic linker, ld. Called for ld -r
3495 from bfd_elf_final_link. */
3498 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3500 bool *failedptr
= (bool *) failedptrarg
;
3501 asection
*elt
, *first
;
3505 /* Ignore linker created group section. See elfNN_ia64_object_p in
3507 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3512 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3514 unsigned long symindx
= 0;
3516 /* elf_group_id will have been set up by objcopy and the
3518 if (elf_group_id (sec
) != NULL
)
3519 symindx
= elf_group_id (sec
)->udata
.i
;
3523 /* If called from the assembler, swap_out_syms will have set up
3525 PR 25699: A corrupt input file could contain bogus group info. */
3526 if (elf_section_syms (abfd
) == NULL
)
3531 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3533 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3535 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3537 /* The ELF backend linker sets sh_info to -2 when the group
3538 signature symbol is global, and thus the index can't be
3539 set until all local symbols are output. */
3541 struct bfd_elf_section_data
*sec_data
;
3542 unsigned long symndx
;
3543 unsigned long extsymoff
;
3544 struct elf_link_hash_entry
*h
;
3546 /* The point of this little dance to the first SHF_GROUP section
3547 then back to the SHT_GROUP section is that this gets us to
3548 the SHT_GROUP in the input object. */
3549 igroup
= elf_sec_group (elf_next_in_group (sec
));
3550 sec_data
= elf_section_data (igroup
);
3551 symndx
= sec_data
->this_hdr
.sh_info
;
3553 if (!elf_bad_symtab (igroup
->owner
))
3555 Elf_Internal_Shdr
*symtab_hdr
;
3557 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3558 extsymoff
= symtab_hdr
->sh_info
;
3560 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3561 while (h
->root
.type
== bfd_link_hash_indirect
3562 || h
->root
.type
== bfd_link_hash_warning
)
3563 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3565 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3568 /* The contents won't be allocated for "ld -r" or objcopy. */
3570 if (sec
->contents
== NULL
)
3573 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3575 /* Arrange for the section to be written out. */
3576 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3577 if (sec
->contents
== NULL
)
3584 loc
= sec
->contents
+ sec
->size
;
3586 /* Get the pointer to the first section in the group that gas
3587 squirreled away here. objcopy arranges for this to be set to the
3588 start of the input section group. */
3589 first
= elt
= elf_next_in_group (sec
);
3591 /* First element is a flag word. Rest of section is elf section
3592 indices for all the sections of the group. Write them backwards
3593 just to keep the group in the same order as given in .section
3594 directives, not that it matters. */
3601 s
= s
->output_section
;
3603 && !bfd_is_abs_section (s
))
3605 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3606 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3608 if (elf_sec
->rel
.hdr
!= NULL
3610 || (input_elf_sec
->rel
.hdr
!= NULL
3611 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3613 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3615 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3617 if (elf_sec
->rela
.hdr
!= NULL
3619 || (input_elf_sec
->rela
.hdr
!= NULL
3620 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3622 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3624 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3627 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3629 elt
= elf_next_in_group (elt
);
3635 BFD_ASSERT (loc
== sec
->contents
);
3637 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3640 /* Given NAME, the name of a relocation section stripped of its
3641 .rel/.rela prefix, return the section in ABFD to which the
3642 relocations apply. */
3645 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3647 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3648 section likely apply to .got.plt or .got section. */
3649 if (get_elf_backend_data (abfd
)->want_got_plt
3650 && strcmp (name
, ".plt") == 0)
3655 sec
= bfd_get_section_by_name (abfd
, name
);
3661 return bfd_get_section_by_name (abfd
, name
);
3664 /* Return the section to which RELOC_SEC applies. */
3667 elf_get_reloc_section (asection
*reloc_sec
)
3672 const struct elf_backend_data
*bed
;
3674 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3675 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3678 /* We look up the section the relocs apply to by name. */
3679 name
= reloc_sec
->name
;
3680 if (!startswith (name
, ".rel"))
3683 if (type
== SHT_RELA
&& *name
++ != 'a')
3686 abfd
= reloc_sec
->owner
;
3687 bed
= get_elf_backend_data (abfd
);
3688 return bed
->get_reloc_section (abfd
, name
);
3691 /* Assign all ELF section numbers. The dummy first section is handled here
3692 too. The link/info pointers for the standard section types are filled
3693 in here too, while we're at it. LINK_INFO will be 0 when arriving
3694 here for objcopy, and when using the generic ELF linker. */
3697 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3699 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3701 unsigned int section_number
;
3702 Elf_Internal_Shdr
**i_shdrp
;
3703 struct bfd_elf_section_data
*d
;
3709 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3711 /* SHT_GROUP sections are in relocatable files only. */
3712 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3714 size_t reloc_count
= 0;
3716 /* Put SHT_GROUP sections first. */
3717 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3719 d
= elf_section_data (sec
);
3721 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3723 if (sec
->flags
& SEC_LINKER_CREATED
)
3725 /* Remove the linker created SHT_GROUP sections. */
3726 bfd_section_list_remove (abfd
, sec
);
3727 abfd
->section_count
--;
3730 d
->this_idx
= section_number
++;
3733 /* Count relocations. */
3734 reloc_count
+= sec
->reloc_count
;
3737 /* Clear HAS_RELOC if there are no relocations. */
3738 if (reloc_count
== 0)
3739 abfd
->flags
&= ~HAS_RELOC
;
3742 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3744 d
= elf_section_data (sec
);
3746 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3747 d
->this_idx
= section_number
++;
3748 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3749 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3752 d
->rel
.idx
= section_number
++;
3753 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3754 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3761 d
->rela
.idx
= section_number
++;
3762 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3763 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3769 need_symtab
= (bfd_get_symcount (abfd
) > 0
3770 || (link_info
== NULL
3771 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3775 elf_onesymtab (abfd
) = section_number
++;
3776 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3777 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3779 elf_section_list
*entry
;
3781 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3783 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3784 entry
->ndx
= section_number
++;
3785 elf_symtab_shndx_list (abfd
) = entry
;
3787 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3788 ".symtab_shndx", false);
3789 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3792 elf_strtab_sec (abfd
) = section_number
++;
3793 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3796 elf_shstrtab_sec (abfd
) = section_number
++;
3797 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3798 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3800 if (section_number
>= SHN_LORESERVE
)
3802 /* xgettext:c-format */
3803 _bfd_error_handler (_("%pB: too many sections: %u"),
3804 abfd
, section_number
);
3808 elf_numsections (abfd
) = section_number
;
3809 elf_elfheader (abfd
)->e_shnum
= section_number
;
3811 /* Set up the list of section header pointers, in agreement with the
3813 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
3814 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc (abfd
, amt
);
3815 if (i_shdrp
== NULL
)
3818 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3819 sizeof (Elf_Internal_Shdr
));
3820 if (i_shdrp
[0] == NULL
)
3822 bfd_release (abfd
, i_shdrp
);
3826 elf_elfsections (abfd
) = i_shdrp
;
3828 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3831 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3832 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3834 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3835 BFD_ASSERT (entry
!= NULL
);
3836 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3837 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3839 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3840 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3843 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3847 d
= elf_section_data (sec
);
3849 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3850 if (d
->rel
.idx
!= 0)
3851 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3852 if (d
->rela
.idx
!= 0)
3853 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3855 /* Fill in the sh_link and sh_info fields while we're at it. */
3857 /* sh_link of a reloc section is the section index of the symbol
3858 table. sh_info is the section index of the section to which
3859 the relocation entries apply. */
3860 if (d
->rel
.idx
!= 0)
3862 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3863 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3864 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3866 if (d
->rela
.idx
!= 0)
3868 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3869 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3870 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3873 /* We need to set up sh_link for SHF_LINK_ORDER. */
3874 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3876 s
= elf_linked_to_section (sec
);
3877 /* We can now have a NULL linked section pointer.
3878 This happens when the sh_link field is 0, which is done
3879 when a linked to section is discarded but the linking
3880 section has been retained for some reason. */
3883 /* Check discarded linkonce section. */
3884 if (discarded_section (s
))
3888 /* xgettext:c-format */
3889 (_("%pB: sh_link of section `%pA' points to"
3890 " discarded section `%pA' of `%pB'"),
3891 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3892 /* Point to the kept section if it has the same
3893 size as the discarded one. */
3894 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3897 bfd_set_error (bfd_error_bad_value
);
3902 /* Handle objcopy. */
3903 else if (s
->output_section
== NULL
)
3906 /* xgettext:c-format */
3907 (_("%pB: sh_link of section `%pA' points to"
3908 " removed section `%pA' of `%pB'"),
3909 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3910 bfd_set_error (bfd_error_bad_value
);
3913 s
= s
->output_section
;
3914 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3918 switch (d
->this_hdr
.sh_type
)
3922 /* A reloc section which we are treating as a normal BFD
3923 section. sh_link is the section index of the symbol
3924 table. sh_info is the section index of the section to
3925 which the relocation entries apply. We assume that an
3926 allocated reloc section uses the dynamic symbol table.
3927 FIXME: How can we be sure? */
3928 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3930 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3932 s
= elf_get_reloc_section (sec
);
3935 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3936 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3941 /* We assume that a section named .stab*str is a stabs
3942 string section. We look for a section with the same name
3943 but without the trailing ``str'', and set its sh_link
3944 field to point to this section. */
3945 if (startswith (sec
->name
, ".stab")
3946 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3951 len
= strlen (sec
->name
);
3952 alc
= (char *) bfd_malloc (len
- 2);
3955 memcpy (alc
, sec
->name
, len
- 3);
3956 alc
[len
- 3] = '\0';
3957 s
= bfd_get_section_by_name (abfd
, alc
);
3961 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3963 /* This is a .stab section. */
3964 elf_section_data (s
)->this_hdr
.sh_entsize
= 12;
3971 case SHT_GNU_verneed
:
3972 case SHT_GNU_verdef
:
3973 /* sh_link is the section header index of the string table
3974 used for the dynamic entries, or the symbol table, or the
3976 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3978 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3981 case SHT_GNU_LIBLIST
:
3982 /* sh_link is the section header index of the prelink library
3983 list used for the dynamic entries, or the symbol table, or
3984 the version strings. */
3985 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3986 ? ".dynstr" : ".gnu.libstr");
3988 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3993 case SHT_GNU_versym
:
3994 /* sh_link is the section header index of the symbol table
3995 this hash table or version table is for. */
3996 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3998 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4002 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
4006 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
4007 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
4008 debug section name from .debug_* to .zdebug_* if needed. */
4014 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4016 /* If the backend has a special mapping, use it. */
4017 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4018 if (bed
->elf_backend_sym_is_global
)
4019 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4021 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4022 || bfd_is_und_section (bfd_asymbol_section (sym
))
4023 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4026 /* Filter global symbols of ABFD to include in the import library. All
4027 SYMCOUNT symbols of ABFD can be examined from their pointers in
4028 SYMS. Pointers of symbols to keep should be stored contiguously at
4029 the beginning of that array.
4031 Returns the number of symbols to keep. */
4034 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4035 asymbol
**syms
, long symcount
)
4037 long src_count
, dst_count
= 0;
4039 for (src_count
= 0; src_count
< symcount
; src_count
++)
4041 asymbol
*sym
= syms
[src_count
];
4042 char *name
= (char *) bfd_asymbol_name (sym
);
4043 struct bfd_link_hash_entry
*h
;
4045 if (!sym_is_global (abfd
, sym
))
4048 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, false);
4051 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4053 if (h
->linker_def
|| h
->ldscript_def
)
4056 syms
[dst_count
++] = sym
;
4059 syms
[dst_count
] = NULL
;
4064 /* Don't output section symbols for sections that are not going to be
4065 output, that are duplicates or there is no BFD section. */
4068 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4070 elf_symbol_type
*type_ptr
;
4075 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4078 /* Ignore the section symbol if it isn't used. */
4079 if ((sym
->flags
& BSF_SECTION_SYM_USED
) == 0)
4082 if (sym
->section
== NULL
)
4085 type_ptr
= elf_symbol_from (sym
);
4086 return ((type_ptr
!= NULL
4087 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4088 && bfd_is_abs_section (sym
->section
))
4089 || !(sym
->section
->owner
== abfd
4090 || (sym
->section
->output_section
!= NULL
4091 && sym
->section
->output_section
->owner
== abfd
4092 && sym
->section
->output_offset
== 0)
4093 || bfd_is_abs_section (sym
->section
)));
4096 /* Map symbol from it's internal number to the external number, moving
4097 all local symbols to be at the head of the list. */
4100 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4102 unsigned int symcount
= bfd_get_symcount (abfd
);
4103 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4104 asymbol
**sect_syms
;
4105 unsigned int num_locals
= 0;
4106 unsigned int num_globals
= 0;
4107 unsigned int num_locals2
= 0;
4108 unsigned int num_globals2
= 0;
4109 unsigned int max_index
= 0;
4116 fprintf (stderr
, "elf_map_symbols\n");
4120 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4122 if (max_index
< asect
->index
)
4123 max_index
= asect
->index
;
4127 amt
= max_index
* sizeof (asymbol
*);
4128 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
4129 if (sect_syms
== NULL
)
4131 elf_section_syms (abfd
) = sect_syms
;
4132 elf_num_section_syms (abfd
) = max_index
;
4134 /* Init sect_syms entries for any section symbols we have already
4135 decided to output. */
4136 for (idx
= 0; idx
< symcount
; idx
++)
4138 asymbol
*sym
= syms
[idx
];
4140 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4142 && !ignore_section_sym (abfd
, sym
)
4143 && !bfd_is_abs_section (sym
->section
))
4145 asection
*sec
= sym
->section
;
4147 if (sec
->owner
!= abfd
)
4148 sec
= sec
->output_section
;
4150 sect_syms
[sec
->index
] = syms
[idx
];
4154 /* Classify all of the symbols. */
4155 for (idx
= 0; idx
< symcount
; idx
++)
4157 if (sym_is_global (abfd
, syms
[idx
]))
4159 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4163 /* We will be adding a section symbol for each normal BFD section. Most
4164 sections will already have a section symbol in outsymbols, but
4165 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4166 at least in that case. */
4167 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4169 asymbol
*sym
= asect
->symbol
;
4170 /* Don't include ignored section symbols. */
4171 if (!ignore_section_sym (abfd
, sym
)
4172 && sect_syms
[asect
->index
] == NULL
)
4174 if (!sym_is_global (abfd
, asect
->symbol
))
4181 /* Now sort the symbols so the local symbols are first. */
4182 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
4183 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
4184 if (new_syms
== NULL
)
4187 for (idx
= 0; idx
< symcount
; idx
++)
4189 asymbol
*sym
= syms
[idx
];
4192 if (sym_is_global (abfd
, sym
))
4193 i
= num_locals
+ num_globals2
++;
4194 /* Don't include ignored section symbols. */
4195 else if (!ignore_section_sym (abfd
, sym
))
4200 sym
->udata
.i
= i
+ 1;
4202 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4204 asymbol
*sym
= asect
->symbol
;
4205 if (!ignore_section_sym (abfd
, sym
)
4206 && sect_syms
[asect
->index
] == NULL
)
4210 sect_syms
[asect
->index
] = sym
;
4211 if (!sym_is_global (abfd
, sym
))
4214 i
= num_locals
+ num_globals2
++;
4216 sym
->udata
.i
= i
+ 1;
4220 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4222 *pnum_locals
= num_locals
;
4226 /* Align to the maximum file alignment that could be required for any
4227 ELF data structure. */
4229 static inline file_ptr
4230 align_file_position (file_ptr off
, int align
)
4232 return (off
+ align
- 1) & ~(align
- 1);
4235 /* Assign a file position to a section, optionally aligning to the
4236 required section alignment. */
4239 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4243 if (align
&& i_shdrp
->sh_addralign
> 1)
4244 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4245 i_shdrp
->sh_offset
= offset
;
4246 if (i_shdrp
->bfd_section
!= NULL
)
4247 i_shdrp
->bfd_section
->filepos
= offset
;
4248 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4249 offset
+= i_shdrp
->sh_size
;
4253 /* Compute the file positions we are going to put the sections at, and
4254 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4255 is not NULL, this is being called by the ELF backend linker. */
4258 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4259 struct bfd_link_info
*link_info
)
4261 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4262 struct fake_section_arg fsargs
;
4264 struct elf_strtab_hash
*strtab
= NULL
;
4265 Elf_Internal_Shdr
*shstrtab_hdr
;
4268 if (abfd
->output_has_begun
)
4271 /* Do any elf backend specific processing first. */
4272 if (bed
->elf_backend_begin_write_processing
)
4273 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4275 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4278 fsargs
.failed
= false;
4279 fsargs
.link_info
= link_info
;
4280 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4284 if (!assign_section_numbers (abfd
, link_info
))
4287 /* The backend linker builds symbol table information itself. */
4288 need_symtab
= (link_info
== NULL
4289 && (bfd_get_symcount (abfd
) > 0
4290 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4294 /* Non-zero if doing a relocatable link. */
4295 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4297 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
, link_info
))
4302 if (link_info
== NULL
)
4304 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4309 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4310 /* sh_name was set in init_file_header. */
4311 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4312 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4313 shstrtab_hdr
->sh_addr
= 0;
4314 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4315 shstrtab_hdr
->sh_entsize
= 0;
4316 shstrtab_hdr
->sh_link
= 0;
4317 shstrtab_hdr
->sh_info
= 0;
4318 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4319 shstrtab_hdr
->sh_addralign
= 1;
4321 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4327 Elf_Internal_Shdr
*hdr
;
4329 off
= elf_next_file_pos (abfd
);
4331 hdr
= & elf_symtab_hdr (abfd
);
4332 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4334 if (elf_symtab_shndx_list (abfd
) != NULL
)
4336 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4337 if (hdr
->sh_size
!= 0)
4338 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4339 /* FIXME: What about other symtab_shndx sections in the list ? */
4342 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4343 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4345 elf_next_file_pos (abfd
) = off
;
4347 /* Now that we know where the .strtab section goes, write it
4349 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4350 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4352 _bfd_elf_strtab_free (strtab
);
4355 abfd
->output_has_begun
= true;
4360 /* Make an initial estimate of the size of the program header. If we
4361 get the number wrong here, we'll redo section placement. */
4363 static bfd_size_type
4364 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4368 const struct elf_backend_data
*bed
;
4370 /* Assume we will need exactly two PT_LOAD segments: one for text
4371 and one for data. */
4374 s
= bfd_get_section_by_name (abfd
, ".interp");
4375 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4377 /* If we have a loadable interpreter section, we need a
4378 PT_INTERP segment. In this case, assume we also need a
4379 PT_PHDR segment, although that may not be true for all
4384 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4386 /* We need a PT_DYNAMIC segment. */
4390 if (info
!= NULL
&& info
->relro
)
4392 /* We need a PT_GNU_RELRO segment. */
4396 if (elf_eh_frame_hdr (abfd
))
4398 /* We need a PT_GNU_EH_FRAME segment. */
4402 if (elf_stack_flags (abfd
))
4404 /* We need a PT_GNU_STACK segment. */
4408 s
= bfd_get_section_by_name (abfd
,
4409 NOTE_GNU_PROPERTY_SECTION_NAME
);
4410 if (s
!= NULL
&& s
->size
!= 0)
4412 /* We need a PT_GNU_PROPERTY segment. */
4416 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4418 if ((s
->flags
& SEC_LOAD
) != 0
4419 && elf_section_type (s
) == SHT_NOTE
)
4421 unsigned int alignment_power
;
4422 /* We need a PT_NOTE segment. */
4424 /* Try to create just one PT_NOTE segment for all adjacent
4425 loadable SHT_NOTE sections. gABI requires that within a
4426 PT_NOTE segment (and also inside of each SHT_NOTE section)
4427 each note should have the same alignment. So we check
4428 whether the sections are correctly aligned. */
4429 alignment_power
= s
->alignment_power
;
4430 while (s
->next
!= NULL
4431 && s
->next
->alignment_power
== alignment_power
4432 && (s
->next
->flags
& SEC_LOAD
) != 0
4433 && elf_section_type (s
->next
) == SHT_NOTE
)
4438 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4440 if (s
->flags
& SEC_THREAD_LOCAL
)
4442 /* We need a PT_TLS segment. */
4448 bed
= get_elf_backend_data (abfd
);
4450 if ((abfd
->flags
& D_PAGED
) != 0
4451 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4453 /* Add a PT_GNU_MBIND segment for each mbind section. */
4454 bfd_vma commonpagesize
;
4455 unsigned int page_align_power
;
4458 commonpagesize
= info
->commonpagesize
;
4460 commonpagesize
= bed
->commonpagesize
;
4461 page_align_power
= bfd_log2 (commonpagesize
);
4462 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4463 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4465 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4468 /* xgettext:c-format */
4469 (_("%pB: GNU_MBIND section `%pA' has invalid "
4470 "sh_info field: %d"),
4471 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4474 /* Align mbind section to page size. */
4475 if (s
->alignment_power
< page_align_power
)
4476 s
->alignment_power
= page_align_power
;
4481 /* Let the backend count up any program headers it might need. */
4482 if (bed
->elf_backend_additional_program_headers
)
4486 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4492 return segs
* bed
->s
->sizeof_phdr
;
4495 /* Find the segment that contains the output_section of section. */
4498 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4500 struct elf_segment_map
*m
;
4501 Elf_Internal_Phdr
*p
;
4503 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4509 for (i
= m
->count
- 1; i
>= 0; i
--)
4510 if (m
->sections
[i
] == section
)
4517 /* Create a mapping from a set of sections to a program segment. */
4519 static struct elf_segment_map
*
4520 make_mapping (bfd
*abfd
,
4521 asection
**sections
,
4526 struct elf_segment_map
*m
;
4531 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4532 amt
+= (to
- from
) * sizeof (asection
*);
4533 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4537 m
->p_type
= PT_LOAD
;
4538 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4539 m
->sections
[i
- from
] = *hdrpp
;
4540 m
->count
= to
- from
;
4542 if (from
== 0 && phdr
)
4544 /* Include the headers in the first PT_LOAD segment. */
4545 m
->includes_filehdr
= 1;
4546 m
->includes_phdrs
= 1;
4552 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4555 struct elf_segment_map
*
4556 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4558 struct elf_segment_map
*m
;
4560 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4561 sizeof (struct elf_segment_map
));
4565 m
->p_type
= PT_DYNAMIC
;
4567 m
->sections
[0] = dynsec
;
4572 /* Possibly add or remove segments from the segment map. */
4575 elf_modify_segment_map (bfd
*abfd
,
4576 struct bfd_link_info
*info
,
4577 bool remove_empty_load
)
4579 struct elf_segment_map
**m
;
4580 const struct elf_backend_data
*bed
;
4582 /* The placement algorithm assumes that non allocated sections are
4583 not in PT_LOAD segments. We ensure this here by removing such
4584 sections from the segment map. We also remove excluded
4585 sections. Finally, any PT_LOAD segment without sections is
4587 m
= &elf_seg_map (abfd
);
4590 unsigned int i
, new_count
;
4592 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4594 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4595 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4596 || (*m
)->p_type
!= PT_LOAD
))
4598 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4602 (*m
)->count
= new_count
;
4604 if (remove_empty_load
4605 && (*m
)->p_type
== PT_LOAD
4607 && !(*m
)->includes_phdrs
)
4613 bed
= get_elf_backend_data (abfd
);
4614 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4616 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4623 #define IS_TBSS(s) \
4624 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4626 /* Set up a mapping from BFD sections to program segments. */
4629 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4632 struct elf_segment_map
*m
;
4633 asection
**sections
= NULL
;
4634 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4637 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4640 info
->user_phdrs
= !no_user_phdrs
;
4642 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4646 struct elf_segment_map
*mfirst
;
4647 struct elf_segment_map
**pm
;
4650 unsigned int hdr_index
;
4651 bfd_vma maxpagesize
;
4653 bool phdr_in_segment
;
4656 unsigned int tls_count
= 0;
4657 asection
*first_tls
= NULL
;
4658 asection
*first_mbind
= NULL
;
4659 asection
*dynsec
, *eh_frame_hdr
;
4661 bfd_vma addr_mask
, wrap_to
= 0; /* Bytes. */
4662 bfd_size_type phdr_size
; /* Octets/bytes. */
4663 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
4665 /* Select the allocated sections, and sort them. */
4667 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
4668 sections
= (asection
**) bfd_malloc (amt
);
4669 if (sections
== NULL
)
4672 /* Calculate top address, avoiding undefined behaviour of shift
4673 left operator when shift count is equal to size of type
4675 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4676 addr_mask
= (addr_mask
<< 1) + 1;
4679 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4681 if ((s
->flags
& SEC_ALLOC
) != 0)
4683 /* target_index is unused until bfd_elf_final_link
4684 starts output of section symbols. Use it to make
4686 s
->target_index
= i
;
4689 /* A wrapping section potentially clashes with header. */
4690 if (((s
->lma
+ s
->size
/ opb
) & addr_mask
) < (s
->lma
& addr_mask
))
4691 wrap_to
= (s
->lma
+ s
->size
/ opb
) & addr_mask
;
4694 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4697 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4699 phdr_size
= elf_program_header_size (abfd
);
4700 if (phdr_size
== (bfd_size_type
) -1)
4701 phdr_size
= get_program_header_size (abfd
, info
);
4702 phdr_size
+= bed
->s
->sizeof_ehdr
;
4703 /* phdr_size is compared to LMA values which are in bytes. */
4706 maxpagesize
= info
->maxpagesize
;
4708 maxpagesize
= bed
->maxpagesize
;
4709 if (maxpagesize
== 0)
4711 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4713 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4714 >= (phdr_size
& (maxpagesize
- 1))))
4715 /* For compatibility with old scripts that may not be using
4716 SIZEOF_HEADERS, add headers when it looks like space has
4717 been left for them. */
4718 phdr_in_segment
= true;
4720 /* Build the mapping. */
4724 /* If we have a .interp section, then create a PT_PHDR segment for
4725 the program headers and a PT_INTERP segment for the .interp
4727 s
= bfd_get_section_by_name (abfd
, ".interp");
4728 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4730 amt
= sizeof (struct elf_segment_map
);
4731 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4735 m
->p_type
= PT_PHDR
;
4737 m
->p_flags_valid
= 1;
4738 m
->includes_phdrs
= 1;
4739 phdr_in_segment
= true;
4743 amt
= sizeof (struct elf_segment_map
);
4744 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4748 m
->p_type
= PT_INTERP
;
4756 /* Look through the sections. We put sections in the same program
4757 segment when the start of the second section can be placed within
4758 a few bytes of the end of the first section. */
4764 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4766 && (dynsec
->flags
& SEC_LOAD
) == 0)
4769 if ((abfd
->flags
& D_PAGED
) == 0)
4770 phdr_in_segment
= false;
4772 /* Deal with -Ttext or something similar such that the first section
4773 is not adjacent to the program headers. This is an
4774 approximation, since at this point we don't know exactly how many
4775 program headers we will need. */
4776 if (phdr_in_segment
&& count
> 0)
4778 bfd_vma phdr_lma
; /* Bytes. */
4779 bool separate_phdr
= false;
4781 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4783 && info
->separate_code
4784 && (sections
[0]->flags
& SEC_CODE
) != 0)
4786 /* If data sections should be separate from code and
4787 thus not executable, and the first section is
4788 executable then put the file and program headers in
4789 their own PT_LOAD. */
4790 separate_phdr
= true;
4791 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4792 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4794 /* The file and program headers are currently on the
4795 same page as the first section. Put them on the
4796 previous page if we can. */
4797 if (phdr_lma
>= maxpagesize
)
4798 phdr_lma
-= maxpagesize
;
4800 separate_phdr
= false;
4803 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4804 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4805 /* If file and program headers would be placed at the end
4806 of memory then it's probably better to omit them. */
4807 phdr_in_segment
= false;
4808 else if (phdr_lma
< wrap_to
)
4809 /* If a section wraps around to where we'll be placing
4810 file and program headers, then the headers will be
4812 phdr_in_segment
= false;
4813 else if (separate_phdr
)
4815 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4818 m
->p_paddr
= phdr_lma
* opb
;
4820 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4821 m
->p_paddr_valid
= 1;
4824 phdr_in_segment
= false;
4828 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4835 /* See if this section and the last one will fit in the same
4838 if (last_hdr
== NULL
)
4840 /* If we don't have a segment yet, then we don't need a new
4841 one (we build the last one after this loop). */
4842 new_segment
= false;
4844 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4846 /* If this section has a different relation between the
4847 virtual address and the load address, then we need a new
4851 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4852 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4854 /* If this section has a load address that makes it overlap
4855 the previous section, then we need a new segment. */
4858 else if ((abfd
->flags
& D_PAGED
) != 0
4859 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4860 == (hdr
->lma
& -maxpagesize
)))
4862 /* If we are demand paged then we can't map two disk
4863 pages onto the same memory page. */
4864 new_segment
= false;
4866 /* In the next test we have to be careful when last_hdr->lma is close
4867 to the end of the address space. If the aligned address wraps
4868 around to the start of the address space, then there are no more
4869 pages left in memory and it is OK to assume that the current
4870 section can be included in the current segment. */
4871 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4872 + maxpagesize
> last_hdr
->lma
)
4873 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4874 + maxpagesize
<= hdr
->lma
))
4876 /* If putting this section in this segment would force us to
4877 skip a page in the segment, then we need a new segment. */
4880 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4881 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4883 /* We don't want to put a loaded section after a
4884 nonloaded (ie. bss style) section in the same segment
4885 as that will force the non-loaded section to be loaded.
4886 Consider .tbss sections as loaded for this purpose. */
4889 else if ((abfd
->flags
& D_PAGED
) == 0)
4891 /* If the file is not demand paged, which means that we
4892 don't require the sections to be correctly aligned in the
4893 file, then there is no other reason for a new segment. */
4894 new_segment
= false;
4896 else if (info
!= NULL
4897 && info
->separate_code
4898 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4903 && (hdr
->flags
& SEC_READONLY
) == 0)
4905 /* We don't want to put a writable section in a read only
4911 /* Otherwise, we can use the same segment. */
4912 new_segment
= false;
4915 /* Allow interested parties a chance to override our decision. */
4916 if (last_hdr
!= NULL
4918 && info
->callbacks
->override_segment_assignment
!= NULL
)
4920 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4926 if ((hdr
->flags
& SEC_READONLY
) == 0)
4928 if ((hdr
->flags
& SEC_CODE
) != 0)
4931 /* .tbss sections effectively have zero size. */
4932 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4936 /* We need a new program segment. We must create a new program
4937 header holding all the sections from hdr_index until hdr. */
4939 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4946 if ((hdr
->flags
& SEC_READONLY
) == 0)
4951 if ((hdr
->flags
& SEC_CODE
) == 0)
4957 /* .tbss sections effectively have zero size. */
4958 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4960 phdr_in_segment
= false;
4963 /* Create a final PT_LOAD program segment, but not if it's just
4965 if (last_hdr
!= NULL
4966 && (i
- hdr_index
!= 1
4967 || !IS_TBSS (last_hdr
)))
4969 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4977 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4980 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4987 /* For each batch of consecutive loadable SHT_NOTE sections,
4988 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4989 because if we link together nonloadable .note sections and
4990 loadable .note sections, we will generate two .note sections
4991 in the output file. */
4992 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4994 if ((s
->flags
& SEC_LOAD
) != 0
4995 && elf_section_type (s
) == SHT_NOTE
)
4998 unsigned int alignment_power
= s
->alignment_power
;
5001 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
5003 if (s2
->next
->alignment_power
== alignment_power
5004 && (s2
->next
->flags
& SEC_LOAD
) != 0
5005 && elf_section_type (s2
->next
) == SHT_NOTE
5006 && align_power (s2
->lma
+ s2
->size
/ opb
,
5013 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5014 amt
+= count
* sizeof (asection
*);
5015 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5019 m
->p_type
= PT_NOTE
;
5023 m
->sections
[m
->count
- count
--] = s
;
5024 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5027 m
->sections
[m
->count
- 1] = s
;
5028 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5032 if (s
->flags
& SEC_THREAD_LOCAL
)
5038 if (first_mbind
== NULL
5039 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5043 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5046 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5047 amt
+= tls_count
* sizeof (asection
*);
5048 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5053 m
->count
= tls_count
;
5054 /* Mandated PF_R. */
5056 m
->p_flags_valid
= 1;
5058 for (i
= 0; i
< tls_count
; ++i
)
5060 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5063 (_("%pB: TLS sections are not adjacent:"), abfd
);
5066 while (i
< tls_count
)
5068 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5070 _bfd_error_handler (_(" TLS: %pA"), s
);
5074 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5077 bfd_set_error (bfd_error_bad_value
);
5089 && (abfd
->flags
& D_PAGED
) != 0
5090 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5091 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5092 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5093 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5095 /* Mandated PF_R. */
5096 unsigned long p_flags
= PF_R
;
5097 if ((s
->flags
& SEC_READONLY
) == 0)
5099 if ((s
->flags
& SEC_CODE
) != 0)
5102 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5103 m
= bfd_zalloc (abfd
, amt
);
5107 m
->p_type
= (PT_GNU_MBIND_LO
5108 + elf_section_data (s
)->this_hdr
.sh_info
);
5110 m
->p_flags_valid
= 1;
5112 m
->p_flags
= p_flags
;
5118 s
= bfd_get_section_by_name (abfd
,
5119 NOTE_GNU_PROPERTY_SECTION_NAME
);
5120 if (s
!= NULL
&& s
->size
!= 0)
5122 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5123 m
= bfd_zalloc (abfd
, amt
);
5127 m
->p_type
= PT_GNU_PROPERTY
;
5129 m
->p_flags_valid
= 1;
5136 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5138 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5139 if (eh_frame_hdr
!= NULL
5140 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5142 amt
= sizeof (struct elf_segment_map
);
5143 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5147 m
->p_type
= PT_GNU_EH_FRAME
;
5149 m
->sections
[0] = eh_frame_hdr
->output_section
;
5155 if (elf_stack_flags (abfd
))
5157 amt
= sizeof (struct elf_segment_map
);
5158 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5162 m
->p_type
= PT_GNU_STACK
;
5163 m
->p_flags
= elf_stack_flags (abfd
);
5164 m
->p_align
= bed
->stack_align
;
5165 m
->p_flags_valid
= 1;
5166 m
->p_align_valid
= m
->p_align
!= 0;
5167 if (info
->stacksize
> 0)
5169 m
->p_size
= info
->stacksize
;
5170 m
->p_size_valid
= 1;
5177 if (info
!= NULL
&& info
->relro
)
5179 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5181 if (m
->p_type
== PT_LOAD
5183 && m
->sections
[0]->vma
>= info
->relro_start
5184 && m
->sections
[0]->vma
< info
->relro_end
)
5187 while (--i
!= (unsigned) -1)
5189 if (m
->sections
[i
]->size
> 0
5190 && (m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5191 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5195 if (i
!= (unsigned) -1)
5200 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5203 amt
= sizeof (struct elf_segment_map
);
5204 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5208 m
->p_type
= PT_GNU_RELRO
;
5215 elf_seg_map (abfd
) = mfirst
;
5218 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5221 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5223 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5232 /* Sort sections by address. */
5235 elf_sort_sections (const void *arg1
, const void *arg2
)
5237 const asection
*sec1
= *(const asection
**) arg1
;
5238 const asection
*sec2
= *(const asection
**) arg2
;
5239 bfd_size_type size1
, size2
;
5241 /* Sort by LMA first, since this is the address used to
5242 place the section into a segment. */
5243 if (sec1
->lma
< sec2
->lma
)
5245 else if (sec1
->lma
> sec2
->lma
)
5248 /* Then sort by VMA. Normally the LMA and the VMA will be
5249 the same, and this will do nothing. */
5250 if (sec1
->vma
< sec2
->vma
)
5252 else if (sec1
->vma
> sec2
->vma
)
5255 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5257 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0 \
5265 else if (TOEND (sec2
))
5270 /* Sort by size, to put zero sized sections
5271 before others at the same address. */
5273 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5274 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5281 return sec1
->target_index
- sec2
->target_index
;
5284 /* This qsort comparison functions sorts PT_LOAD segments first and
5285 by p_paddr, for assign_file_positions_for_load_sections. */
5288 elf_sort_segments (const void *arg1
, const void *arg2
)
5290 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5291 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5293 if (m1
->p_type
!= m2
->p_type
)
5295 if (m1
->p_type
== PT_NULL
)
5297 if (m2
->p_type
== PT_NULL
)
5299 return m1
->p_type
< m2
->p_type
? -1 : 1;
5301 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5302 return m1
->includes_filehdr
? -1 : 1;
5303 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5304 return m1
->no_sort_lma
? -1 : 1;
5305 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5307 bfd_vma lma1
, lma2
; /* Octets. */
5309 if (m1
->p_paddr_valid
)
5311 else if (m1
->count
!= 0)
5313 unsigned int opb
= bfd_octets_per_byte (m1
->sections
[0]->owner
,
5315 lma1
= (m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
) * opb
;
5318 if (m2
->p_paddr_valid
)
5320 else if (m2
->count
!= 0)
5322 unsigned int opb
= bfd_octets_per_byte (m2
->sections
[0]->owner
,
5324 lma2
= (m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
) * opb
;
5327 return lma1
< lma2
? -1 : 1;
5329 if (m1
->idx
!= m2
->idx
)
5330 return m1
->idx
< m2
->idx
? -1 : 1;
5334 /* Ian Lance Taylor writes:
5336 We shouldn't be using % with a negative signed number. That's just
5337 not good. We have to make sure either that the number is not
5338 negative, or that the number has an unsigned type. When the types
5339 are all the same size they wind up as unsigned. When file_ptr is a
5340 larger signed type, the arithmetic winds up as signed long long,
5343 What we're trying to say here is something like ``increase OFF by
5344 the least amount that will cause it to be equal to the VMA modulo
5346 /* In other words, something like:
5348 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5349 off_offset = off % bed->maxpagesize;
5350 if (vma_offset < off_offset)
5351 adjustment = vma_offset + bed->maxpagesize - off_offset;
5353 adjustment = vma_offset - off_offset;
5355 which can be collapsed into the expression below. */
5358 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5360 /* PR binutils/16199: Handle an alignment of zero. */
5361 if (maxpagesize
== 0)
5363 return ((vma
- off
) % maxpagesize
);
5367 print_segment_map (const struct elf_segment_map
*m
)
5370 const char *pt
= get_segment_type (m
->p_type
);
5375 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5376 sprintf (buf
, "LOPROC+%7.7x",
5377 (unsigned int) (m
->p_type
- PT_LOPROC
));
5378 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5379 sprintf (buf
, "LOOS+%7.7x",
5380 (unsigned int) (m
->p_type
- PT_LOOS
));
5382 snprintf (buf
, sizeof (buf
), "%8.8x",
5383 (unsigned int) m
->p_type
);
5387 fprintf (stderr
, "%s:", pt
);
5388 for (j
= 0; j
< m
->count
; j
++)
5389 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5395 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5400 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5402 buf
= bfd_zmalloc (len
);
5405 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5410 /* Assign file positions to the sections based on the mapping from
5411 sections to segments. This function also sets up some fields in
5415 assign_file_positions_for_load_sections (bfd
*abfd
,
5416 struct bfd_link_info
*link_info
)
5418 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5419 struct elf_segment_map
*m
;
5420 struct elf_segment_map
*phdr_load_seg
;
5421 Elf_Internal_Phdr
*phdrs
;
5422 Elf_Internal_Phdr
*p
;
5423 file_ptr off
; /* Octets. */
5424 bfd_size_type maxpagesize
;
5425 unsigned int alloc
, actual
;
5427 struct elf_segment_map
**sorted_seg_map
;
5428 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
5430 if (link_info
== NULL
5431 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5435 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5440 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5441 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5445 /* PR binutils/12467. */
5446 elf_elfheader (abfd
)->e_phoff
= 0;
5447 elf_elfheader (abfd
)->e_phentsize
= 0;
5450 elf_elfheader (abfd
)->e_phnum
= alloc
;
5452 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5455 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5459 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5460 BFD_ASSERT (elf_program_header_size (abfd
)
5461 == actual
* bed
->s
->sizeof_phdr
);
5462 BFD_ASSERT (actual
>= alloc
);
5467 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5471 /* We're writing the size in elf_program_header_size (abfd),
5472 see assign_file_positions_except_relocs, so make sure we have
5473 that amount allocated, with trailing space cleared.
5474 The variable alloc contains the computed need, while
5475 elf_program_header_size (abfd) contains the size used for the
5477 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5478 where the layout is forced to according to a larger size in the
5479 last iterations for the testcase ld-elf/header. */
5480 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5481 + alloc
* sizeof (*sorted_seg_map
)));
5482 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5483 elf_tdata (abfd
)->phdr
= phdrs
;
5487 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5489 sorted_seg_map
[j
] = m
;
5490 /* If elf_segment_map is not from map_sections_to_segments, the
5491 sections may not be correctly ordered. NOTE: sorting should
5492 not be done to the PT_NOTE section of a corefile, which may
5493 contain several pseudo-sections artificially created by bfd.
5494 Sorting these pseudo-sections breaks things badly. */
5496 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5497 && m
->p_type
== PT_NOTE
))
5499 for (i
= 0; i
< m
->count
; i
++)
5500 m
->sections
[i
]->target_index
= i
;
5501 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5506 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5510 if ((abfd
->flags
& D_PAGED
) != 0)
5512 if (link_info
!= NULL
)
5513 maxpagesize
= link_info
->maxpagesize
;
5515 maxpagesize
= bed
->maxpagesize
;
5518 /* Sections must map to file offsets past the ELF file header. */
5519 off
= bed
->s
->sizeof_ehdr
;
5520 /* And if one of the PT_LOAD headers doesn't include the program
5521 headers then we'll be mapping program headers in the usual
5522 position after the ELF file header. */
5523 phdr_load_seg
= NULL
;
5524 for (j
= 0; j
< alloc
; j
++)
5526 m
= sorted_seg_map
[j
];
5527 if (m
->p_type
!= PT_LOAD
)
5529 if (m
->includes_phdrs
)
5535 if (phdr_load_seg
== NULL
)
5536 off
+= actual
* bed
->s
->sizeof_phdr
;
5538 for (j
= 0; j
< alloc
; j
++)
5541 bfd_vma off_adjust
; /* Octets. */
5544 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5545 number of sections with contents contributing to both p_filesz
5546 and p_memsz, followed by a number of sections with no contents
5547 that just contribute to p_memsz. In this loop, OFF tracks next
5548 available file offset for PT_LOAD and PT_NOTE segments. */
5549 m
= sorted_seg_map
[j
];
5551 p
->p_type
= m
->p_type
;
5552 p
->p_flags
= m
->p_flags
;
5555 p
->p_vaddr
= m
->p_vaddr_offset
* opb
;
5557 p
->p_vaddr
= (m
->sections
[0]->vma
+ m
->p_vaddr_offset
) * opb
;
5559 if (m
->p_paddr_valid
)
5560 p
->p_paddr
= m
->p_paddr
;
5561 else if (m
->count
== 0)
5564 p
->p_paddr
= (m
->sections
[0]->lma
+ m
->p_vaddr_offset
) * opb
;
5566 if (p
->p_type
== PT_LOAD
5567 && (abfd
->flags
& D_PAGED
) != 0)
5569 /* p_align in demand paged PT_LOAD segments effectively stores
5570 the maximum page size. When copying an executable with
5571 objcopy, we set m->p_align from the input file. Use this
5572 value for maxpagesize rather than bed->maxpagesize, which
5573 may be different. Note that we use maxpagesize for PT_TLS
5574 segment alignment later in this function, so we are relying
5575 on at least one PT_LOAD segment appearing before a PT_TLS
5577 if (m
->p_align_valid
)
5578 maxpagesize
= m
->p_align
;
5580 p
->p_align
= maxpagesize
;
5582 else if (m
->p_align_valid
)
5583 p
->p_align
= m
->p_align
;
5584 else if (m
->count
== 0)
5585 p
->p_align
= 1 << bed
->s
->log_file_align
;
5587 if (m
== phdr_load_seg
)
5589 if (!m
->includes_filehdr
)
5591 off
+= actual
* bed
->s
->sizeof_phdr
;
5594 no_contents
= false;
5596 if (p
->p_type
== PT_LOAD
5599 bfd_size_type align
; /* Bytes. */
5600 unsigned int align_power
= 0;
5602 if (m
->p_align_valid
)
5606 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5608 unsigned int secalign
;
5610 secalign
= bfd_section_alignment (*secpp
);
5611 if (secalign
> align_power
)
5612 align_power
= secalign
;
5614 align
= (bfd_size_type
) 1 << align_power
;
5615 if (align
< maxpagesize
)
5616 align
= maxpagesize
;
5619 for (i
= 0; i
< m
->count
; i
++)
5620 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5621 /* If we aren't making room for this section, then
5622 it must be SHT_NOBITS regardless of what we've
5623 set via struct bfd_elf_special_section. */
5624 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5626 /* Find out whether this segment contains any loadable
5629 for (i
= 0; i
< m
->count
; i
++)
5630 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5632 no_contents
= false;
5636 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
* opb
);
5638 /* Broken hardware and/or kernel require that files do not
5639 map the same page with different permissions on some hppa
5642 && (abfd
->flags
& D_PAGED
) != 0
5643 && bed
->no_page_alias
5644 && (off
& (maxpagesize
- 1)) != 0
5645 && ((off
& -maxpagesize
)
5646 == ((off
+ off_adjust
) & -maxpagesize
)))
5647 off_adjust
+= maxpagesize
;
5651 /* We shouldn't need to align the segment on disk since
5652 the segment doesn't need file space, but the gABI
5653 arguably requires the alignment and glibc ld.so
5654 checks it. So to comply with the alignment
5655 requirement but not waste file space, we adjust
5656 p_offset for just this segment. (OFF_ADJUST is
5657 subtracted from OFF later.) This may put p_offset
5658 past the end of file, but that shouldn't matter. */
5663 /* Make sure the .dynamic section is the first section in the
5664 PT_DYNAMIC segment. */
5665 else if (p
->p_type
== PT_DYNAMIC
5667 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5670 (_("%pB: The first section in the PT_DYNAMIC segment"
5671 " is not the .dynamic section"),
5673 bfd_set_error (bfd_error_bad_value
);
5676 /* Set the note section type to SHT_NOTE. */
5677 else if (p
->p_type
== PT_NOTE
)
5678 for (i
= 0; i
< m
->count
; i
++)
5679 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5681 if (m
->includes_filehdr
)
5683 if (!m
->p_flags_valid
)
5685 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5686 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5687 if (p
->p_type
== PT_LOAD
)
5691 if (p
->p_vaddr
< (bfd_vma
) off
5692 || (!m
->p_paddr_valid
5693 && p
->p_paddr
< (bfd_vma
) off
))
5696 (_("%pB: not enough room for program headers,"
5697 " try linking with -N"),
5699 bfd_set_error (bfd_error_bad_value
);
5703 if (!m
->p_paddr_valid
)
5707 else if (sorted_seg_map
[0]->includes_filehdr
)
5709 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5710 p
->p_vaddr
= filehdr
->p_vaddr
;
5711 if (!m
->p_paddr_valid
)
5712 p
->p_paddr
= filehdr
->p_paddr
;
5716 if (m
->includes_phdrs
)
5718 if (!m
->p_flags_valid
)
5720 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5721 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5722 if (!m
->includes_filehdr
)
5724 if (p
->p_type
== PT_LOAD
)
5726 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5729 p
->p_vaddr
-= off
- p
->p_offset
;
5730 if (!m
->p_paddr_valid
)
5731 p
->p_paddr
-= off
- p
->p_offset
;
5734 else if (phdr_load_seg
!= NULL
)
5736 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5737 bfd_vma phdr_off
= 0; /* Octets. */
5738 if (phdr_load_seg
->includes_filehdr
)
5739 phdr_off
= bed
->s
->sizeof_ehdr
;
5740 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5741 if (!m
->p_paddr_valid
)
5742 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5743 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5746 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5750 if (p
->p_type
== PT_LOAD
5751 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5753 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5758 /* Put meaningless p_offset for PT_LOAD segments
5759 without file contents somewhere within the first
5760 page, in an attempt to not point past EOF. */
5761 bfd_size_type align
= maxpagesize
;
5762 if (align
< p
->p_align
)
5766 p
->p_offset
= off
% align
;
5771 file_ptr adjust
; /* Octets. */
5773 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5775 p
->p_filesz
+= adjust
;
5776 p
->p_memsz
+= adjust
;
5780 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5781 maps. Set filepos for sections in PT_LOAD segments, and in
5782 core files, for sections in PT_NOTE segments.
5783 assign_file_positions_for_non_load_sections will set filepos
5784 for other sections and update p_filesz for other segments. */
5785 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5788 bfd_size_type align
;
5789 Elf_Internal_Shdr
*this_hdr
;
5792 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5793 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5795 if ((p
->p_type
== PT_LOAD
5796 || p
->p_type
== PT_TLS
)
5797 && (this_hdr
->sh_type
!= SHT_NOBITS
5798 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5799 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5800 || p
->p_type
== PT_TLS
))))
5802 bfd_vma p_start
= p
->p_paddr
; /* Octets. */
5803 bfd_vma p_end
= p_start
+ p
->p_memsz
; /* Octets. */
5804 bfd_vma s_start
= sec
->lma
* opb
; /* Octets. */
5805 bfd_vma adjust
= s_start
- p_end
; /* Octets. */
5809 || p_end
< p_start
))
5812 /* xgettext:c-format */
5813 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5814 abfd
, sec
, (uint64_t) s_start
/ opb
,
5815 (uint64_t) p_end
/ opb
);
5817 sec
->lma
= p_end
/ opb
;
5819 p
->p_memsz
+= adjust
;
5821 if (p
->p_type
== PT_LOAD
)
5823 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5826 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5828 /* We have a PROGBITS section following NOBITS ones.
5829 Allocate file space for the NOBITS section(s) and
5831 adjust
= p
->p_memsz
- p
->p_filesz
;
5832 if (!write_zeros (abfd
, off
, adjust
))
5836 /* We only adjust sh_offset in SHT_NOBITS sections
5837 as would seem proper for their address when the
5838 section is first in the segment. sh_offset
5839 doesn't really have any significance for
5840 SHT_NOBITS anyway, apart from a notional position
5841 relative to other sections. Historically we
5842 didn't bother with adjusting sh_offset and some
5843 programs depend on it not being adjusted. See
5844 pr12921 and pr25662. */
5845 if (this_hdr
->sh_type
!= SHT_NOBITS
|| i
== 0)
5848 if (this_hdr
->sh_type
== SHT_NOBITS
)
5849 off_adjust
+= adjust
;
5852 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5853 p
->p_filesz
+= adjust
;
5856 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5858 /* The section at i == 0 is the one that actually contains
5862 this_hdr
->sh_offset
= sec
->filepos
= off
;
5863 off
+= this_hdr
->sh_size
;
5864 p
->p_filesz
= this_hdr
->sh_size
;
5870 /* The rest are fake sections that shouldn't be written. */
5879 if (p
->p_type
== PT_LOAD
)
5881 this_hdr
->sh_offset
= sec
->filepos
= off
;
5882 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5883 off
+= this_hdr
->sh_size
;
5885 else if (this_hdr
->sh_type
== SHT_NOBITS
5886 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5887 && this_hdr
->sh_offset
== 0)
5889 /* This is a .tbss section that didn't get a PT_LOAD.
5890 (See _bfd_elf_map_sections_to_segments "Create a
5891 final PT_LOAD".) Set sh_offset to the value it
5892 would have if we had created a zero p_filesz and
5893 p_memsz PT_LOAD header for the section. This
5894 also makes the PT_TLS header have the same
5896 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5898 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5901 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5903 p
->p_filesz
+= this_hdr
->sh_size
;
5904 /* A load section without SHF_ALLOC is something like
5905 a note section in a PT_NOTE segment. These take
5906 file space but are not loaded into memory. */
5907 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5908 p
->p_memsz
+= this_hdr
->sh_size
;
5910 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5912 if (p
->p_type
== PT_TLS
)
5913 p
->p_memsz
+= this_hdr
->sh_size
;
5915 /* .tbss is special. It doesn't contribute to p_memsz of
5917 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5918 p
->p_memsz
+= this_hdr
->sh_size
;
5921 if (align
> p
->p_align
5922 && !m
->p_align_valid
5923 && (p
->p_type
!= PT_LOAD
5924 || (abfd
->flags
& D_PAGED
) == 0))
5928 if (!m
->p_flags_valid
)
5931 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5933 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5940 /* PR ld/20815 - Check that the program header segment, if
5941 present, will be loaded into memory. */
5942 if (p
->p_type
== PT_PHDR
5943 && phdr_load_seg
== NULL
5944 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5945 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5947 /* The fix for this error is usually to edit the linker script being
5948 used and set up the program headers manually. Either that or
5949 leave room for the headers at the start of the SECTIONS. */
5950 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5951 " by LOAD segment"),
5953 if (link_info
== NULL
)
5955 /* Arrange for the linker to exit with an error, deleting
5956 the output file unless --noinhibit-exec is given. */
5957 link_info
->callbacks
->info ("%X");
5960 /* Check that all sections are in a PT_LOAD segment.
5961 Don't check funky gdb generated core files. */
5962 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5964 bool check_vma
= true;
5966 for (i
= 1; i
< m
->count
; i
++)
5967 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5968 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5969 ->this_hdr
), p
) != 0
5970 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5971 ->this_hdr
), p
) != 0)
5973 /* Looks like we have overlays packed into the segment. */
5978 for (i
= 0; i
< m
->count
; i
++)
5980 Elf_Internal_Shdr
*this_hdr
;
5983 sec
= m
->sections
[i
];
5984 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5985 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5986 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5989 /* xgettext:c-format */
5990 (_("%pB: section `%pA' can't be allocated in segment %d"),
5992 print_segment_map (m
);
5998 elf_next_file_pos (abfd
) = off
;
6000 if (link_info
!= NULL
6001 && phdr_load_seg
!= NULL
6002 && phdr_load_seg
->includes_filehdr
)
6004 /* There is a segment that contains both the file headers and the
6005 program headers, so provide a symbol __ehdr_start pointing there.
6006 A program can use this to examine itself robustly. */
6008 struct elf_link_hash_entry
*hash
6009 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
6010 false, false, true);
6011 /* If the symbol was referenced and not defined, define it. */
6013 && (hash
->root
.type
== bfd_link_hash_new
6014 || hash
->root
.type
== bfd_link_hash_undefined
6015 || hash
->root
.type
== bfd_link_hash_undefweak
6016 || hash
->root
.type
== bfd_link_hash_common
))
6019 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
/ opb
;
6021 if (phdr_load_seg
->count
!= 0)
6022 /* The segment contains sections, so use the first one. */
6023 s
= phdr_load_seg
->sections
[0];
6025 /* Use the first (i.e. lowest-addressed) section in any segment. */
6026 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6027 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6035 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6036 hash
->root
.u
.def
.section
= s
;
6040 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6041 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6044 hash
->root
.type
= bfd_link_hash_defined
;
6045 hash
->def_regular
= 1;
6053 /* Determine if a bfd is a debuginfo file. Unfortunately there
6054 is no defined method for detecting such files, so we have to
6055 use heuristics instead. */
6058 is_debuginfo_file (bfd
*abfd
)
6060 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6063 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6064 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6065 Elf_Internal_Shdr
**headerp
;
6067 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6069 Elf_Internal_Shdr
*header
= * headerp
;
6071 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6072 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6073 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6074 && header
->sh_type
!= SHT_NOBITS
6075 && header
->sh_type
!= SHT_NOTE
)
6082 /* Assign file positions for the other sections, except for compressed debugging
6083 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6086 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6087 struct bfd_link_info
*link_info
)
6089 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6090 Elf_Internal_Shdr
**i_shdrpp
;
6091 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6092 Elf_Internal_Phdr
*phdrs
;
6093 Elf_Internal_Phdr
*p
;
6094 struct elf_segment_map
*m
;
6096 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
6097 bfd_vma maxpagesize
;
6099 if (link_info
!= NULL
)
6100 maxpagesize
= link_info
->maxpagesize
;
6102 maxpagesize
= bed
->maxpagesize
;
6103 i_shdrpp
= elf_elfsections (abfd
);
6104 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6105 off
= elf_next_file_pos (abfd
);
6106 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6108 Elf_Internal_Shdr
*hdr
;
6111 if (hdr
->bfd_section
!= NULL
6112 && (hdr
->bfd_section
->filepos
!= 0
6113 || (hdr
->sh_type
== SHT_NOBITS
6114 && hdr
->contents
== NULL
)))
6115 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6116 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6118 if (hdr
->sh_size
!= 0
6119 /* PR 24717 - debuginfo files are known to be not strictly
6120 compliant with the ELF standard. In particular they often
6121 have .note.gnu.property sections that are outside of any
6122 loadable segment. This is not a problem for such files,
6123 so do not warn about them. */
6124 && ! is_debuginfo_file (abfd
))
6126 /* xgettext:c-format */
6127 (_("%pB: warning: allocated section `%s' not in segment"),
6129 (hdr
->bfd_section
== NULL
6131 : hdr
->bfd_section
->name
));
6132 /* We don't need to page align empty sections. */
6133 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6134 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6137 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6139 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6142 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6143 && hdr
->bfd_section
== NULL
)
6144 /* We don't know the offset of these sections yet: their size has
6145 not been decided. */
6146 || (hdr
->bfd_section
!= NULL
6147 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6148 || (bfd_section_is_ctf (hdr
->bfd_section
)
6149 && abfd
->is_linker_output
)))
6150 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6151 || (elf_symtab_shndx_list (abfd
) != NULL
6152 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6153 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6154 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6155 hdr
->sh_offset
= -1;
6157 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6159 elf_next_file_pos (abfd
) = off
;
6161 /* Now that we have set the section file positions, we can set up
6162 the file positions for the non PT_LOAD segments. */
6163 phdrs
= elf_tdata (abfd
)->phdr
;
6164 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6166 if (p
->p_type
== PT_GNU_RELRO
)
6168 bfd_vma start
, end
; /* Bytes. */
6171 if (link_info
!= NULL
)
6173 /* During linking the range of the RELRO segment is passed
6174 in link_info. Note that there may be padding between
6175 relro_start and the first RELRO section. */
6176 start
= link_info
->relro_start
;
6177 end
= link_info
->relro_end
;
6179 else if (m
->count
!= 0)
6181 if (!m
->p_size_valid
)
6183 start
= m
->sections
[0]->vma
;
6184 end
= start
+ m
->p_size
/ opb
;
6195 struct elf_segment_map
*lm
;
6196 const Elf_Internal_Phdr
*lp
;
6199 /* Find a LOAD segment containing a section in the RELRO
6201 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6203 lm
= lm
->next
, lp
++)
6205 if (lp
->p_type
== PT_LOAD
6207 && (lm
->sections
[lm
->count
- 1]->vma
6208 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6209 ? lm
->sections
[lm
->count
- 1]->size
/ opb
6211 && lm
->sections
[0]->vma
< end
)
6217 /* Find the section starting the RELRO segment. */
6218 for (i
= 0; i
< lm
->count
; i
++)
6220 asection
*s
= lm
->sections
[i
];
6229 p
->p_vaddr
= lm
->sections
[i
]->vma
* opb
;
6230 p
->p_paddr
= lm
->sections
[i
]->lma
* opb
;
6231 p
->p_offset
= lm
->sections
[i
]->filepos
;
6232 p
->p_memsz
= end
* opb
- p
->p_vaddr
;
6233 p
->p_filesz
= p
->p_memsz
;
6235 /* The RELRO segment typically ends a few bytes
6236 into .got.plt but other layouts are possible.
6237 In cases where the end does not match any
6238 loaded section (for instance is in file
6239 padding), trim p_filesz back to correspond to
6240 the end of loaded section contents. */
6241 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6242 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6244 /* Preserve the alignment and flags if they are
6245 valid. The gold linker generates RW/4 for
6246 the PT_GNU_RELRO section. It is better for
6247 objcopy/strip to honor these attributes
6248 otherwise gdb will choke when using separate
6250 if (!m
->p_align_valid
)
6252 if (!m
->p_flags_valid
)
6258 if (link_info
!= NULL
)
6261 memset (p
, 0, sizeof *p
);
6263 else if (p
->p_type
== PT_GNU_STACK
)
6265 if (m
->p_size_valid
)
6266 p
->p_memsz
= m
->p_size
;
6268 else if (m
->count
!= 0)
6272 if (p
->p_type
!= PT_LOAD
6273 && (p
->p_type
!= PT_NOTE
6274 || bfd_get_format (abfd
) != bfd_core
))
6276 /* A user specified segment layout may include a PHDR
6277 segment that overlaps with a LOAD segment... */
6278 if (p
->p_type
== PT_PHDR
)
6284 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6286 /* PR 17512: file: 2195325e. */
6288 (_("%pB: error: non-load segment %d includes file header "
6289 "and/or program header"),
6290 abfd
, (int) (p
- phdrs
));
6295 p
->p_offset
= m
->sections
[0]->filepos
;
6296 for (i
= m
->count
; i
-- != 0;)
6298 asection
*sect
= m
->sections
[i
];
6299 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6300 if (hdr
->sh_type
!= SHT_NOBITS
)
6302 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6304 /* NB: p_memsz of the loadable PT_NOTE segment
6305 should be the same as p_filesz. */
6306 if (p
->p_type
== PT_NOTE
6307 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
6308 p
->p_memsz
= p
->p_filesz
;
6319 static elf_section_list
*
6320 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6322 for (;list
!= NULL
; list
= list
->next
)
6328 /* Work out the file positions of all the sections. This is called by
6329 _bfd_elf_compute_section_file_positions. All the section sizes and
6330 VMAs must be known before this is called.
6332 Reloc sections come in two flavours: Those processed specially as
6333 "side-channel" data attached to a section to which they apply, and those that
6334 bfd doesn't process as relocations. The latter sort are stored in a normal
6335 bfd section by bfd_section_from_shdr. We don't consider the former sort
6336 here, unless they form part of the loadable image. Reloc sections not
6337 assigned here (and compressed debugging sections and CTF sections which
6338 nothing else in the file can rely upon) will be handled later by
6339 assign_file_positions_for_relocs.
6341 We also don't set the positions of the .symtab and .strtab here. */
6344 assign_file_positions_except_relocs (bfd
*abfd
,
6345 struct bfd_link_info
*link_info
)
6347 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6348 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6349 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6352 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6353 && bfd_get_format (abfd
) != bfd_core
)
6355 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6356 unsigned int num_sec
= elf_numsections (abfd
);
6357 Elf_Internal_Shdr
**hdrpp
;
6361 /* Start after the ELF header. */
6362 off
= i_ehdrp
->e_ehsize
;
6364 /* We are not creating an executable, which means that we are
6365 not creating a program header, and that the actual order of
6366 the sections in the file is unimportant. */
6367 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6369 Elf_Internal_Shdr
*hdr
;
6372 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6373 && hdr
->bfd_section
== NULL
)
6374 /* Do not assign offsets for these sections yet: we don't know
6376 || (hdr
->bfd_section
!= NULL
6377 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6378 || (bfd_section_is_ctf (hdr
->bfd_section
)
6379 && abfd
->is_linker_output
)))
6380 || i
== elf_onesymtab (abfd
)
6381 || (elf_symtab_shndx_list (abfd
) != NULL
6382 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6383 || i
== elf_strtab_sec (abfd
)
6384 || i
== elf_shstrtab_sec (abfd
))
6386 hdr
->sh_offset
= -1;
6389 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6392 elf_next_file_pos (abfd
) = off
;
6393 elf_program_header_size (abfd
) = 0;
6397 /* Assign file positions for the loaded sections based on the
6398 assignment of sections to segments. */
6399 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6402 /* And for non-load sections. */
6403 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6407 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6410 /* Write out the program headers. */
6411 alloc
= i_ehdrp
->e_phnum
;
6414 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6415 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6423 _bfd_elf_init_file_header (bfd
*abfd
,
6424 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6426 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6427 struct elf_strtab_hash
*shstrtab
;
6428 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6430 i_ehdrp
= elf_elfheader (abfd
);
6432 shstrtab
= _bfd_elf_strtab_init ();
6433 if (shstrtab
== NULL
)
6436 elf_shstrtab (abfd
) = shstrtab
;
6438 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6439 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6440 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6441 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6443 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6444 i_ehdrp
->e_ident
[EI_DATA
] =
6445 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6446 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6448 if ((abfd
->flags
& DYNAMIC
) != 0)
6449 i_ehdrp
->e_type
= ET_DYN
;
6450 else if ((abfd
->flags
& EXEC_P
) != 0)
6451 i_ehdrp
->e_type
= ET_EXEC
;
6452 else if (bfd_get_format (abfd
) == bfd_core
)
6453 i_ehdrp
->e_type
= ET_CORE
;
6455 i_ehdrp
->e_type
= ET_REL
;
6457 switch (bfd_get_arch (abfd
))
6459 case bfd_arch_unknown
:
6460 i_ehdrp
->e_machine
= EM_NONE
;
6463 /* There used to be a long list of cases here, each one setting
6464 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6465 in the corresponding bfd definition. To avoid duplication,
6466 the switch was removed. Machines that need special handling
6467 can generally do it in elf_backend_final_write_processing(),
6468 unless they need the information earlier than the final write.
6469 Such need can generally be supplied by replacing the tests for
6470 e_machine with the conditions used to determine it. */
6472 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6475 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6476 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6478 /* No program header, for now. */
6479 i_ehdrp
->e_phoff
= 0;
6480 i_ehdrp
->e_phentsize
= 0;
6481 i_ehdrp
->e_phnum
= 0;
6483 /* Each bfd section is section header entry. */
6484 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6485 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6487 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6488 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
6489 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6490 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
6491 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6492 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
6493 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6494 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6495 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6501 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6503 FIXME: We used to have code here to sort the PT_LOAD segments into
6504 ascending order, as per the ELF spec. But this breaks some programs,
6505 including the Linux kernel. But really either the spec should be
6506 changed or the programs updated. */
6509 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6511 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6513 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6514 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6515 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6516 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6517 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6519 /* Find the lowest p_vaddr in PT_LOAD segments. */
6520 bfd_vma p_vaddr
= (bfd_vma
) -1;
6521 for (; segment
< end_segment
; segment
++)
6522 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6523 p_vaddr
= segment
->p_vaddr
;
6525 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6526 segments is non-zero. */
6528 i_ehdrp
->e_type
= ET_EXEC
;
6533 /* Assign file positions for all the reloc sections which are not part
6534 of the loadable file image, and the file position of section headers. */
6537 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6540 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6541 Elf_Internal_Shdr
*shdrp
;
6542 Elf_Internal_Ehdr
*i_ehdrp
;
6543 const struct elf_backend_data
*bed
;
6545 off
= elf_next_file_pos (abfd
);
6547 shdrpp
= elf_elfsections (abfd
);
6548 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6549 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6552 if (shdrp
->sh_offset
== -1)
6554 asection
*sec
= shdrp
->bfd_section
;
6555 bool is_rel
= (shdrp
->sh_type
== SHT_REL
6556 || shdrp
->sh_type
== SHT_RELA
);
6557 bool is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6560 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6562 if (!is_rel
&& !is_ctf
)
6564 const char *name
= sec
->name
;
6565 struct bfd_elf_section_data
*d
;
6567 /* Compress DWARF debug sections. */
6568 if (!bfd_compress_section (abfd
, sec
,
6572 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6573 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6575 /* If section is compressed with zlib-gnu, convert
6576 section name from .debug_* to .zdebug_*. */
6578 = convert_debug_to_zdebug (abfd
, name
);
6579 if (new_name
== NULL
)
6583 /* Add section name to section name section. */
6584 if (shdrp
->sh_name
!= (unsigned int) -1)
6587 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6589 d
= elf_section_data (sec
);
6591 /* Add reloc section name to section name section. */
6593 && !_bfd_elf_set_reloc_sh_name (abfd
,
6598 && !_bfd_elf_set_reloc_sh_name (abfd
,
6603 /* Update section size and contents. */
6604 shdrp
->sh_size
= sec
->size
;
6605 shdrp
->contents
= sec
->contents
;
6606 shdrp
->bfd_section
->contents
= NULL
;
6610 /* Update section size and contents. */
6611 shdrp
->sh_size
= sec
->size
;
6612 shdrp
->contents
= sec
->contents
;
6615 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6622 /* Place section name section after DWARF debug sections have been
6624 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6625 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6626 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6627 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
6629 /* Place the section headers. */
6630 i_ehdrp
= elf_elfheader (abfd
);
6631 bed
= get_elf_backend_data (abfd
);
6632 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6633 i_ehdrp
->e_shoff
= off
;
6634 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6635 elf_next_file_pos (abfd
) = off
;
6641 _bfd_elf_write_object_contents (bfd
*abfd
)
6643 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6644 Elf_Internal_Shdr
**i_shdrp
;
6646 unsigned int count
, num_sec
;
6647 struct elf_obj_tdata
*t
;
6649 if (! abfd
->output_has_begun
6650 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6652 /* Do not rewrite ELF data when the BFD has been opened for update.
6653 abfd->output_has_begun was set to TRUE on opening, so creation of new
6654 sections, and modification of existing section sizes was restricted.
6655 This means the ELF header, program headers and section headers can't have
6657 If the contents of any sections has been modified, then those changes have
6658 already been written to the BFD. */
6659 else if (abfd
->direction
== both_direction
)
6661 BFD_ASSERT (abfd
->output_has_begun
);
6665 i_shdrp
= elf_elfsections (abfd
);
6668 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6672 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6675 /* After writing the headers, we need to write the sections too... */
6676 num_sec
= elf_numsections (abfd
);
6677 for (count
= 1; count
< num_sec
; count
++)
6679 i_shdrp
[count
]->sh_name
6680 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6681 i_shdrp
[count
]->sh_name
);
6682 if (bed
->elf_backend_section_processing
)
6683 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6685 if (i_shdrp
[count
]->contents
)
6687 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6689 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6690 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6695 /* Write out the section header names. */
6696 t
= elf_tdata (abfd
);
6697 if (elf_shstrtab (abfd
) != NULL
6698 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6699 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6702 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6705 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6708 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6709 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6710 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6716 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6718 /* Hopefully this can be done just like an object file. */
6719 return _bfd_elf_write_object_contents (abfd
);
6722 /* Given a section, search the header to find them. */
6725 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6727 const struct elf_backend_data
*bed
;
6728 unsigned int sec_index
;
6730 if (elf_section_data (asect
) != NULL
6731 && elf_section_data (asect
)->this_idx
!= 0)
6732 return elf_section_data (asect
)->this_idx
;
6734 if (bfd_is_abs_section (asect
))
6735 sec_index
= SHN_ABS
;
6736 else if (bfd_is_com_section (asect
))
6737 sec_index
= SHN_COMMON
;
6738 else if (bfd_is_und_section (asect
))
6739 sec_index
= SHN_UNDEF
;
6741 sec_index
= SHN_BAD
;
6743 bed
= get_elf_backend_data (abfd
);
6744 if (bed
->elf_backend_section_from_bfd_section
)
6746 int retval
= sec_index
;
6748 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6752 if (sec_index
== SHN_BAD
)
6753 bfd_set_error (bfd_error_nonrepresentable_section
);
6758 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6762 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6764 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6766 flagword flags
= asym_ptr
->flags
;
6768 /* When gas creates relocations against local labels, it creates its
6769 own symbol for the section, but does put the symbol into the
6770 symbol chain, so udata is 0. When the linker is generating
6771 relocatable output, this section symbol may be for one of the
6772 input sections rather than the output section. */
6773 if (asym_ptr
->udata
.i
== 0
6774 && (flags
& BSF_SECTION_SYM
)
6775 && asym_ptr
->section
)
6780 sec
= asym_ptr
->section
;
6781 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6782 sec
= sec
->output_section
;
6783 if (sec
->owner
== abfd
6784 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6785 && elf_section_syms (abfd
)[indx
] != NULL
)
6786 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6789 idx
= asym_ptr
->udata
.i
;
6793 /* This case can occur when using --strip-symbol on a symbol
6794 which is used in a relocation entry. */
6796 /* xgettext:c-format */
6797 (_("%pB: symbol `%s' required but not present"),
6798 abfd
, bfd_asymbol_name (asym_ptr
));
6799 bfd_set_error (bfd_error_no_symbols
);
6806 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6807 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6815 /* Rewrite program header information. */
6818 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
, bfd_vma maxpagesize
)
6820 Elf_Internal_Ehdr
*iehdr
;
6821 struct elf_segment_map
*map
;
6822 struct elf_segment_map
*map_first
;
6823 struct elf_segment_map
**pointer_to_map
;
6824 Elf_Internal_Phdr
*segment
;
6827 unsigned int num_segments
;
6828 bool phdr_included
= false;
6830 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6831 unsigned int phdr_adjust_num
= 0;
6832 const struct elf_backend_data
*bed
;
6833 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
6835 bed
= get_elf_backend_data (ibfd
);
6836 iehdr
= elf_elfheader (ibfd
);
6839 pointer_to_map
= &map_first
;
6841 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6843 /* Returns the end address of the segment + 1. */
6844 #define SEGMENT_END(segment, start) \
6845 (start + (segment->p_memsz > segment->p_filesz \
6846 ? segment->p_memsz : segment->p_filesz))
6848 #define SECTION_SIZE(section, segment) \
6849 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6850 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6851 ? section->size : 0)
6853 /* Returns TRUE if the given section is contained within
6854 the given segment. VMA addresses are compared. */
6855 #define IS_CONTAINED_BY_VMA(section, segment, opb) \
6856 (section->vma * (opb) >= segment->p_vaddr \
6857 && (section->vma * (opb) + SECTION_SIZE (section, segment) \
6858 <= (SEGMENT_END (segment, segment->p_vaddr))))
6860 /* Returns TRUE if the given section is contained within
6861 the given segment. LMA addresses are compared. */
6862 #define IS_CONTAINED_BY_LMA(section, segment, base, opb) \
6863 (section->lma * (opb) >= base \
6864 && (section->lma + SECTION_SIZE (section, segment) / (opb) >= section->lma) \
6865 && (section->lma * (opb) + SECTION_SIZE (section, segment) \
6866 <= SEGMENT_END (segment, base)))
6868 /* Handle PT_NOTE segment. */
6869 #define IS_NOTE(p, s) \
6870 (p->p_type == PT_NOTE \
6871 && elf_section_type (s) == SHT_NOTE \
6872 && (bfd_vma) s->filepos >= p->p_offset \
6873 && ((bfd_vma) s->filepos + s->size \
6874 <= p->p_offset + p->p_filesz))
6876 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6878 #define IS_COREFILE_NOTE(p, s) \
6880 && bfd_get_format (ibfd) == bfd_core \
6884 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6885 linker, which generates a PT_INTERP section with p_vaddr and
6886 p_memsz set to 0. */
6887 #define IS_SOLARIS_PT_INTERP(p, s) \
6889 && p->p_paddr == 0 \
6890 && p->p_memsz == 0 \
6891 && p->p_filesz > 0 \
6892 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6894 && (bfd_vma) s->filepos >= p->p_offset \
6895 && ((bfd_vma) s->filepos + s->size \
6896 <= p->p_offset + p->p_filesz))
6898 /* Decide if the given section should be included in the given segment.
6899 A section will be included if:
6900 1. It is within the address space of the segment -- we use the LMA
6901 if that is set for the segment and the VMA otherwise,
6902 2. It is an allocated section or a NOTE section in a PT_NOTE
6904 3. There is an output section associated with it,
6905 4. The section has not already been allocated to a previous segment.
6906 5. PT_GNU_STACK segments do not include any sections.
6907 6. PT_TLS segment includes only SHF_TLS sections.
6908 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6909 8. PT_DYNAMIC should not contain empty sections at the beginning
6910 (with the possible exception of .dynamic). */
6911 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed, opb) \
6912 ((((segment->p_paddr \
6913 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr, opb) \
6914 : IS_CONTAINED_BY_VMA (section, segment, opb)) \
6915 && (section->flags & SEC_ALLOC) != 0) \
6916 || IS_NOTE (segment, section)) \
6917 && segment->p_type != PT_GNU_STACK \
6918 && (segment->p_type != PT_TLS \
6919 || (section->flags & SEC_THREAD_LOCAL)) \
6920 && (segment->p_type == PT_LOAD \
6921 || segment->p_type == PT_TLS \
6922 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6923 && (segment->p_type != PT_DYNAMIC \
6924 || SECTION_SIZE (section, segment) > 0 \
6925 || (segment->p_paddr \
6926 ? segment->p_paddr != section->lma * (opb) \
6927 : segment->p_vaddr != section->vma * (opb)) \
6928 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6929 && (segment->p_type != PT_LOAD || !section->segment_mark))
6931 /* If the output section of a section in the input segment is NULL,
6932 it is removed from the corresponding output segment. */
6933 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed, opb) \
6934 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed, opb) \
6935 && section->output_section != NULL)
6937 /* Returns TRUE iff seg1 starts after the end of seg2. */
6938 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6939 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6941 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6942 their VMA address ranges and their LMA address ranges overlap.
6943 It is possible to have overlapping VMA ranges without overlapping LMA
6944 ranges. RedBoot images for example can have both .data and .bss mapped
6945 to the same VMA range, but with the .data section mapped to a different
6947 #define SEGMENT_OVERLAPS(seg1, seg2) \
6948 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6949 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6950 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6951 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6953 /* Initialise the segment mark field. */
6954 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6955 section
->segment_mark
= false;
6957 /* The Solaris linker creates program headers in which all the
6958 p_paddr fields are zero. When we try to objcopy or strip such a
6959 file, we get confused. Check for this case, and if we find it
6960 don't set the p_paddr_valid fields. */
6961 p_paddr_valid
= false;
6962 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6965 if (segment
->p_paddr
!= 0)
6967 p_paddr_valid
= true;
6971 /* Scan through the segments specified in the program header
6972 of the input BFD. For this first scan we look for overlaps
6973 in the loadable segments. These can be created by weird
6974 parameters to objcopy. Also, fix some solaris weirdness. */
6975 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6980 Elf_Internal_Phdr
*segment2
;
6982 if (segment
->p_type
== PT_INTERP
)
6983 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6984 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6986 /* Mininal change so that the normal section to segment
6987 assignment code will work. */
6988 segment
->p_vaddr
= section
->vma
* opb
;
6992 if (segment
->p_type
!= PT_LOAD
)
6994 /* Remove PT_GNU_RELRO segment. */
6995 if (segment
->p_type
== PT_GNU_RELRO
)
6996 segment
->p_type
= PT_NULL
;
7000 /* Determine if this segment overlaps any previous segments. */
7001 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
7003 bfd_signed_vma extra_length
;
7005 if (segment2
->p_type
!= PT_LOAD
7006 || !SEGMENT_OVERLAPS (segment
, segment2
))
7009 /* Merge the two segments together. */
7010 if (segment2
->p_vaddr
< segment
->p_vaddr
)
7012 /* Extend SEGMENT2 to include SEGMENT and then delete
7014 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
7015 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
7017 if (extra_length
> 0)
7019 segment2
->p_memsz
+= extra_length
;
7020 segment2
->p_filesz
+= extra_length
;
7023 segment
->p_type
= PT_NULL
;
7025 /* Since we have deleted P we must restart the outer loop. */
7027 segment
= elf_tdata (ibfd
)->phdr
;
7032 /* Extend SEGMENT to include SEGMENT2 and then delete
7034 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7035 - SEGMENT_END (segment
, segment
->p_vaddr
));
7037 if (extra_length
> 0)
7039 segment
->p_memsz
+= extra_length
;
7040 segment
->p_filesz
+= extra_length
;
7043 segment2
->p_type
= PT_NULL
;
7048 /* The second scan attempts to assign sections to segments. */
7049 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7053 unsigned int section_count
;
7054 asection
**sections
;
7055 asection
*output_section
;
7057 asection
*matching_lma
;
7058 asection
*suggested_lma
;
7061 asection
*first_section
;
7063 if (segment
->p_type
== PT_NULL
)
7066 first_section
= NULL
;
7067 /* Compute how many sections might be placed into this segment. */
7068 for (section
= ibfd
->sections
, section_count
= 0;
7070 section
= section
->next
)
7072 /* Find the first section in the input segment, which may be
7073 removed from the corresponding output segment. */
7074 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
, opb
))
7076 if (first_section
== NULL
)
7077 first_section
= section
;
7078 if (section
->output_section
!= NULL
)
7083 /* Allocate a segment map big enough to contain
7084 all of the sections we have selected. */
7085 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7086 amt
+= section_count
* sizeof (asection
*);
7087 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7091 /* Initialise the fields of the segment map. Default to
7092 using the physical address of the segment in the input BFD. */
7094 map
->p_type
= segment
->p_type
;
7095 map
->p_flags
= segment
->p_flags
;
7096 map
->p_flags_valid
= 1;
7098 if (map
->p_type
== PT_LOAD
7099 && (ibfd
->flags
& D_PAGED
) != 0
7101 && segment
->p_align
> 1)
7103 map
->p_align
= segment
->p_align
;
7104 if (segment
->p_align
> maxpagesize
)
7105 map
->p_align
= maxpagesize
;
7106 map
->p_align_valid
= 1;
7109 /* If the first section in the input segment is removed, there is
7110 no need to preserve segment physical address in the corresponding
7112 if (!first_section
|| first_section
->output_section
!= NULL
)
7114 map
->p_paddr
= segment
->p_paddr
;
7115 map
->p_paddr_valid
= p_paddr_valid
;
7118 /* Determine if this segment contains the ELF file header
7119 and if it contains the program headers themselves. */
7120 map
->includes_filehdr
= (segment
->p_offset
== 0
7121 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7122 map
->includes_phdrs
= 0;
7124 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7126 map
->includes_phdrs
=
7127 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7128 && (segment
->p_offset
+ segment
->p_filesz
7129 >= ((bfd_vma
) iehdr
->e_phoff
7130 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7132 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7133 phdr_included
= true;
7136 if (section_count
== 0)
7138 /* Special segments, such as the PT_PHDR segment, may contain
7139 no sections, but ordinary, loadable segments should contain
7140 something. They are allowed by the ELF spec however, so only
7141 a warning is produced.
7142 There is however the valid use case of embedded systems which
7143 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7144 flash memory with zeros. No warning is shown for that case. */
7145 if (segment
->p_type
== PT_LOAD
7146 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7147 /* xgettext:c-format */
7149 (_("%pB: warning: empty loadable segment detected"
7150 " at vaddr=%#" PRIx64
", is this intentional?"),
7151 ibfd
, (uint64_t) segment
->p_vaddr
);
7153 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7155 *pointer_to_map
= map
;
7156 pointer_to_map
= &map
->next
;
7161 /* Now scan the sections in the input BFD again and attempt
7162 to add their corresponding output sections to the segment map.
7163 The problem here is how to handle an output section which has
7164 been moved (ie had its LMA changed). There are four possibilities:
7166 1. None of the sections have been moved.
7167 In this case we can continue to use the segment LMA from the
7170 2. All of the sections have been moved by the same amount.
7171 In this case we can change the segment's LMA to match the LMA
7172 of the first section.
7174 3. Some of the sections have been moved, others have not.
7175 In this case those sections which have not been moved can be
7176 placed in the current segment which will have to have its size,
7177 and possibly its LMA changed, and a new segment or segments will
7178 have to be created to contain the other sections.
7180 4. The sections have been moved, but not by the same amount.
7181 In this case we can change the segment's LMA to match the LMA
7182 of the first section and we will have to create a new segment
7183 or segments to contain the other sections.
7185 In order to save time, we allocate an array to hold the section
7186 pointers that we are interested in. As these sections get assigned
7187 to a segment, they are removed from this array. */
7189 amt
= section_count
* sizeof (asection
*);
7190 sections
= (asection
**) bfd_malloc (amt
);
7191 if (sections
== NULL
)
7194 /* Step One: Scan for segment vs section LMA conflicts.
7195 Also add the sections to the section array allocated above.
7196 Also add the sections to the current segment. In the common
7197 case, where the sections have not been moved, this means that
7198 we have completely filled the segment, and there is nothing
7201 matching_lma
= NULL
;
7202 suggested_lma
= NULL
;
7204 for (section
= first_section
, j
= 0;
7206 section
= section
->next
)
7208 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
, opb
))
7210 output_section
= section
->output_section
;
7212 sections
[j
++] = section
;
7214 /* The Solaris native linker always sets p_paddr to 0.
7215 We try to catch that case here, and set it to the
7216 correct value. Note - some backends require that
7217 p_paddr be left as zero. */
7219 && segment
->p_vaddr
!= 0
7220 && !bed
->want_p_paddr_set_to_zero
7222 && output_section
->lma
!= 0
7223 && (align_power (segment
->p_vaddr
7224 + (map
->includes_filehdr
7225 ? iehdr
->e_ehsize
: 0)
7226 + (map
->includes_phdrs
7227 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7229 output_section
->alignment_power
* opb
)
7230 == (output_section
->vma
* opb
)))
7231 map
->p_paddr
= segment
->p_vaddr
;
7233 /* Match up the physical address of the segment with the
7234 LMA address of the output section. */
7235 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7237 || IS_COREFILE_NOTE (segment
, section
)
7238 || (bed
->want_p_paddr_set_to_zero
7239 && IS_CONTAINED_BY_VMA (output_section
, segment
, opb
)))
7241 if (matching_lma
== NULL
7242 || output_section
->lma
< matching_lma
->lma
)
7243 matching_lma
= output_section
;
7245 /* We assume that if the section fits within the segment
7246 then it does not overlap any other section within that
7248 map
->sections
[isec
++] = output_section
;
7250 else if (suggested_lma
== NULL
)
7251 suggested_lma
= output_section
;
7253 if (j
== section_count
)
7258 BFD_ASSERT (j
== section_count
);
7260 /* Step Two: Adjust the physical address of the current segment,
7262 if (isec
== section_count
)
7264 /* All of the sections fitted within the segment as currently
7265 specified. This is the default case. Add the segment to
7266 the list of built segments and carry on to process the next
7267 program header in the input BFD. */
7268 map
->count
= section_count
;
7269 *pointer_to_map
= map
;
7270 pointer_to_map
= &map
->next
;
7273 && !bed
->want_p_paddr_set_to_zero
)
7275 bfd_vma hdr_size
= 0;
7276 if (map
->includes_filehdr
)
7277 hdr_size
= iehdr
->e_ehsize
;
7278 if (map
->includes_phdrs
)
7279 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7281 /* Account for padding before the first section in the
7283 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7284 - matching_lma
->lma
);
7292 /* Change the current segment's physical address to match
7293 the LMA of the first section that fitted, or if no
7294 section fitted, the first section. */
7295 if (matching_lma
== NULL
)
7296 matching_lma
= suggested_lma
;
7298 map
->p_paddr
= matching_lma
->lma
* opb
;
7300 /* Offset the segment physical address from the lma
7301 to allow for space taken up by elf headers. */
7302 if (map
->includes_phdrs
)
7304 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7306 /* iehdr->e_phnum is just an estimate of the number
7307 of program headers that we will need. Make a note
7308 here of the number we used and the segment we chose
7309 to hold these headers, so that we can adjust the
7310 offset when we know the correct value. */
7311 phdr_adjust_num
= iehdr
->e_phnum
;
7312 phdr_adjust_seg
= map
;
7315 if (map
->includes_filehdr
)
7317 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7318 map
->p_paddr
-= iehdr
->e_ehsize
;
7319 /* We've subtracted off the size of headers from the
7320 first section lma, but there may have been some
7321 alignment padding before that section too. Try to
7322 account for that by adjusting the segment lma down to
7323 the same alignment. */
7324 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7325 align
= segment
->p_align
;
7326 map
->p_paddr
&= -(align
* opb
);
7330 /* Step Three: Loop over the sections again, this time assigning
7331 those that fit to the current segment and removing them from the
7332 sections array; but making sure not to leave large gaps. Once all
7333 possible sections have been assigned to the current segment it is
7334 added to the list of built segments and if sections still remain
7335 to be assigned, a new segment is constructed before repeating
7341 suggested_lma
= NULL
;
7343 /* Fill the current segment with sections that fit. */
7344 for (j
= 0; j
< section_count
; j
++)
7346 section
= sections
[j
];
7348 if (section
== NULL
)
7351 output_section
= section
->output_section
;
7353 BFD_ASSERT (output_section
!= NULL
);
7355 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7357 || IS_COREFILE_NOTE (segment
, section
))
7359 if (map
->count
== 0)
7361 /* If the first section in a segment does not start at
7362 the beginning of the segment, then something is
7364 if (align_power (map
->p_paddr
7365 + (map
->includes_filehdr
7366 ? iehdr
->e_ehsize
: 0)
7367 + (map
->includes_phdrs
7368 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7370 output_section
->alignment_power
* opb
)
7371 != output_section
->lma
* opb
)
7378 prev_sec
= map
->sections
[map
->count
- 1];
7380 /* If the gap between the end of the previous section
7381 and the start of this section is more than
7382 maxpagesize then we need to start a new segment. */
7383 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7385 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7386 || (prev_sec
->lma
+ prev_sec
->size
7387 > output_section
->lma
))
7389 if (suggested_lma
== NULL
)
7390 suggested_lma
= output_section
;
7396 map
->sections
[map
->count
++] = output_section
;
7399 if (segment
->p_type
== PT_LOAD
)
7400 section
->segment_mark
= true;
7402 else if (suggested_lma
== NULL
)
7403 suggested_lma
= output_section
;
7406 /* PR 23932. A corrupt input file may contain sections that cannot
7407 be assigned to any segment - because for example they have a
7408 negative size - or segments that do not contain any sections.
7409 But there are also valid reasons why a segment can be empty.
7410 So allow a count of zero. */
7412 /* Add the current segment to the list of built segments. */
7413 *pointer_to_map
= map
;
7414 pointer_to_map
= &map
->next
;
7416 if (isec
< section_count
)
7418 /* We still have not allocated all of the sections to
7419 segments. Create a new segment here, initialise it
7420 and carry on looping. */
7421 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7422 amt
+= section_count
* sizeof (asection
*);
7423 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7430 /* Initialise the fields of the segment map. Set the physical
7431 physical address to the LMA of the first section that has
7432 not yet been assigned. */
7434 map
->p_type
= segment
->p_type
;
7435 map
->p_flags
= segment
->p_flags
;
7436 map
->p_flags_valid
= 1;
7437 map
->p_paddr
= suggested_lma
->lma
* opb
;
7438 map
->p_paddr_valid
= p_paddr_valid
;
7439 map
->includes_filehdr
= 0;
7440 map
->includes_phdrs
= 0;
7445 bfd_set_error (bfd_error_sorry
);
7449 while (isec
< section_count
);
7454 elf_seg_map (obfd
) = map_first
;
7456 /* If we had to estimate the number of program headers that were
7457 going to be needed, then check our estimate now and adjust
7458 the offset if necessary. */
7459 if (phdr_adjust_seg
!= NULL
)
7463 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7466 if (count
> phdr_adjust_num
)
7467 phdr_adjust_seg
->p_paddr
7468 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7470 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7471 if (map
->p_type
== PT_PHDR
)
7474 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7475 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7482 #undef IS_CONTAINED_BY_VMA
7483 #undef IS_CONTAINED_BY_LMA
7485 #undef IS_COREFILE_NOTE
7486 #undef IS_SOLARIS_PT_INTERP
7487 #undef IS_SECTION_IN_INPUT_SEGMENT
7488 #undef INCLUDE_SECTION_IN_SEGMENT
7489 #undef SEGMENT_AFTER_SEGMENT
7490 #undef SEGMENT_OVERLAPS
7494 /* Copy ELF program header information. */
7497 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7499 Elf_Internal_Ehdr
*iehdr
;
7500 struct elf_segment_map
*map
;
7501 struct elf_segment_map
*map_first
;
7502 struct elf_segment_map
**pointer_to_map
;
7503 Elf_Internal_Phdr
*segment
;
7505 unsigned int num_segments
;
7506 bool phdr_included
= false;
7508 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
7510 iehdr
= elf_elfheader (ibfd
);
7513 pointer_to_map
= &map_first
;
7515 /* If all the segment p_paddr fields are zero, don't set
7516 map->p_paddr_valid. */
7517 p_paddr_valid
= false;
7518 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7519 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7522 if (segment
->p_paddr
!= 0)
7524 p_paddr_valid
= true;
7528 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7533 unsigned int section_count
;
7535 Elf_Internal_Shdr
*this_hdr
;
7536 asection
*first_section
= NULL
;
7537 asection
*lowest_section
;
7539 /* Compute how many sections are in this segment. */
7540 for (section
= ibfd
->sections
, section_count
= 0;
7542 section
= section
->next
)
7544 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7545 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7547 if (first_section
== NULL
)
7548 first_section
= section
;
7553 /* Allocate a segment map big enough to contain
7554 all of the sections we have selected. */
7555 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7556 amt
+= section_count
* sizeof (asection
*);
7557 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7561 /* Initialize the fields of the output segment map with the
7564 map
->p_type
= segment
->p_type
;
7565 map
->p_flags
= segment
->p_flags
;
7566 map
->p_flags_valid
= 1;
7567 map
->p_paddr
= segment
->p_paddr
;
7568 map
->p_paddr_valid
= p_paddr_valid
;
7569 map
->p_align
= segment
->p_align
;
7570 map
->p_align_valid
= 1;
7571 map
->p_vaddr_offset
= 0;
7573 if (map
->p_type
== PT_GNU_RELRO
7574 || map
->p_type
== PT_GNU_STACK
)
7576 /* The PT_GNU_RELRO segment may contain the first a few
7577 bytes in the .got.plt section even if the whole .got.plt
7578 section isn't in the PT_GNU_RELRO segment. We won't
7579 change the size of the PT_GNU_RELRO segment.
7580 Similarly, PT_GNU_STACK size is significant on uclinux
7582 map
->p_size
= segment
->p_memsz
;
7583 map
->p_size_valid
= 1;
7586 /* Determine if this segment contains the ELF file header
7587 and if it contains the program headers themselves. */
7588 map
->includes_filehdr
= (segment
->p_offset
== 0
7589 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7591 map
->includes_phdrs
= 0;
7592 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7594 map
->includes_phdrs
=
7595 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7596 && (segment
->p_offset
+ segment
->p_filesz
7597 >= ((bfd_vma
) iehdr
->e_phoff
7598 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7600 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7601 phdr_included
= true;
7604 lowest_section
= NULL
;
7605 if (section_count
!= 0)
7607 unsigned int isec
= 0;
7609 for (section
= first_section
;
7611 section
= section
->next
)
7613 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7614 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7616 map
->sections
[isec
++] = section
->output_section
;
7617 if ((section
->flags
& SEC_ALLOC
) != 0)
7621 if (lowest_section
== NULL
7622 || section
->lma
< lowest_section
->lma
)
7623 lowest_section
= section
;
7625 /* Section lmas are set up from PT_LOAD header
7626 p_paddr in _bfd_elf_make_section_from_shdr.
7627 If this header has a p_paddr that disagrees
7628 with the section lma, flag the p_paddr as
7630 if ((section
->flags
& SEC_LOAD
) != 0)
7631 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7633 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7634 if (section
->lma
* opb
- segment
->p_paddr
!= seg_off
)
7635 map
->p_paddr_valid
= false;
7637 if (isec
== section_count
)
7643 if (section_count
== 0)
7644 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7645 else if (map
->p_paddr_valid
)
7647 /* Account for padding before the first section in the segment. */
7648 bfd_vma hdr_size
= 0;
7649 if (map
->includes_filehdr
)
7650 hdr_size
= iehdr
->e_ehsize
;
7651 if (map
->includes_phdrs
)
7652 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7654 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7655 - (lowest_section
? lowest_section
->lma
: 0));
7658 map
->count
= section_count
;
7659 *pointer_to_map
= map
;
7660 pointer_to_map
= &map
->next
;
7663 elf_seg_map (obfd
) = map_first
;
7667 /* Copy private BFD data. This copies or rewrites ELF program header
7671 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7673 bfd_vma maxpagesize
;
7675 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7676 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7679 if (elf_tdata (ibfd
)->phdr
== NULL
)
7682 if (ibfd
->xvec
== obfd
->xvec
)
7684 /* Check to see if any sections in the input BFD
7685 covered by ELF program header have changed. */
7686 Elf_Internal_Phdr
*segment
;
7687 asection
*section
, *osec
;
7688 unsigned int i
, num_segments
;
7689 Elf_Internal_Shdr
*this_hdr
;
7690 const struct elf_backend_data
*bed
;
7692 bed
= get_elf_backend_data (ibfd
);
7694 /* Regenerate the segment map if p_paddr is set to 0. */
7695 if (bed
->want_p_paddr_set_to_zero
)
7698 /* Initialize the segment mark field. */
7699 for (section
= obfd
->sections
; section
!= NULL
;
7700 section
= section
->next
)
7701 section
->segment_mark
= false;
7703 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7704 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7708 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7709 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7710 which severly confuses things, so always regenerate the segment
7711 map in this case. */
7712 if (segment
->p_paddr
== 0
7713 && segment
->p_memsz
== 0
7714 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7717 for (section
= ibfd
->sections
;
7718 section
!= NULL
; section
= section
->next
)
7720 /* We mark the output section so that we know it comes
7721 from the input BFD. */
7722 osec
= section
->output_section
;
7724 osec
->segment_mark
= true;
7726 /* Check if this section is covered by the segment. */
7727 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7728 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7730 /* FIXME: Check if its output section is changed or
7731 removed. What else do we need to check? */
7733 || section
->flags
!= osec
->flags
7734 || section
->lma
!= osec
->lma
7735 || section
->vma
!= osec
->vma
7736 || section
->size
!= osec
->size
7737 || section
->rawsize
!= osec
->rawsize
7738 || section
->alignment_power
!= osec
->alignment_power
)
7744 /* Check to see if any output section do not come from the
7746 for (section
= obfd
->sections
; section
!= NULL
;
7747 section
= section
->next
)
7749 if (!section
->segment_mark
)
7752 section
->segment_mark
= false;
7755 return copy_elf_program_header (ibfd
, obfd
);
7760 if (ibfd
->xvec
== obfd
->xvec
)
7762 /* When rewriting program header, set the output maxpagesize to
7763 the maximum alignment of input PT_LOAD segments. */
7764 Elf_Internal_Phdr
*segment
;
7766 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7768 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7771 if (segment
->p_type
== PT_LOAD
7772 && maxpagesize
< segment
->p_align
)
7774 /* PR 17512: file: f17299af. */
7775 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7776 /* xgettext:c-format */
7777 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7778 PRIx64
" is too large"),
7779 ibfd
, (uint64_t) segment
->p_align
);
7781 maxpagesize
= segment
->p_align
;
7784 if (maxpagesize
== 0)
7785 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
7787 return rewrite_elf_program_header (ibfd
, obfd
, maxpagesize
);
7790 /* Initialize private output section information from input section. */
7793 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7797 struct bfd_link_info
*link_info
)
7800 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7801 bool final_link
= (link_info
!= NULL
7802 && !bfd_link_relocatable (link_info
));
7804 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7805 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7808 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7810 /* If this is a known ABI section, ELF section type and flags may
7811 have been set up when OSEC was created. For normal sections we
7812 allow the user to override the type and flags other than
7813 SHF_MASKOS and SHF_MASKPROC. */
7814 if (elf_section_type (osec
) == SHT_PROGBITS
7815 || elf_section_type (osec
) == SHT_NOTE
7816 || elf_section_type (osec
) == SHT_NOBITS
)
7817 elf_section_type (osec
) = SHT_NULL
;
7818 /* For objcopy and relocatable link, copy the ELF section type from
7819 the input file if the BFD section flags are the same. (If they
7820 are different the user may be doing something like
7821 "objcopy --set-section-flags .text=alloc,data".) For a final
7822 link allow some flags that the linker clears to differ. */
7823 if (elf_section_type (osec
) == SHT_NULL
7824 && (osec
->flags
== isec
->flags
7826 && ((osec
->flags
^ isec
->flags
)
7827 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7828 elf_section_type (osec
) = elf_section_type (isec
);
7830 /* FIXME: Is this correct for all OS/PROC specific flags? */
7831 elf_section_flags (osec
) = (elf_section_flags (isec
)
7832 & (SHF_MASKOS
| SHF_MASKPROC
));
7834 /* Copy sh_info from input for mbind section. */
7835 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7836 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7837 elf_section_data (osec
)->this_hdr
.sh_info
7838 = elf_section_data (isec
)->this_hdr
.sh_info
;
7840 /* Set things up for objcopy and relocatable link. The output
7841 SHT_GROUP section will have its elf_next_in_group pointing back
7842 to the input group members. Ignore linker created group section.
7843 See elfNN_ia64_object_p in elfxx-ia64.c. */
7844 if ((link_info
== NULL
7845 || !link_info
->resolve_section_groups
)
7846 && (elf_sec_group (isec
) == NULL
7847 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7849 if (elf_section_flags (isec
) & SHF_GROUP
)
7850 elf_section_flags (osec
) |= SHF_GROUP
;
7851 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7852 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7855 /* If not decompress, preserve SHF_COMPRESSED. */
7856 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7857 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7860 ihdr
= &elf_section_data (isec
)->this_hdr
;
7862 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7863 don't use the output section of the linked-to section since it
7864 may be NULL at this point. */
7865 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7867 ohdr
= &elf_section_data (osec
)->this_hdr
;
7868 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7869 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7872 osec
->use_rela_p
= isec
->use_rela_p
;
7877 /* Copy private section information. This copies over the entsize
7878 field, and sometimes the info field. */
7881 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7886 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7888 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7889 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7892 ihdr
= &elf_section_data (isec
)->this_hdr
;
7893 ohdr
= &elf_section_data (osec
)->this_hdr
;
7895 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7897 if (ihdr
->sh_type
== SHT_SYMTAB
7898 || ihdr
->sh_type
== SHT_DYNSYM
7899 || ihdr
->sh_type
== SHT_GNU_verneed
7900 || ihdr
->sh_type
== SHT_GNU_verdef
)
7901 ohdr
->sh_info
= ihdr
->sh_info
;
7903 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7907 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7908 necessary if we are removing either the SHT_GROUP section or any of
7909 the group member sections. DISCARDED is the value that a section's
7910 output_section has if the section will be discarded, NULL when this
7911 function is called from objcopy, bfd_abs_section_ptr when called
7915 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7919 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7920 if (elf_section_type (isec
) == SHT_GROUP
)
7922 asection
*first
= elf_next_in_group (isec
);
7923 asection
*s
= first
;
7924 bfd_size_type removed
= 0;
7928 /* If this member section is being output but the
7929 SHT_GROUP section is not, then clear the group info
7930 set up by _bfd_elf_copy_private_section_data. */
7931 if (s
->output_section
!= discarded
7932 && isec
->output_section
== discarded
)
7934 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7935 elf_group_name (s
->output_section
) = NULL
;
7939 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7940 if (s
->output_section
== discarded
7941 && isec
->output_section
!= discarded
)
7943 /* Conversely, if the member section is not being
7944 output but the SHT_GROUP section is, then adjust
7947 if (elf_sec
->rel
.hdr
!= NULL
7948 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7950 if (elf_sec
->rela
.hdr
!= NULL
7951 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7956 /* Also adjust for zero-sized relocation member
7958 if (elf_sec
->rel
.hdr
!= NULL
7959 && elf_sec
->rel
.hdr
->sh_size
== 0)
7961 if (elf_sec
->rela
.hdr
!= NULL
7962 && elf_sec
->rela
.hdr
->sh_size
== 0)
7966 s
= elf_next_in_group (s
);
7972 if (discarded
!= NULL
)
7974 /* If we've been called for ld -r, then we need to
7975 adjust the input section size. */
7976 if (isec
->rawsize
== 0)
7977 isec
->rawsize
= isec
->size
;
7978 isec
->size
= isec
->rawsize
- removed
;
7979 if (isec
->size
<= 4)
7982 isec
->flags
|= SEC_EXCLUDE
;
7987 /* Adjust the output section size when called from
7989 isec
->output_section
->size
-= removed
;
7990 if (isec
->output_section
->size
<= 4)
7992 isec
->output_section
->size
= 0;
7993 isec
->output_section
->flags
|= SEC_EXCLUDE
;
8002 /* Copy private header information. */
8005 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
8007 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8008 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8011 /* Copy over private BFD data if it has not already been copied.
8012 This must be done here, rather than in the copy_private_bfd_data
8013 entry point, because the latter is called after the section
8014 contents have been set, which means that the program headers have
8015 already been worked out. */
8016 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
8018 if (! copy_private_bfd_data (ibfd
, obfd
))
8022 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
8025 /* Copy private symbol information. If this symbol is in a section
8026 which we did not map into a BFD section, try to map the section
8027 index correctly. We use special macro definitions for the mapped
8028 section indices; these definitions are interpreted by the
8029 swap_out_syms function. */
8031 #define MAP_ONESYMTAB (SHN_HIOS + 1)
8032 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
8033 #define MAP_STRTAB (SHN_HIOS + 3)
8034 #define MAP_SHSTRTAB (SHN_HIOS + 4)
8035 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
8038 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
8043 elf_symbol_type
*isym
, *osym
;
8045 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8046 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8049 isym
= elf_symbol_from (isymarg
);
8050 osym
= elf_symbol_from (osymarg
);
8053 && isym
->internal_elf_sym
.st_shndx
!= 0
8055 && bfd_is_abs_section (isym
->symbol
.section
))
8059 shndx
= isym
->internal_elf_sym
.st_shndx
;
8060 if (shndx
== elf_onesymtab (ibfd
))
8061 shndx
= MAP_ONESYMTAB
;
8062 else if (shndx
== elf_dynsymtab (ibfd
))
8063 shndx
= MAP_DYNSYMTAB
;
8064 else if (shndx
== elf_strtab_sec (ibfd
))
8066 else if (shndx
== elf_shstrtab_sec (ibfd
))
8067 shndx
= MAP_SHSTRTAB
;
8068 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
8069 shndx
= MAP_SYM_SHNDX
;
8070 osym
->internal_elf_sym
.st_shndx
= shndx
;
8076 /* Swap out the symbols. */
8079 swap_out_syms (bfd
*abfd
,
8080 struct elf_strtab_hash
**sttp
,
8082 struct bfd_link_info
*info
)
8084 const struct elf_backend_data
*bed
;
8085 unsigned int symcount
;
8087 struct elf_strtab_hash
*stt
;
8088 Elf_Internal_Shdr
*symtab_hdr
;
8089 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8090 Elf_Internal_Shdr
*symstrtab_hdr
;
8091 struct elf_sym_strtab
*symstrtab
;
8092 bfd_byte
*outbound_syms
;
8093 bfd_byte
*outbound_shndx
;
8094 unsigned long outbound_syms_index
;
8095 unsigned long outbound_shndx_index
;
8097 unsigned int num_locals
;
8099 bool name_local_sections
;
8101 if (!elf_map_symbols (abfd
, &num_locals
))
8104 /* Dump out the symtabs. */
8105 stt
= _bfd_elf_strtab_init ();
8109 bed
= get_elf_backend_data (abfd
);
8110 symcount
= bfd_get_symcount (abfd
);
8111 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8112 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8113 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8114 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8115 symtab_hdr
->sh_info
= num_locals
+ 1;
8116 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8118 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8119 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8121 /* Allocate buffer to swap out the .strtab section. */
8122 if (_bfd_mul_overflow (symcount
+ 1, sizeof (*symstrtab
), &amt
)
8123 || (symstrtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
)) == NULL
)
8125 bfd_set_error (bfd_error_no_memory
);
8126 _bfd_elf_strtab_free (stt
);
8130 if (_bfd_mul_overflow (symcount
+ 1, bed
->s
->sizeof_sym
, &amt
)
8131 || (outbound_syms
= (bfd_byte
*) bfd_alloc (abfd
, amt
)) == NULL
)
8134 bfd_set_error (bfd_error_no_memory
);
8137 _bfd_elf_strtab_free (stt
);
8140 symtab_hdr
->contents
= outbound_syms
;
8141 outbound_syms_index
= 0;
8143 outbound_shndx
= NULL
;
8144 outbound_shndx_index
= 0;
8146 if (elf_symtab_shndx_list (abfd
))
8148 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8149 if (symtab_shndx_hdr
->sh_name
!= 0)
8151 if (_bfd_mul_overflow (symcount
+ 1,
8152 sizeof (Elf_External_Sym_Shndx
), &amt
))
8154 outbound_shndx
= (bfd_byte
*) bfd_zalloc (abfd
, amt
);
8155 if (outbound_shndx
== NULL
)
8158 symtab_shndx_hdr
->contents
= outbound_shndx
;
8159 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8160 symtab_shndx_hdr
->sh_size
= amt
;
8161 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8162 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8164 /* FIXME: What about any other headers in the list ? */
8167 /* Now generate the data (for "contents"). */
8169 /* Fill in zeroth symbol and swap it out. */
8170 Elf_Internal_Sym sym
;
8176 sym
.st_shndx
= SHN_UNDEF
;
8177 sym
.st_target_internal
= 0;
8178 symstrtab
[0].sym
= sym
;
8179 symstrtab
[0].dest_index
= outbound_syms_index
;
8180 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8181 outbound_syms_index
++;
8182 if (outbound_shndx
!= NULL
)
8183 outbound_shndx_index
++;
8187 = (bed
->elf_backend_name_local_section_symbols
8188 && bed
->elf_backend_name_local_section_symbols (abfd
));
8190 syms
= bfd_get_outsymbols (abfd
);
8191 for (idx
= 0; idx
< symcount
;)
8193 Elf_Internal_Sym sym
;
8194 bfd_vma value
= syms
[idx
]->value
;
8195 elf_symbol_type
*type_ptr
;
8196 flagword flags
= syms
[idx
]->flags
;
8199 if (!name_local_sections
8200 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8202 /* Local section symbols have no name. */
8203 sym
.st_name
= (unsigned long) -1;
8207 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8208 to get the final offset for st_name. */
8210 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8212 if (sym
.st_name
== (unsigned long) -1)
8216 type_ptr
= elf_symbol_from (syms
[idx
]);
8218 if ((flags
& BSF_SECTION_SYM
) == 0
8219 && bfd_is_com_section (syms
[idx
]->section
))
8221 /* ELF common symbols put the alignment into the `value' field,
8222 and the size into the `size' field. This is backwards from
8223 how BFD handles it, so reverse it here. */
8224 sym
.st_size
= value
;
8225 if (type_ptr
== NULL
8226 || type_ptr
->internal_elf_sym
.st_value
== 0)
8227 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8229 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8230 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8231 (abfd
, syms
[idx
]->section
);
8235 asection
*sec
= syms
[idx
]->section
;
8238 if (sec
->output_section
)
8240 value
+= sec
->output_offset
;
8241 sec
= sec
->output_section
;
8244 /* Don't add in the section vma for relocatable output. */
8245 if (! relocatable_p
)
8247 sym
.st_value
= value
;
8248 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8250 if (bfd_is_abs_section (sec
)
8252 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8254 /* This symbol is in a real ELF section which we did
8255 not create as a BFD section. Undo the mapping done
8256 by copy_private_symbol_data. */
8257 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8261 shndx
= elf_onesymtab (abfd
);
8264 shndx
= elf_dynsymtab (abfd
);
8267 shndx
= elf_strtab_sec (abfd
);
8270 shndx
= elf_shstrtab_sec (abfd
);
8273 if (elf_symtab_shndx_list (abfd
))
8274 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8281 if (shndx
>= SHN_LOPROC
&& shndx
<= SHN_HIOS
)
8283 if (bed
->symbol_section_index
)
8284 shndx
= bed
->symbol_section_index (abfd
, type_ptr
);
8285 /* Otherwise just leave the index alone. */
8289 if (shndx
> SHN_HIOS
&& shndx
< SHN_HIRESERVE
)
8290 _bfd_error_handler (_("%pB: \
8291 Unable to handle section index %x in ELF symbol. Using ABS instead."),
8300 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8302 if (shndx
== SHN_BAD
)
8306 /* Writing this would be a hell of a lot easier if
8307 we had some decent documentation on bfd, and
8308 knew what to expect of the library, and what to
8309 demand of applications. For example, it
8310 appears that `objcopy' might not set the
8311 section of a symbol to be a section that is
8312 actually in the output file. */
8313 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8315 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8316 if (shndx
== SHN_BAD
)
8318 /* xgettext:c-format */
8320 (_("unable to find equivalent output section"
8321 " for symbol '%s' from section '%s'"),
8322 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8324 bfd_set_error (bfd_error_invalid_operation
);
8330 sym
.st_shndx
= shndx
;
8333 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8335 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8336 type
= STT_GNU_IFUNC
;
8337 else if ((flags
& BSF_FUNCTION
) != 0)
8339 else if ((flags
& BSF_OBJECT
) != 0)
8341 else if ((flags
& BSF_RELC
) != 0)
8343 else if ((flags
& BSF_SRELC
) != 0)
8348 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8351 /* Processor-specific types. */
8352 if (type_ptr
!= NULL
8353 && bed
->elf_backend_get_symbol_type
)
8354 type
= ((*bed
->elf_backend_get_symbol_type
)
8355 (&type_ptr
->internal_elf_sym
, type
));
8357 if (flags
& BSF_SECTION_SYM
)
8359 if (flags
& BSF_GLOBAL
)
8360 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8362 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8364 else if (bfd_is_com_section (syms
[idx
]->section
))
8366 if (type
!= STT_TLS
)
8368 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8369 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8370 ? STT_COMMON
: STT_OBJECT
);
8372 type
= ((flags
& BSF_ELF_COMMON
) != 0
8373 ? STT_COMMON
: STT_OBJECT
);
8375 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8377 else if (bfd_is_und_section (syms
[idx
]->section
))
8378 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8382 else if (flags
& BSF_FILE
)
8383 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8386 int bind
= STB_LOCAL
;
8388 if (flags
& BSF_LOCAL
)
8390 else if (flags
& BSF_GNU_UNIQUE
)
8391 bind
= STB_GNU_UNIQUE
;
8392 else if (flags
& BSF_WEAK
)
8394 else if (flags
& BSF_GLOBAL
)
8397 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8400 if (type_ptr
!= NULL
)
8402 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8403 sym
.st_target_internal
8404 = type_ptr
->internal_elf_sym
.st_target_internal
;
8409 sym
.st_target_internal
= 0;
8413 symstrtab
[idx
].sym
= sym
;
8414 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8415 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8417 outbound_syms_index
++;
8418 if (outbound_shndx
!= NULL
)
8419 outbound_shndx_index
++;
8422 /* Finalize the .strtab section. */
8423 _bfd_elf_strtab_finalize (stt
);
8425 /* Swap out the .strtab section. */
8426 for (idx
= 0; idx
<= symcount
; idx
++)
8428 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8429 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8430 elfsym
->sym
.st_name
= 0;
8432 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8433 elfsym
->sym
.st_name
);
8434 if (info
&& info
->callbacks
->ctf_new_symbol
)
8435 info
->callbacks
->ctf_new_symbol (elfsym
->dest_index
,
8438 /* Inform the linker of the addition of this symbol. */
8440 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8442 + (elfsym
->dest_index
8443 * bed
->s
->sizeof_sym
)),
8445 + (elfsym
->destshndx_index
8446 * sizeof (Elf_External_Sym_Shndx
))));
8451 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8452 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8453 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8454 symstrtab_hdr
->sh_addr
= 0;
8455 symstrtab_hdr
->sh_entsize
= 0;
8456 symstrtab_hdr
->sh_link
= 0;
8457 symstrtab_hdr
->sh_info
= 0;
8458 symstrtab_hdr
->sh_addralign
= 1;
8463 /* Return the number of bytes required to hold the symtab vector.
8465 Note that we base it on the count plus 1, since we will null terminate
8466 the vector allocated based on this size. However, the ELF symbol table
8467 always has a dummy entry as symbol #0, so it ends up even. */
8470 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8472 bfd_size_type symcount
;
8474 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8476 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8477 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8479 bfd_set_error (bfd_error_file_too_big
);
8482 symtab_size
= symcount
* (sizeof (asymbol
*));
8484 symtab_size
= sizeof (asymbol
*);
8485 else if (!bfd_write_p (abfd
))
8487 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8489 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8491 bfd_set_error (bfd_error_file_truncated
);
8500 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8502 bfd_size_type symcount
;
8504 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8506 if (elf_dynsymtab (abfd
) == 0)
8508 bfd_set_error (bfd_error_invalid_operation
);
8512 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8513 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8515 bfd_set_error (bfd_error_file_too_big
);
8518 symtab_size
= symcount
* (sizeof (asymbol
*));
8520 symtab_size
= sizeof (asymbol
*);
8521 else if (!bfd_write_p (abfd
))
8523 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8525 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8527 bfd_set_error (bfd_error_file_truncated
);
8536 _bfd_elf_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
8538 if (asect
->reloc_count
!= 0 && !bfd_write_p (abfd
))
8540 /* Sanity check reloc section size. */
8541 struct bfd_elf_section_data
*d
= elf_section_data (asect
);
8542 Elf_Internal_Shdr
*rel_hdr
= &d
->this_hdr
;
8543 bfd_size_type ext_rel_size
= rel_hdr
->sh_size
;
8544 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8546 if (filesize
!= 0 && ext_rel_size
> filesize
)
8548 bfd_set_error (bfd_error_file_truncated
);
8553 #if SIZEOF_LONG == SIZEOF_INT
8554 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8556 bfd_set_error (bfd_error_file_too_big
);
8560 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8563 /* Canonicalize the relocs. */
8566 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8573 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8575 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
8578 tblptr
= section
->relocation
;
8579 for (i
= 0; i
< section
->reloc_count
; i
++)
8580 *relptr
++ = tblptr
++;
8584 return section
->reloc_count
;
8588 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8590 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8591 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, false);
8594 abfd
->symcount
= symcount
;
8599 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8600 asymbol
**allocation
)
8602 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8603 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, true);
8606 abfd
->dynsymcount
= symcount
;
8610 /* Return the size required for the dynamic reloc entries. Any loadable
8611 section that was actually installed in the BFD, and has type SHT_REL
8612 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8613 dynamic reloc section. */
8616 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8618 bfd_size_type count
, ext_rel_size
;
8621 if (elf_dynsymtab (abfd
) == 0)
8623 bfd_set_error (bfd_error_invalid_operation
);
8629 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8630 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8631 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8632 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8634 ext_rel_size
+= s
->size
;
8635 if (ext_rel_size
< s
->size
)
8637 bfd_set_error (bfd_error_file_truncated
);
8640 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8641 if (count
> LONG_MAX
/ sizeof (arelent
*))
8643 bfd_set_error (bfd_error_file_too_big
);
8647 if (count
> 1 && !bfd_write_p (abfd
))
8649 /* Sanity check reloc section sizes. */
8650 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8651 if (filesize
!= 0 && ext_rel_size
> filesize
)
8653 bfd_set_error (bfd_error_file_truncated
);
8657 return count
* sizeof (arelent
*);
8660 /* Canonicalize the dynamic relocation entries. Note that we return the
8661 dynamic relocations as a single block, although they are actually
8662 associated with particular sections; the interface, which was
8663 designed for SunOS style shared libraries, expects that there is only
8664 one set of dynamic relocs. Any loadable section that was actually
8665 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8666 dynamic symbol table, is considered to be a dynamic reloc section. */
8669 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8673 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
8677 if (elf_dynsymtab (abfd
) == 0)
8679 bfd_set_error (bfd_error_invalid_operation
);
8683 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8685 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8687 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8688 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8689 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8694 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
8696 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8698 for (i
= 0; i
< count
; i
++)
8709 /* Read in the version information. */
8712 _bfd_elf_slurp_version_tables (bfd
*abfd
, bool default_imported_symver
)
8714 bfd_byte
*contents
= NULL
;
8715 unsigned int freeidx
= 0;
8718 if (elf_dynverref (abfd
) != 0)
8720 Elf_Internal_Shdr
*hdr
;
8721 Elf_External_Verneed
*everneed
;
8722 Elf_Internal_Verneed
*iverneed
;
8724 bfd_byte
*contents_end
;
8726 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8728 if (hdr
->sh_info
== 0
8729 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8731 error_return_bad_verref
:
8733 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8734 bfd_set_error (bfd_error_bad_value
);
8735 error_return_verref
:
8736 elf_tdata (abfd
)->verref
= NULL
;
8737 elf_tdata (abfd
)->cverrefs
= 0;
8741 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8742 goto error_return_verref
;
8743 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8744 if (contents
== NULL
)
8745 goto error_return_verref
;
8747 if (_bfd_mul_overflow (hdr
->sh_info
, sizeof (Elf_Internal_Verneed
), &amt
))
8749 bfd_set_error (bfd_error_file_too_big
);
8750 goto error_return_verref
;
8752 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*) bfd_alloc (abfd
, amt
);
8753 if (elf_tdata (abfd
)->verref
== NULL
)
8754 goto error_return_verref
;
8756 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8757 == sizeof (Elf_External_Vernaux
));
8758 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8759 everneed
= (Elf_External_Verneed
*) contents
;
8760 iverneed
= elf_tdata (abfd
)->verref
;
8761 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8763 Elf_External_Vernaux
*evernaux
;
8764 Elf_Internal_Vernaux
*ivernaux
;
8767 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8769 iverneed
->vn_bfd
= abfd
;
8771 iverneed
->vn_filename
=
8772 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8774 if (iverneed
->vn_filename
== NULL
)
8775 goto error_return_bad_verref
;
8777 if (iverneed
->vn_cnt
== 0)
8778 iverneed
->vn_auxptr
= NULL
;
8781 if (_bfd_mul_overflow (iverneed
->vn_cnt
,
8782 sizeof (Elf_Internal_Vernaux
), &amt
))
8784 bfd_set_error (bfd_error_file_too_big
);
8785 goto error_return_verref
;
8787 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8788 bfd_alloc (abfd
, amt
);
8789 if (iverneed
->vn_auxptr
== NULL
)
8790 goto error_return_verref
;
8793 if (iverneed
->vn_aux
8794 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8795 goto error_return_bad_verref
;
8797 evernaux
= ((Elf_External_Vernaux
*)
8798 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8799 ivernaux
= iverneed
->vn_auxptr
;
8800 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8802 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8804 ivernaux
->vna_nodename
=
8805 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8806 ivernaux
->vna_name
);
8807 if (ivernaux
->vna_nodename
== NULL
)
8808 goto error_return_bad_verref
;
8810 if (ivernaux
->vna_other
> freeidx
)
8811 freeidx
= ivernaux
->vna_other
;
8813 ivernaux
->vna_nextptr
= NULL
;
8814 if (ivernaux
->vna_next
== 0)
8816 iverneed
->vn_cnt
= j
+ 1;
8819 if (j
+ 1 < iverneed
->vn_cnt
)
8820 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8822 if (ivernaux
->vna_next
8823 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8824 goto error_return_bad_verref
;
8826 evernaux
= ((Elf_External_Vernaux
*)
8827 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8830 iverneed
->vn_nextref
= NULL
;
8831 if (iverneed
->vn_next
== 0)
8833 if (i
+ 1 < hdr
->sh_info
)
8834 iverneed
->vn_nextref
= iverneed
+ 1;
8836 if (iverneed
->vn_next
8837 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8838 goto error_return_bad_verref
;
8840 everneed
= ((Elf_External_Verneed
*)
8841 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8843 elf_tdata (abfd
)->cverrefs
= i
;
8849 if (elf_dynverdef (abfd
) != 0)
8851 Elf_Internal_Shdr
*hdr
;
8852 Elf_External_Verdef
*everdef
;
8853 Elf_Internal_Verdef
*iverdef
;
8854 Elf_Internal_Verdef
*iverdefarr
;
8855 Elf_Internal_Verdef iverdefmem
;
8857 unsigned int maxidx
;
8858 bfd_byte
*contents_end_def
, *contents_end_aux
;
8860 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8862 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8864 error_return_bad_verdef
:
8866 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8867 bfd_set_error (bfd_error_bad_value
);
8868 error_return_verdef
:
8869 elf_tdata (abfd
)->verdef
= NULL
;
8870 elf_tdata (abfd
)->cverdefs
= 0;
8874 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8875 goto error_return_verdef
;
8876 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8877 if (contents
== NULL
)
8878 goto error_return_verdef
;
8880 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8881 >= sizeof (Elf_External_Verdaux
));
8882 contents_end_def
= contents
+ hdr
->sh_size
8883 - sizeof (Elf_External_Verdef
);
8884 contents_end_aux
= contents
+ hdr
->sh_size
8885 - sizeof (Elf_External_Verdaux
);
8887 /* We know the number of entries in the section but not the maximum
8888 index. Therefore we have to run through all entries and find
8890 everdef
= (Elf_External_Verdef
*) contents
;
8892 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8894 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8896 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8897 goto error_return_bad_verdef
;
8898 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8899 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8901 if (iverdefmem
.vd_next
== 0)
8904 if (iverdefmem
.vd_next
8905 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8906 goto error_return_bad_verdef
;
8908 everdef
= ((Elf_External_Verdef
*)
8909 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8912 if (default_imported_symver
)
8914 if (freeidx
> maxidx
)
8919 if (_bfd_mul_overflow (maxidx
, sizeof (Elf_Internal_Verdef
), &amt
))
8921 bfd_set_error (bfd_error_file_too_big
);
8922 goto error_return_verdef
;
8924 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
8925 if (elf_tdata (abfd
)->verdef
== NULL
)
8926 goto error_return_verdef
;
8928 elf_tdata (abfd
)->cverdefs
= maxidx
;
8930 everdef
= (Elf_External_Verdef
*) contents
;
8931 iverdefarr
= elf_tdata (abfd
)->verdef
;
8932 for (i
= 0; i
< hdr
->sh_info
; i
++)
8934 Elf_External_Verdaux
*everdaux
;
8935 Elf_Internal_Verdaux
*iverdaux
;
8938 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8940 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8941 goto error_return_bad_verdef
;
8943 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8944 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8946 iverdef
->vd_bfd
= abfd
;
8948 if (iverdef
->vd_cnt
== 0)
8949 iverdef
->vd_auxptr
= NULL
;
8952 if (_bfd_mul_overflow (iverdef
->vd_cnt
,
8953 sizeof (Elf_Internal_Verdaux
), &amt
))
8955 bfd_set_error (bfd_error_file_too_big
);
8956 goto error_return_verdef
;
8958 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8959 bfd_alloc (abfd
, amt
);
8960 if (iverdef
->vd_auxptr
== NULL
)
8961 goto error_return_verdef
;
8965 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8966 goto error_return_bad_verdef
;
8968 everdaux
= ((Elf_External_Verdaux
*)
8969 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8970 iverdaux
= iverdef
->vd_auxptr
;
8971 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8973 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8975 iverdaux
->vda_nodename
=
8976 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8977 iverdaux
->vda_name
);
8978 if (iverdaux
->vda_nodename
== NULL
)
8979 goto error_return_bad_verdef
;
8981 iverdaux
->vda_nextptr
= NULL
;
8982 if (iverdaux
->vda_next
== 0)
8984 iverdef
->vd_cnt
= j
+ 1;
8987 if (j
+ 1 < iverdef
->vd_cnt
)
8988 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8990 if (iverdaux
->vda_next
8991 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8992 goto error_return_bad_verdef
;
8994 everdaux
= ((Elf_External_Verdaux
*)
8995 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8998 iverdef
->vd_nodename
= NULL
;
8999 if (iverdef
->vd_cnt
)
9000 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
9002 iverdef
->vd_nextdef
= NULL
;
9003 if (iverdef
->vd_next
== 0)
9005 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
9006 iverdef
->vd_nextdef
= iverdef
+ 1;
9008 everdef
= ((Elf_External_Verdef
*)
9009 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
9015 else if (default_imported_symver
)
9022 if (_bfd_mul_overflow (freeidx
, sizeof (Elf_Internal_Verdef
), &amt
))
9024 bfd_set_error (bfd_error_file_too_big
);
9027 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
9028 if (elf_tdata (abfd
)->verdef
== NULL
)
9031 elf_tdata (abfd
)->cverdefs
= freeidx
;
9034 /* Create a default version based on the soname. */
9035 if (default_imported_symver
)
9037 Elf_Internal_Verdef
*iverdef
;
9038 Elf_Internal_Verdaux
*iverdaux
;
9040 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
9042 iverdef
->vd_version
= VER_DEF_CURRENT
;
9043 iverdef
->vd_flags
= 0;
9044 iverdef
->vd_ndx
= freeidx
;
9045 iverdef
->vd_cnt
= 1;
9047 iverdef
->vd_bfd
= abfd
;
9049 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
9050 if (iverdef
->vd_nodename
== NULL
)
9051 goto error_return_verdef
;
9052 iverdef
->vd_nextdef
= NULL
;
9053 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
9054 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
9055 if (iverdef
->vd_auxptr
== NULL
)
9056 goto error_return_verdef
;
9058 iverdaux
= iverdef
->vd_auxptr
;
9059 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
9070 _bfd_elf_make_empty_symbol (bfd
*abfd
)
9072 elf_symbol_type
*newsym
;
9074 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
9077 newsym
->symbol
.the_bfd
= abfd
;
9078 return &newsym
->symbol
;
9082 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
9086 bfd_symbol_info (symbol
, ret
);
9089 /* Return whether a symbol name implies a local symbol. Most targets
9090 use this function for the is_local_label_name entry point, but some
9094 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
9097 /* Normal local symbols start with ``.L''. */
9098 if (name
[0] == '.' && name
[1] == 'L')
9101 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
9102 DWARF debugging symbols starting with ``..''. */
9103 if (name
[0] == '.' && name
[1] == '.')
9106 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
9107 emitting DWARF debugging output. I suspect this is actually a
9108 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
9109 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
9110 underscore to be emitted on some ELF targets). For ease of use,
9111 we treat such symbols as local. */
9112 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
9115 /* Treat assembler generated fake symbols, dollar local labels and
9116 forward-backward labels (aka local labels) as locals.
9117 These labels have the form:
9119 L0^A.* (fake symbols)
9121 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
9123 Versions which start with .L will have already been matched above,
9124 so we only need to match the rest. */
9125 if (name
[0] == 'L' && ISDIGIT (name
[1]))
9131 for (p
= name
+ 2; (c
= *p
); p
++)
9133 if (c
== 1 || c
== 2)
9135 if (c
== 1 && p
== name
+ 2)
9136 /* A fake symbol. */
9139 /* FIXME: We are being paranoid here and treating symbols like
9140 L0^Bfoo as if there were non-local, on the grounds that the
9141 assembler will never generate them. But can any symbol
9142 containing an ASCII value in the range 1-31 ever be anything
9143 other than some kind of local ? */
9160 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9161 asymbol
*symbol ATTRIBUTE_UNUSED
)
9168 _bfd_elf_set_arch_mach (bfd
*abfd
,
9169 enum bfd_architecture arch
,
9170 unsigned long machine
)
9172 /* If this isn't the right architecture for this backend, and this
9173 isn't the generic backend, fail. */
9174 if (arch
!= get_elf_backend_data (abfd
)->arch
9175 && arch
!= bfd_arch_unknown
9176 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9179 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9182 /* Find the nearest line to a particular section and offset,
9183 for error reporting. */
9186 _bfd_elf_find_nearest_line (bfd
*abfd
,
9190 const char **filename_ptr
,
9191 const char **functionname_ptr
,
9192 unsigned int *line_ptr
,
9193 unsigned int *discriminator_ptr
)
9197 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9198 filename_ptr
, functionname_ptr
,
9199 line_ptr
, discriminator_ptr
,
9200 dwarf_debug_sections
,
9201 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9204 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9205 filename_ptr
, functionname_ptr
, line_ptr
))
9207 if (!*functionname_ptr
)
9208 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9209 *filename_ptr
? NULL
: filename_ptr
,
9214 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9215 &found
, filename_ptr
,
9216 functionname_ptr
, line_ptr
,
9217 &elf_tdata (abfd
)->line_info
))
9219 if (found
&& (*functionname_ptr
|| *line_ptr
))
9222 if (symbols
== NULL
)
9225 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9226 filename_ptr
, functionname_ptr
))
9233 /* Find the line for a symbol. */
9236 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9237 const char **filename_ptr
, unsigned int *line_ptr
)
9239 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9240 filename_ptr
, NULL
, line_ptr
, NULL
,
9241 dwarf_debug_sections
,
9242 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9245 /* After a call to bfd_find_nearest_line, successive calls to
9246 bfd_find_inliner_info can be used to get source information about
9247 each level of function inlining that terminated at the address
9248 passed to bfd_find_nearest_line. Currently this is only supported
9249 for DWARF2 with appropriate DWARF3 extensions. */
9252 _bfd_elf_find_inliner_info (bfd
*abfd
,
9253 const char **filename_ptr
,
9254 const char **functionname_ptr
,
9255 unsigned int *line_ptr
)
9258 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9259 functionname_ptr
, line_ptr
,
9260 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9265 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9267 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9268 int ret
= bed
->s
->sizeof_ehdr
;
9270 if (!bfd_link_relocatable (info
))
9272 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9274 if (phdr_size
== (bfd_size_type
) -1)
9276 struct elf_segment_map
*m
;
9279 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9280 phdr_size
+= bed
->s
->sizeof_phdr
;
9283 phdr_size
= get_program_header_size (abfd
, info
);
9286 elf_program_header_size (abfd
) = phdr_size
;
9294 _bfd_elf_set_section_contents (bfd
*abfd
,
9296 const void *location
,
9298 bfd_size_type count
)
9300 Elf_Internal_Shdr
*hdr
;
9303 if (! abfd
->output_has_begun
9304 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9310 hdr
= &elf_section_data (section
)->this_hdr
;
9311 if (hdr
->sh_offset
== (file_ptr
) -1)
9313 unsigned char *contents
;
9315 if (bfd_section_is_ctf (section
))
9316 /* Nothing to do with this section: the contents are generated
9320 if ((section
->flags
& SEC_ELF_COMPRESS
) == 0)
9323 (_("%pB:%pA: error: attempting to write into an unallocated compressed section"),
9325 bfd_set_error (bfd_error_invalid_operation
);
9329 if ((offset
+ count
) > hdr
->sh_size
)
9332 (_("%pB:%pA: error: attempting to write over the end of the section"),
9335 bfd_set_error (bfd_error_invalid_operation
);
9339 contents
= hdr
->contents
;
9340 if (contents
== NULL
)
9343 (_("%pB:%pA: error: attempting to write section into an empty buffer"),
9346 bfd_set_error (bfd_error_invalid_operation
);
9350 memcpy (contents
+ offset
, location
, count
);
9354 pos
= hdr
->sh_offset
+ offset
;
9355 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9356 || bfd_bwrite (location
, count
, abfd
) != count
)
9363 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9364 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9365 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9371 /* Try to convert a non-ELF reloc into an ELF one. */
9374 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9376 /* Check whether we really have an ELF howto. */
9378 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9380 bfd_reloc_code_real_type code
;
9381 reloc_howto_type
*howto
;
9383 /* Alien reloc: Try to determine its type to replace it with an
9384 equivalent ELF reloc. */
9386 if (areloc
->howto
->pc_relative
)
9388 switch (areloc
->howto
->bitsize
)
9391 code
= BFD_RELOC_8_PCREL
;
9394 code
= BFD_RELOC_12_PCREL
;
9397 code
= BFD_RELOC_16_PCREL
;
9400 code
= BFD_RELOC_24_PCREL
;
9403 code
= BFD_RELOC_32_PCREL
;
9406 code
= BFD_RELOC_64_PCREL
;
9412 howto
= bfd_reloc_type_lookup (abfd
, code
);
9414 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9416 if (howto
->pcrel_offset
)
9417 areloc
->addend
+= areloc
->address
;
9419 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9424 switch (areloc
->howto
->bitsize
)
9430 code
= BFD_RELOC_14
;
9433 code
= BFD_RELOC_16
;
9436 code
= BFD_RELOC_26
;
9439 code
= BFD_RELOC_32
;
9442 code
= BFD_RELOC_64
;
9448 howto
= bfd_reloc_type_lookup (abfd
, code
);
9452 areloc
->howto
= howto
;
9460 /* xgettext:c-format */
9461 _bfd_error_handler (_("%pB: %s unsupported"),
9462 abfd
, areloc
->howto
->name
);
9463 bfd_set_error (bfd_error_sorry
);
9468 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9470 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9472 && (bfd_get_format (abfd
) == bfd_object
9473 || bfd_get_format (abfd
) == bfd_core
))
9475 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9476 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9477 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9480 return _bfd_generic_close_and_cleanup (abfd
);
9483 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9484 in the relocation's offset. Thus we cannot allow any sort of sanity
9485 range-checking to interfere. There is nothing else to do in processing
9488 bfd_reloc_status_type
9489 _bfd_elf_rel_vtable_reloc_fn
9490 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9491 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9492 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9493 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9495 return bfd_reloc_ok
;
9498 /* Elf core file support. Much of this only works on native
9499 toolchains, since we rely on knowing the
9500 machine-dependent procfs structure in order to pick
9501 out details about the corefile. */
9503 #ifdef HAVE_SYS_PROCFS_H
9504 # include <sys/procfs.h>
9507 /* Return a PID that identifies a "thread" for threaded cores, or the
9508 PID of the main process for non-threaded cores. */
9511 elfcore_make_pid (bfd
*abfd
)
9515 pid
= elf_tdata (abfd
)->core
->lwpid
;
9517 pid
= elf_tdata (abfd
)->core
->pid
;
9522 /* If there isn't a section called NAME, make one, using
9523 data from SECT. Note, this function will generate a
9524 reference to NAME, so you shouldn't deallocate or
9528 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9532 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9535 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9539 sect2
->size
= sect
->size
;
9540 sect2
->filepos
= sect
->filepos
;
9541 sect2
->alignment_power
= sect
->alignment_power
;
9545 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9546 actually creates up to two pseudosections:
9547 - For the single-threaded case, a section named NAME, unless
9548 such a section already exists.
9549 - For the multi-threaded case, a section named "NAME/PID", where
9550 PID is elfcore_make_pid (abfd).
9551 Both pseudosections have identical contents. */
9553 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9559 char *threaded_name
;
9563 /* Build the section name. */
9565 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9566 len
= strlen (buf
) + 1;
9567 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9568 if (threaded_name
== NULL
)
9570 memcpy (threaded_name
, buf
, len
);
9572 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9577 sect
->filepos
= filepos
;
9578 sect
->alignment_power
= 2;
9580 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9584 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9587 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9593 sect
->size
= note
->descsz
- offs
;
9594 sect
->filepos
= note
->descpos
+ offs
;
9595 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9601 elfcore_make_memtag_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9604 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".memtag",
9610 sect
->size
= note
->descsz
- offs
;
9611 sect
->filepos
= note
->descpos
+ offs
;
9612 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9617 /* prstatus_t exists on:
9619 linux 2.[01] + glibc
9623 #if defined (HAVE_PRSTATUS_T)
9626 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9631 if (note
->descsz
== sizeof (prstatus_t
))
9635 size
= sizeof (prstat
.pr_reg
);
9636 offset
= offsetof (prstatus_t
, pr_reg
);
9637 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9639 /* Do not overwrite the core signal if it
9640 has already been set by another thread. */
9641 if (elf_tdata (abfd
)->core
->signal
== 0)
9642 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9643 if (elf_tdata (abfd
)->core
->pid
== 0)
9644 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9646 /* pr_who exists on:
9649 pr_who doesn't exist on:
9652 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9653 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9655 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9658 #if defined (HAVE_PRSTATUS32_T)
9659 else if (note
->descsz
== sizeof (prstatus32_t
))
9661 /* 64-bit host, 32-bit corefile */
9662 prstatus32_t prstat
;
9664 size
= sizeof (prstat
.pr_reg
);
9665 offset
= offsetof (prstatus32_t
, pr_reg
);
9666 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9668 /* Do not overwrite the core signal if it
9669 has already been set by another thread. */
9670 if (elf_tdata (abfd
)->core
->signal
== 0)
9671 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9672 if (elf_tdata (abfd
)->core
->pid
== 0)
9673 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9675 /* pr_who exists on:
9678 pr_who doesn't exist on:
9681 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9682 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9684 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9687 #endif /* HAVE_PRSTATUS32_T */
9690 /* Fail - we don't know how to handle any other
9691 note size (ie. data object type). */
9695 /* Make a ".reg/999" section and a ".reg" section. */
9696 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9697 size
, note
->descpos
+ offset
);
9699 #endif /* defined (HAVE_PRSTATUS_T) */
9701 /* Create a pseudosection containing the exact contents of NOTE. */
9703 elfcore_make_note_pseudosection (bfd
*abfd
,
9705 Elf_Internal_Note
*note
)
9707 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9708 note
->descsz
, note
->descpos
);
9711 /* There isn't a consistent prfpregset_t across platforms,
9712 but it doesn't matter, because we don't have to pick this
9713 data structure apart. */
9716 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9718 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9721 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9722 type of NT_PRXFPREG. Just include the whole note's contents
9726 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9728 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9731 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9732 with a note type of NT_X86_XSTATE. Just include the whole note's
9733 contents literally. */
9736 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9738 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9742 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9744 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9748 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9750 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9754 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9756 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9760 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9762 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9766 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9768 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9772 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9774 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9778 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9780 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9784 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9786 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9790 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9792 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9796 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9798 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9802 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9804 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9808 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9810 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9814 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9816 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9820 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9822 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9826 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9828 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9832 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9834 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9838 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9840 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9844 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9846 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9850 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9852 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9856 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9858 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9862 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9864 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9868 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9870 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9874 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9876 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9880 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9882 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9886 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9888 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9892 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9894 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9898 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9900 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9904 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9906 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9910 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9912 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9916 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9918 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9922 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9924 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9928 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9930 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9934 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9936 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9940 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9942 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9946 elfcore_grok_aarch_mte (bfd
*abfd
, Elf_Internal_Note
*note
)
9948 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-mte",
9953 elfcore_grok_arc_v2 (bfd
*abfd
, Elf_Internal_Note
*note
)
9955 return elfcore_make_note_pseudosection (abfd
, ".reg-arc-v2", note
);
9958 /* Convert NOTE into a bfd_section called ".reg-riscv-csr". Return TRUE if
9959 successful otherwise, return FALSE. */
9962 elfcore_grok_riscv_csr (bfd
*abfd
, Elf_Internal_Note
*note
)
9964 return elfcore_make_note_pseudosection (abfd
, ".reg-riscv-csr", note
);
9967 /* Convert NOTE into a bfd_section called ".gdb-tdesc". Return TRUE if
9968 successful otherwise, return FALSE. */
9971 elfcore_grok_gdb_tdesc (bfd
*abfd
, Elf_Internal_Note
*note
)
9973 return elfcore_make_note_pseudosection (abfd
, ".gdb-tdesc", note
);
9976 #if defined (HAVE_PRPSINFO_T)
9977 typedef prpsinfo_t elfcore_psinfo_t
;
9978 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9979 typedef prpsinfo32_t elfcore_psinfo32_t
;
9983 #if defined (HAVE_PSINFO_T)
9984 typedef psinfo_t elfcore_psinfo_t
;
9985 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9986 typedef psinfo32_t elfcore_psinfo32_t
;
9990 /* return a malloc'ed copy of a string at START which is at
9991 most MAX bytes long, possibly without a terminating '\0'.
9992 the copy will always have a terminating '\0'. */
9995 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9998 char *end
= (char *) memchr (start
, '\0', max
);
10006 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
10010 memcpy (dups
, start
, len
);
10016 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10018 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10020 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
10022 elfcore_psinfo_t psinfo
;
10024 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10026 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
10027 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10029 elf_tdata (abfd
)->core
->program
10030 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10031 sizeof (psinfo
.pr_fname
));
10033 elf_tdata (abfd
)->core
->command
10034 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10035 sizeof (psinfo
.pr_psargs
));
10037 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10038 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
10040 /* 64-bit host, 32-bit corefile */
10041 elfcore_psinfo32_t psinfo
;
10043 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10045 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
10046 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10048 elf_tdata (abfd
)->core
->program
10049 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10050 sizeof (psinfo
.pr_fname
));
10052 elf_tdata (abfd
)->core
->command
10053 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10054 sizeof (psinfo
.pr_psargs
));
10060 /* Fail - we don't know how to handle any other
10061 note size (ie. data object type). */
10065 /* Note that for some reason, a spurious space is tacked
10066 onto the end of the args in some (at least one anyway)
10067 implementations, so strip it off if it exists. */
10070 char *command
= elf_tdata (abfd
)->core
->command
;
10071 int n
= strlen (command
);
10073 if (0 < n
&& command
[n
- 1] == ' ')
10074 command
[n
- 1] = '\0';
10079 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
10081 #if defined (HAVE_PSTATUS_T)
10083 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10085 if (note
->descsz
== sizeof (pstatus_t
)
10086 #if defined (HAVE_PXSTATUS_T)
10087 || note
->descsz
== sizeof (pxstatus_t
)
10093 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10095 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10097 #if defined (HAVE_PSTATUS32_T)
10098 else if (note
->descsz
== sizeof (pstatus32_t
))
10100 /* 64-bit host, 32-bit corefile */
10103 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10105 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10108 /* Could grab some more details from the "representative"
10109 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
10110 NT_LWPSTATUS note, presumably. */
10114 #endif /* defined (HAVE_PSTATUS_T) */
10116 #if defined (HAVE_LWPSTATUS_T)
10118 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10120 lwpstatus_t lwpstat
;
10126 if (note
->descsz
!= sizeof (lwpstat
)
10127 #if defined (HAVE_LWPXSTATUS_T)
10128 && note
->descsz
!= sizeof (lwpxstatus_t
)
10133 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
10135 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
10136 /* Do not overwrite the core signal if it has already been set by
10138 if (elf_tdata (abfd
)->core
->signal
== 0)
10139 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
10141 /* Make a ".reg/999" section. */
10143 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
10144 len
= strlen (buf
) + 1;
10145 name
= bfd_alloc (abfd
, len
);
10148 memcpy (name
, buf
, len
);
10150 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10154 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10155 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
10156 sect
->filepos
= note
->descpos
10157 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
10160 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10161 sect
->size
= sizeof (lwpstat
.pr_reg
);
10162 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
10165 sect
->alignment_power
= 2;
10167 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10170 /* Make a ".reg2/999" section */
10172 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
10173 len
= strlen (buf
) + 1;
10174 name
= bfd_alloc (abfd
, len
);
10177 memcpy (name
, buf
, len
);
10179 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10183 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10184 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
10185 sect
->filepos
= note
->descpos
10186 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
10189 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
10190 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
10191 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
10194 sect
->alignment_power
= 2;
10196 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
10198 #endif /* defined (HAVE_LWPSTATUS_T) */
10200 /* These constants, and the structure offsets used below, are defined by
10201 Cygwin's core_dump.h */
10202 #define NOTE_INFO_PROCESS 1
10203 #define NOTE_INFO_THREAD 2
10204 #define NOTE_INFO_MODULE 3
10205 #define NOTE_INFO_MODULE64 4
10208 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10213 unsigned int name_size
;
10216 int is_active_thread
;
10219 if (note
->descsz
< 4)
10222 if (! startswith (note
->namedata
, "win32"))
10225 type
= bfd_get_32 (abfd
, note
->descdata
);
10229 const char *type_name
;
10230 unsigned long min_size
;
10233 { "NOTE_INFO_PROCESS", 12 },
10234 { "NOTE_INFO_THREAD", 12 },
10235 { "NOTE_INFO_MODULE", 12 },
10236 { "NOTE_INFO_MODULE64", 16 },
10239 if (type
== 0 || type
> (sizeof(size_check
)/sizeof(size_check
[0])))
10242 if (note
->descsz
< size_check
[type
- 1].min_size
)
10244 _bfd_error_handler (_("%pB: warning: win32pstatus %s of size %lu bytes is too small"),
10245 abfd
, size_check
[type
- 1].type_name
, note
->descsz
);
10251 case NOTE_INFO_PROCESS
:
10252 /* FIXME: need to add ->core->command. */
10253 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10254 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10257 case NOTE_INFO_THREAD
:
10258 /* Make a ".reg/<tid>" section containing the Win32 API thread CONTEXT
10260 /* thread_info.tid */
10261 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 4));
10263 len
= strlen (buf
) + 1;
10264 name
= (char *) bfd_alloc (abfd
, len
);
10268 memcpy (name
, buf
, len
);
10270 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10274 /* sizeof (thread_info.thread_context) */
10275 sect
->size
= note
->descsz
- 12;
10276 /* offsetof (thread_info.thread_context) */
10277 sect
->filepos
= note
->descpos
+ 12;
10278 sect
->alignment_power
= 2;
10280 /* thread_info.is_active_thread */
10281 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10283 if (is_active_thread
)
10284 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10288 case NOTE_INFO_MODULE
:
10289 case NOTE_INFO_MODULE64
:
10290 /* Make a ".module/xxxxxxxx" section. */
10291 if (type
== NOTE_INFO_MODULE
)
10293 /* module_info.base_address */
10294 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10295 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10296 /* module_info.module_name_size */
10297 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10299 else /* NOTE_INFO_MODULE64 */
10301 /* module_info.base_address */
10302 base_addr
= bfd_get_64 (abfd
, note
->descdata
+ 4);
10303 sprintf (buf
, ".module/%016lx", (unsigned long) base_addr
);
10304 /* module_info.module_name_size */
10305 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10308 len
= strlen (buf
) + 1;
10309 name
= (char *) bfd_alloc (abfd
, len
);
10313 memcpy (name
, buf
, len
);
10315 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10320 if (note
->descsz
< 12 + name_size
)
10322 _bfd_error_handler (_("%pB: win32pstatus NOTE_INFO_MODULE of size %lu is too small to contain a name of size %u"),
10323 abfd
, note
->descsz
, name_size
);
10327 sect
->size
= note
->descsz
;
10328 sect
->filepos
= note
->descpos
;
10329 sect
->alignment_power
= 2;
10340 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10342 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10344 switch (note
->type
)
10350 if (bed
->elf_backend_grok_prstatus
)
10351 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10353 #if defined (HAVE_PRSTATUS_T)
10354 return elfcore_grok_prstatus (abfd
, note
);
10359 #if defined (HAVE_PSTATUS_T)
10361 return elfcore_grok_pstatus (abfd
, note
);
10364 #if defined (HAVE_LWPSTATUS_T)
10366 return elfcore_grok_lwpstatus (abfd
, note
);
10369 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10370 return elfcore_grok_prfpreg (abfd
, note
);
10372 case NT_WIN32PSTATUS
:
10373 return elfcore_grok_win32pstatus (abfd
, note
);
10375 case NT_PRXFPREG
: /* Linux SSE extension */
10376 if (note
->namesz
== 6
10377 && strcmp (note
->namedata
, "LINUX") == 0)
10378 return elfcore_grok_prxfpreg (abfd
, note
);
10382 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10383 if (note
->namesz
== 6
10384 && strcmp (note
->namedata
, "LINUX") == 0)
10385 return elfcore_grok_xstatereg (abfd
, note
);
10390 if (note
->namesz
== 6
10391 && strcmp (note
->namedata
, "LINUX") == 0)
10392 return elfcore_grok_ppc_vmx (abfd
, note
);
10397 if (note
->namesz
== 6
10398 && strcmp (note
->namedata
, "LINUX") == 0)
10399 return elfcore_grok_ppc_vsx (abfd
, note
);
10404 if (note
->namesz
== 6
10405 && strcmp (note
->namedata
, "LINUX") == 0)
10406 return elfcore_grok_ppc_tar (abfd
, note
);
10411 if (note
->namesz
== 6
10412 && strcmp (note
->namedata
, "LINUX") == 0)
10413 return elfcore_grok_ppc_ppr (abfd
, note
);
10418 if (note
->namesz
== 6
10419 && strcmp (note
->namedata
, "LINUX") == 0)
10420 return elfcore_grok_ppc_dscr (abfd
, note
);
10425 if (note
->namesz
== 6
10426 && strcmp (note
->namedata
, "LINUX") == 0)
10427 return elfcore_grok_ppc_ebb (abfd
, note
);
10432 if (note
->namesz
== 6
10433 && strcmp (note
->namedata
, "LINUX") == 0)
10434 return elfcore_grok_ppc_pmu (abfd
, note
);
10438 case NT_PPC_TM_CGPR
:
10439 if (note
->namesz
== 6
10440 && strcmp (note
->namedata
, "LINUX") == 0)
10441 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10445 case NT_PPC_TM_CFPR
:
10446 if (note
->namesz
== 6
10447 && strcmp (note
->namedata
, "LINUX") == 0)
10448 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10452 case NT_PPC_TM_CVMX
:
10453 if (note
->namesz
== 6
10454 && strcmp (note
->namedata
, "LINUX") == 0)
10455 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10459 case NT_PPC_TM_CVSX
:
10460 if (note
->namesz
== 6
10461 && strcmp (note
->namedata
, "LINUX") == 0)
10462 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10466 case NT_PPC_TM_SPR
:
10467 if (note
->namesz
== 6
10468 && strcmp (note
->namedata
, "LINUX") == 0)
10469 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10473 case NT_PPC_TM_CTAR
:
10474 if (note
->namesz
== 6
10475 && strcmp (note
->namedata
, "LINUX") == 0)
10476 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10480 case NT_PPC_TM_CPPR
:
10481 if (note
->namesz
== 6
10482 && strcmp (note
->namedata
, "LINUX") == 0)
10483 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10487 case NT_PPC_TM_CDSCR
:
10488 if (note
->namesz
== 6
10489 && strcmp (note
->namedata
, "LINUX") == 0)
10490 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10494 case NT_S390_HIGH_GPRS
:
10495 if (note
->namesz
== 6
10496 && strcmp (note
->namedata
, "LINUX") == 0)
10497 return elfcore_grok_s390_high_gprs (abfd
, note
);
10501 case NT_S390_TIMER
:
10502 if (note
->namesz
== 6
10503 && strcmp (note
->namedata
, "LINUX") == 0)
10504 return elfcore_grok_s390_timer (abfd
, note
);
10508 case NT_S390_TODCMP
:
10509 if (note
->namesz
== 6
10510 && strcmp (note
->namedata
, "LINUX") == 0)
10511 return elfcore_grok_s390_todcmp (abfd
, note
);
10515 case NT_S390_TODPREG
:
10516 if (note
->namesz
== 6
10517 && strcmp (note
->namedata
, "LINUX") == 0)
10518 return elfcore_grok_s390_todpreg (abfd
, note
);
10523 if (note
->namesz
== 6
10524 && strcmp (note
->namedata
, "LINUX") == 0)
10525 return elfcore_grok_s390_ctrs (abfd
, note
);
10529 case NT_S390_PREFIX
:
10530 if (note
->namesz
== 6
10531 && strcmp (note
->namedata
, "LINUX") == 0)
10532 return elfcore_grok_s390_prefix (abfd
, note
);
10536 case NT_S390_LAST_BREAK
:
10537 if (note
->namesz
== 6
10538 && strcmp (note
->namedata
, "LINUX") == 0)
10539 return elfcore_grok_s390_last_break (abfd
, note
);
10543 case NT_S390_SYSTEM_CALL
:
10544 if (note
->namesz
== 6
10545 && strcmp (note
->namedata
, "LINUX") == 0)
10546 return elfcore_grok_s390_system_call (abfd
, note
);
10551 if (note
->namesz
== 6
10552 && strcmp (note
->namedata
, "LINUX") == 0)
10553 return elfcore_grok_s390_tdb (abfd
, note
);
10557 case NT_S390_VXRS_LOW
:
10558 if (note
->namesz
== 6
10559 && strcmp (note
->namedata
, "LINUX") == 0)
10560 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10564 case NT_S390_VXRS_HIGH
:
10565 if (note
->namesz
== 6
10566 && strcmp (note
->namedata
, "LINUX") == 0)
10567 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10571 case NT_S390_GS_CB
:
10572 if (note
->namesz
== 6
10573 && strcmp (note
->namedata
, "LINUX") == 0)
10574 return elfcore_grok_s390_gs_cb (abfd
, note
);
10578 case NT_S390_GS_BC
:
10579 if (note
->namesz
== 6
10580 && strcmp (note
->namedata
, "LINUX") == 0)
10581 return elfcore_grok_s390_gs_bc (abfd
, note
);
10586 if (note
->namesz
== 6
10587 && strcmp (note
->namedata
, "LINUX") == 0)
10588 return elfcore_grok_arc_v2 (abfd
, note
);
10593 if (note
->namesz
== 6
10594 && strcmp (note
->namedata
, "LINUX") == 0)
10595 return elfcore_grok_arm_vfp (abfd
, note
);
10600 if (note
->namesz
== 6
10601 && strcmp (note
->namedata
, "LINUX") == 0)
10602 return elfcore_grok_aarch_tls (abfd
, note
);
10606 case NT_ARM_HW_BREAK
:
10607 if (note
->namesz
== 6
10608 && strcmp (note
->namedata
, "LINUX") == 0)
10609 return elfcore_grok_aarch_hw_break (abfd
, note
);
10613 case NT_ARM_HW_WATCH
:
10614 if (note
->namesz
== 6
10615 && strcmp (note
->namedata
, "LINUX") == 0)
10616 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10621 if (note
->namesz
== 6
10622 && strcmp (note
->namedata
, "LINUX") == 0)
10623 return elfcore_grok_aarch_sve (abfd
, note
);
10627 case NT_ARM_PAC_MASK
:
10628 if (note
->namesz
== 6
10629 && strcmp (note
->namedata
, "LINUX") == 0)
10630 return elfcore_grok_aarch_pauth (abfd
, note
);
10634 case NT_ARM_TAGGED_ADDR_CTRL
:
10635 if (note
->namesz
== 6
10636 && strcmp (note
->namedata
, "LINUX") == 0)
10637 return elfcore_grok_aarch_mte (abfd
, note
);
10642 if (note
->namesz
== 4
10643 && strcmp (note
->namedata
, "GDB") == 0)
10644 return elfcore_grok_gdb_tdesc (abfd
, note
);
10649 if (note
->namesz
== 4
10650 && strcmp (note
->namedata
, "GDB") == 0)
10651 return elfcore_grok_riscv_csr (abfd
, note
);
10657 if (bed
->elf_backend_grok_psinfo
)
10658 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10660 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10661 return elfcore_grok_psinfo (abfd
, note
);
10667 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10670 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10674 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10678 return elfcore_make_memtag_note_section (abfd
, note
, 0);
10683 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10685 struct bfd_build_id
* build_id
;
10687 if (note
->descsz
== 0)
10690 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10691 if (build_id
== NULL
)
10694 build_id
->size
= note
->descsz
;
10695 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10696 abfd
->build_id
= build_id
;
10702 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10704 switch (note
->type
)
10709 case NT_GNU_PROPERTY_TYPE_0
:
10710 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10712 case NT_GNU_BUILD_ID
:
10713 return elfobj_grok_gnu_build_id (abfd
, note
);
10718 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10720 struct sdt_note
*cur
=
10721 (struct sdt_note
*) bfd_alloc (abfd
,
10722 sizeof (struct sdt_note
) + note
->descsz
);
10724 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10725 cur
->size
= (bfd_size_type
) note
->descsz
;
10726 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10728 elf_tdata (abfd
)->sdt_note_head
= cur
;
10734 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10736 switch (note
->type
)
10739 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10747 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10751 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10754 if (note
->descsz
< 108)
10759 if (note
->descsz
< 120)
10767 /* Check for version 1 in pr_version. */
10768 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10773 /* Skip over pr_psinfosz. */
10774 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10778 offset
+= 4; /* Padding before pr_psinfosz. */
10782 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10783 elf_tdata (abfd
)->core
->program
10784 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10787 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10788 elf_tdata (abfd
)->core
->command
10789 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10792 /* Padding before pr_pid. */
10795 /* The pr_pid field was added in version "1a". */
10796 if (note
->descsz
< offset
+ 4)
10799 elf_tdata (abfd
)->core
->pid
10800 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10806 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10812 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10813 Also compute minimum size of this note. */
10814 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10818 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10822 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10823 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10830 if (note
->descsz
< min_size
)
10833 /* Check for version 1 in pr_version. */
10834 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10837 /* Extract size of pr_reg from pr_gregsetsz. */
10838 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10839 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10841 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10846 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10850 /* Skip over pr_osreldate. */
10853 /* Read signal from pr_cursig. */
10854 if (elf_tdata (abfd
)->core
->signal
== 0)
10855 elf_tdata (abfd
)->core
->signal
10856 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10859 /* Read TID from pr_pid. */
10860 elf_tdata (abfd
)->core
->lwpid
10861 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10864 /* Padding before pr_reg. */
10865 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10868 /* Make sure that there is enough data remaining in the note. */
10869 if ((note
->descsz
- offset
) < size
)
10872 /* Make a ".reg/999" section and a ".reg" section. */
10873 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10874 size
, note
->descpos
+ offset
);
10878 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10880 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10882 switch (note
->type
)
10885 if (bed
->elf_backend_grok_freebsd_prstatus
)
10886 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10888 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10891 return elfcore_grok_prfpreg (abfd
, note
);
10894 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10896 case NT_FREEBSD_THRMISC
:
10897 if (note
->namesz
== 8)
10898 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10902 case NT_FREEBSD_PROCSTAT_PROC
:
10903 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10906 case NT_FREEBSD_PROCSTAT_FILES
:
10907 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10910 case NT_FREEBSD_PROCSTAT_VMMAP
:
10911 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10914 case NT_FREEBSD_PROCSTAT_AUXV
:
10915 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10917 case NT_X86_XSTATE
:
10918 if (note
->namesz
== 8)
10919 return elfcore_grok_xstatereg (abfd
, note
);
10923 case NT_FREEBSD_PTLWPINFO
:
10924 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10928 return elfcore_grok_arm_vfp (abfd
, note
);
10936 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10940 cp
= strchr (note
->namedata
, '@');
10943 *lwpidp
= atoi(cp
+ 1);
10950 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10952 if (note
->descsz
<= 0x7c + 31)
10955 /* Signal number at offset 0x08. */
10956 elf_tdata (abfd
)->core
->signal
10957 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10959 /* Process ID at offset 0x50. */
10960 elf_tdata (abfd
)->core
->pid
10961 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10963 /* Command name at 0x7c (max 32 bytes, including nul). */
10964 elf_tdata (abfd
)->core
->command
10965 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10967 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10972 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10976 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10977 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10979 switch (note
->type
)
10981 case NT_NETBSDCORE_PROCINFO
:
10982 /* NetBSD-specific core "procinfo". Note that we expect to
10983 find this note before any of the others, which is fine,
10984 since the kernel writes this note out first when it
10985 creates a core file. */
10986 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10987 case NT_NETBSDCORE_AUXV
:
10988 /* NetBSD-specific Elf Auxiliary Vector data. */
10989 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10990 case NT_NETBSDCORE_LWPSTATUS
:
10991 return elfcore_make_note_pseudosection (abfd
,
10992 ".note.netbsdcore.lwpstatus",
10998 /* As of March 2020 there are no other machine-independent notes
10999 defined for NetBSD core files. If the note type is less
11000 than the start of the machine-dependent note types, we don't
11003 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
11007 switch (bfd_get_arch (abfd
))
11009 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
11010 PT_GETFPREGS == mach+2. */
11012 case bfd_arch_aarch64
:
11013 case bfd_arch_alpha
:
11014 case bfd_arch_sparc
:
11015 switch (note
->type
)
11017 case NT_NETBSDCORE_FIRSTMACH
+0:
11018 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11020 case NT_NETBSDCORE_FIRSTMACH
+2:
11021 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11027 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
11028 There's also old PT___GETREGS40 == mach + 1 for old reg
11029 structure which lacks GBR. */
11032 switch (note
->type
)
11034 case NT_NETBSDCORE_FIRSTMACH
+3:
11035 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11037 case NT_NETBSDCORE_FIRSTMACH
+5:
11038 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11044 /* On all other arch's, PT_GETREGS == mach+1 and
11045 PT_GETFPREGS == mach+3. */
11048 switch (note
->type
)
11050 case NT_NETBSDCORE_FIRSTMACH
+1:
11051 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11053 case NT_NETBSDCORE_FIRSTMACH
+3:
11054 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11064 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
11066 if (note
->descsz
<= 0x48 + 31)
11069 /* Signal number at offset 0x08. */
11070 elf_tdata (abfd
)->core
->signal
11071 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
11073 /* Process ID at offset 0x20. */
11074 elf_tdata (abfd
)->core
->pid
11075 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
11077 /* Command name at 0x48 (max 32 bytes, including nul). */
11078 elf_tdata (abfd
)->core
->command
11079 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
11085 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11087 if (note
->type
== NT_OPENBSD_PROCINFO
)
11088 return elfcore_grok_openbsd_procinfo (abfd
, note
);
11090 if (note
->type
== NT_OPENBSD_REGS
)
11091 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11093 if (note
->type
== NT_OPENBSD_FPREGS
)
11094 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11096 if (note
->type
== NT_OPENBSD_XFPREGS
)
11097 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
11099 if (note
->type
== NT_OPENBSD_AUXV
)
11100 return elfcore_make_auxv_note_section (abfd
, note
, 0);
11102 if (note
->type
== NT_OPENBSD_WCOOKIE
)
11104 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
11109 sect
->size
= note
->descsz
;
11110 sect
->filepos
= note
->descpos
;
11111 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
11120 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
11122 void *ddata
= note
->descdata
;
11129 if (note
->descsz
< 16)
11132 /* nto_procfs_status 'pid' field is at offset 0. */
11133 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
11135 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
11136 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
11138 /* nto_procfs_status 'flags' field is at offset 8. */
11139 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
11141 /* nto_procfs_status 'what' field is at offset 14. */
11142 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
11144 elf_tdata (abfd
)->core
->signal
= sig
;
11145 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11148 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
11149 do not come from signals so we make sure we set the current
11150 thread just in case. */
11151 if (flags
& 0x00000080)
11152 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11154 /* Make a ".qnx_core_status/%d" section. */
11155 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
11157 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11160 strcpy (name
, buf
);
11162 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11166 sect
->size
= note
->descsz
;
11167 sect
->filepos
= note
->descpos
;
11168 sect
->alignment_power
= 2;
11170 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
11174 elfcore_grok_nto_regs (bfd
*abfd
,
11175 Elf_Internal_Note
*note
,
11183 /* Make a "(base)/%d" section. */
11184 sprintf (buf
, "%s/%ld", base
, tid
);
11186 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11189 strcpy (name
, buf
);
11191 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11195 sect
->size
= note
->descsz
;
11196 sect
->filepos
= note
->descpos
;
11197 sect
->alignment_power
= 2;
11199 /* This is the current thread. */
11200 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
11201 return elfcore_maybe_make_sect (abfd
, base
, sect
);
11206 #define BFD_QNT_CORE_INFO 7
11207 #define BFD_QNT_CORE_STATUS 8
11208 #define BFD_QNT_CORE_GREG 9
11209 #define BFD_QNT_CORE_FPREG 10
11212 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11214 /* Every GREG section has a STATUS section before it. Store the
11215 tid from the previous call to pass down to the next gregs
11217 static long tid
= 1;
11219 switch (note
->type
)
11221 case BFD_QNT_CORE_INFO
:
11222 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
11223 case BFD_QNT_CORE_STATUS
:
11224 return elfcore_grok_nto_status (abfd
, note
, &tid
);
11225 case BFD_QNT_CORE_GREG
:
11226 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
11227 case BFD_QNT_CORE_FPREG
:
11228 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
11235 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11241 /* Use note name as section name. */
11242 len
= note
->namesz
;
11243 name
= (char *) bfd_alloc (abfd
, len
);
11246 memcpy (name
, note
->namedata
, len
);
11247 name
[len
- 1] = '\0';
11249 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11253 sect
->size
= note
->descsz
;
11254 sect
->filepos
= note
->descpos
;
11255 sect
->alignment_power
= 1;
11260 /* Function: elfcore_write_note
11263 buffer to hold note, and current size of buffer
11267 size of data for note
11269 Writes note to end of buffer. ELF64 notes are written exactly as
11270 for ELF32, despite the current (as of 2006) ELF gabi specifying
11271 that they ought to have 8-byte namesz and descsz field, and have
11272 8-byte alignment. Other writers, eg. Linux kernel, do the same.
11275 Pointer to realloc'd buffer, *BUFSIZ updated. */
11278 elfcore_write_note (bfd
*abfd
,
11286 Elf_External_Note
*xnp
;
11293 namesz
= strlen (name
) + 1;
11295 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
11297 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
11300 dest
= buf
+ *bufsiz
;
11301 *bufsiz
+= newspace
;
11302 xnp
= (Elf_External_Note
*) dest
;
11303 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
11304 H_PUT_32 (abfd
, size
, xnp
->descsz
);
11305 H_PUT_32 (abfd
, type
, xnp
->type
);
11309 memcpy (dest
, name
, namesz
);
11317 memcpy (dest
, input
, size
);
11327 /* gcc-8 warns (*) on all the strncpy calls in this function about
11328 possible string truncation. The "truncation" is not a bug. We
11329 have an external representation of structs with fields that are not
11330 necessarily NULL terminated and corresponding internal
11331 representation fields that are one larger so that they can always
11332 be NULL terminated.
11333 gcc versions between 4.2 and 4.6 do not allow pragma control of
11334 diagnostics inside functions, giving a hard error if you try to use
11335 the finer control available with later versions.
11336 gcc prior to 4.2 warns about diagnostic push and pop.
11337 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11338 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11339 (*) Depending on your system header files! */
11340 #if GCC_VERSION >= 8000
11341 # pragma GCC diagnostic push
11342 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11345 elfcore_write_prpsinfo (bfd
*abfd
,
11349 const char *psargs
)
11351 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11353 if (bed
->elf_backend_write_core_note
!= NULL
)
11356 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11357 NT_PRPSINFO
, fname
, psargs
);
11362 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11363 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11364 if (bed
->s
->elfclass
== ELFCLASS32
)
11366 # if defined (HAVE_PSINFO32_T)
11368 int note_type
= NT_PSINFO
;
11371 int note_type
= NT_PRPSINFO
;
11374 memset (&data
, 0, sizeof (data
));
11375 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11376 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11377 return elfcore_write_note (abfd
, buf
, bufsiz
,
11378 "CORE", note_type
, &data
, sizeof (data
));
11383 # if defined (HAVE_PSINFO_T)
11385 int note_type
= NT_PSINFO
;
11388 int note_type
= NT_PRPSINFO
;
11391 memset (&data
, 0, sizeof (data
));
11392 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11393 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11394 return elfcore_write_note (abfd
, buf
, bufsiz
,
11395 "CORE", note_type
, &data
, sizeof (data
));
11397 #endif /* PSINFO_T or PRPSINFO_T */
11402 #if GCC_VERSION >= 8000
11403 # pragma GCC diagnostic pop
11407 elfcore_write_linux_prpsinfo32
11408 (bfd
*abfd
, char *buf
, int *bufsiz
,
11409 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11411 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11413 struct elf_external_linux_prpsinfo32_ugid16 data
;
11415 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11416 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11417 &data
, sizeof (data
));
11421 struct elf_external_linux_prpsinfo32_ugid32 data
;
11423 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11424 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11425 &data
, sizeof (data
));
11430 elfcore_write_linux_prpsinfo64
11431 (bfd
*abfd
, char *buf
, int *bufsiz
,
11432 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11434 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11436 struct elf_external_linux_prpsinfo64_ugid16 data
;
11438 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11439 return elfcore_write_note (abfd
, buf
, bufsiz
,
11440 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11444 struct elf_external_linux_prpsinfo64_ugid32 data
;
11446 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11447 return elfcore_write_note (abfd
, buf
, bufsiz
,
11448 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11453 elfcore_write_prstatus (bfd
*abfd
,
11460 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11462 if (bed
->elf_backend_write_core_note
!= NULL
)
11465 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11467 pid
, cursig
, gregs
);
11472 #if defined (HAVE_PRSTATUS_T)
11473 #if defined (HAVE_PRSTATUS32_T)
11474 if (bed
->s
->elfclass
== ELFCLASS32
)
11476 prstatus32_t prstat
;
11478 memset (&prstat
, 0, sizeof (prstat
));
11479 prstat
.pr_pid
= pid
;
11480 prstat
.pr_cursig
= cursig
;
11481 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11482 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11483 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11490 memset (&prstat
, 0, sizeof (prstat
));
11491 prstat
.pr_pid
= pid
;
11492 prstat
.pr_cursig
= cursig
;
11493 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11494 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11495 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11497 #endif /* HAVE_PRSTATUS_T */
11503 #if defined (HAVE_LWPSTATUS_T)
11505 elfcore_write_lwpstatus (bfd
*abfd
,
11512 lwpstatus_t lwpstat
;
11513 const char *note_name
= "CORE";
11515 memset (&lwpstat
, 0, sizeof (lwpstat
));
11516 lwpstat
.pr_lwpid
= pid
>> 16;
11517 lwpstat
.pr_cursig
= cursig
;
11518 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11519 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11520 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11521 #if !defined(gregs)
11522 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11523 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11525 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11526 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11529 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11530 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11532 #endif /* HAVE_LWPSTATUS_T */
11534 #if defined (HAVE_PSTATUS_T)
11536 elfcore_write_pstatus (bfd
*abfd
,
11540 int cursig ATTRIBUTE_UNUSED
,
11541 const void *gregs ATTRIBUTE_UNUSED
)
11543 const char *note_name
= "CORE";
11544 #if defined (HAVE_PSTATUS32_T)
11545 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11547 if (bed
->s
->elfclass
== ELFCLASS32
)
11551 memset (&pstat
, 0, sizeof (pstat
));
11552 pstat
.pr_pid
= pid
& 0xffff;
11553 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11554 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11562 memset (&pstat
, 0, sizeof (pstat
));
11563 pstat
.pr_pid
= pid
& 0xffff;
11564 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11565 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11569 #endif /* HAVE_PSTATUS_T */
11572 elfcore_write_prfpreg (bfd
*abfd
,
11575 const void *fpregs
,
11578 const char *note_name
= "CORE";
11579 return elfcore_write_note (abfd
, buf
, bufsiz
,
11580 note_name
, NT_FPREGSET
, fpregs
, size
);
11584 elfcore_write_prxfpreg (bfd
*abfd
,
11587 const void *xfpregs
,
11590 char *note_name
= "LINUX";
11591 return elfcore_write_note (abfd
, buf
, bufsiz
,
11592 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11596 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11597 const void *xfpregs
, int size
)
11600 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11601 note_name
= "FreeBSD";
11603 note_name
= "LINUX";
11604 return elfcore_write_note (abfd
, buf
, bufsiz
,
11605 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11609 elfcore_write_ppc_vmx (bfd
*abfd
,
11612 const void *ppc_vmx
,
11615 char *note_name
= "LINUX";
11616 return elfcore_write_note (abfd
, buf
, bufsiz
,
11617 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11621 elfcore_write_ppc_vsx (bfd
*abfd
,
11624 const void *ppc_vsx
,
11627 char *note_name
= "LINUX";
11628 return elfcore_write_note (abfd
, buf
, bufsiz
,
11629 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11633 elfcore_write_ppc_tar (bfd
*abfd
,
11636 const void *ppc_tar
,
11639 char *note_name
= "LINUX";
11640 return elfcore_write_note (abfd
, buf
, bufsiz
,
11641 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11645 elfcore_write_ppc_ppr (bfd
*abfd
,
11648 const void *ppc_ppr
,
11651 char *note_name
= "LINUX";
11652 return elfcore_write_note (abfd
, buf
, bufsiz
,
11653 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11657 elfcore_write_ppc_dscr (bfd
*abfd
,
11660 const void *ppc_dscr
,
11663 char *note_name
= "LINUX";
11664 return elfcore_write_note (abfd
, buf
, bufsiz
,
11665 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11669 elfcore_write_ppc_ebb (bfd
*abfd
,
11672 const void *ppc_ebb
,
11675 char *note_name
= "LINUX";
11676 return elfcore_write_note (abfd
, buf
, bufsiz
,
11677 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11681 elfcore_write_ppc_pmu (bfd
*abfd
,
11684 const void *ppc_pmu
,
11687 char *note_name
= "LINUX";
11688 return elfcore_write_note (abfd
, buf
, bufsiz
,
11689 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11693 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11696 const void *ppc_tm_cgpr
,
11699 char *note_name
= "LINUX";
11700 return elfcore_write_note (abfd
, buf
, bufsiz
,
11701 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11705 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11708 const void *ppc_tm_cfpr
,
11711 char *note_name
= "LINUX";
11712 return elfcore_write_note (abfd
, buf
, bufsiz
,
11713 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11717 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11720 const void *ppc_tm_cvmx
,
11723 char *note_name
= "LINUX";
11724 return elfcore_write_note (abfd
, buf
, bufsiz
,
11725 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11729 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11732 const void *ppc_tm_cvsx
,
11735 char *note_name
= "LINUX";
11736 return elfcore_write_note (abfd
, buf
, bufsiz
,
11737 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11741 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11744 const void *ppc_tm_spr
,
11747 char *note_name
= "LINUX";
11748 return elfcore_write_note (abfd
, buf
, bufsiz
,
11749 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11753 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11756 const void *ppc_tm_ctar
,
11759 char *note_name
= "LINUX";
11760 return elfcore_write_note (abfd
, buf
, bufsiz
,
11761 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11765 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11768 const void *ppc_tm_cppr
,
11771 char *note_name
= "LINUX";
11772 return elfcore_write_note (abfd
, buf
, bufsiz
,
11773 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11777 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11780 const void *ppc_tm_cdscr
,
11783 char *note_name
= "LINUX";
11784 return elfcore_write_note (abfd
, buf
, bufsiz
,
11785 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11789 elfcore_write_s390_high_gprs (bfd
*abfd
,
11792 const void *s390_high_gprs
,
11795 char *note_name
= "LINUX";
11796 return elfcore_write_note (abfd
, buf
, bufsiz
,
11797 note_name
, NT_S390_HIGH_GPRS
,
11798 s390_high_gprs
, size
);
11802 elfcore_write_s390_timer (bfd
*abfd
,
11805 const void *s390_timer
,
11808 char *note_name
= "LINUX";
11809 return elfcore_write_note (abfd
, buf
, bufsiz
,
11810 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11814 elfcore_write_s390_todcmp (bfd
*abfd
,
11817 const void *s390_todcmp
,
11820 char *note_name
= "LINUX";
11821 return elfcore_write_note (abfd
, buf
, bufsiz
,
11822 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11826 elfcore_write_s390_todpreg (bfd
*abfd
,
11829 const void *s390_todpreg
,
11832 char *note_name
= "LINUX";
11833 return elfcore_write_note (abfd
, buf
, bufsiz
,
11834 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11838 elfcore_write_s390_ctrs (bfd
*abfd
,
11841 const void *s390_ctrs
,
11844 char *note_name
= "LINUX";
11845 return elfcore_write_note (abfd
, buf
, bufsiz
,
11846 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11850 elfcore_write_s390_prefix (bfd
*abfd
,
11853 const void *s390_prefix
,
11856 char *note_name
= "LINUX";
11857 return elfcore_write_note (abfd
, buf
, bufsiz
,
11858 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11862 elfcore_write_s390_last_break (bfd
*abfd
,
11865 const void *s390_last_break
,
11868 char *note_name
= "LINUX";
11869 return elfcore_write_note (abfd
, buf
, bufsiz
,
11870 note_name
, NT_S390_LAST_BREAK
,
11871 s390_last_break
, size
);
11875 elfcore_write_s390_system_call (bfd
*abfd
,
11878 const void *s390_system_call
,
11881 char *note_name
= "LINUX";
11882 return elfcore_write_note (abfd
, buf
, bufsiz
,
11883 note_name
, NT_S390_SYSTEM_CALL
,
11884 s390_system_call
, size
);
11888 elfcore_write_s390_tdb (bfd
*abfd
,
11891 const void *s390_tdb
,
11894 char *note_name
= "LINUX";
11895 return elfcore_write_note (abfd
, buf
, bufsiz
,
11896 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11900 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11903 const void *s390_vxrs_low
,
11906 char *note_name
= "LINUX";
11907 return elfcore_write_note (abfd
, buf
, bufsiz
,
11908 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11912 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11915 const void *s390_vxrs_high
,
11918 char *note_name
= "LINUX";
11919 return elfcore_write_note (abfd
, buf
, bufsiz
,
11920 note_name
, NT_S390_VXRS_HIGH
,
11921 s390_vxrs_high
, size
);
11925 elfcore_write_s390_gs_cb (bfd
*abfd
,
11928 const void *s390_gs_cb
,
11931 char *note_name
= "LINUX";
11932 return elfcore_write_note (abfd
, buf
, bufsiz
,
11933 note_name
, NT_S390_GS_CB
,
11938 elfcore_write_s390_gs_bc (bfd
*abfd
,
11941 const void *s390_gs_bc
,
11944 char *note_name
= "LINUX";
11945 return elfcore_write_note (abfd
, buf
, bufsiz
,
11946 note_name
, NT_S390_GS_BC
,
11951 elfcore_write_arm_vfp (bfd
*abfd
,
11954 const void *arm_vfp
,
11957 char *note_name
= "LINUX";
11958 return elfcore_write_note (abfd
, buf
, bufsiz
,
11959 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11963 elfcore_write_aarch_tls (bfd
*abfd
,
11966 const void *aarch_tls
,
11969 char *note_name
= "LINUX";
11970 return elfcore_write_note (abfd
, buf
, bufsiz
,
11971 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11975 elfcore_write_aarch_hw_break (bfd
*abfd
,
11978 const void *aarch_hw_break
,
11981 char *note_name
= "LINUX";
11982 return elfcore_write_note (abfd
, buf
, bufsiz
,
11983 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11987 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11990 const void *aarch_hw_watch
,
11993 char *note_name
= "LINUX";
11994 return elfcore_write_note (abfd
, buf
, bufsiz
,
11995 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11999 elfcore_write_aarch_sve (bfd
*abfd
,
12002 const void *aarch_sve
,
12005 char *note_name
= "LINUX";
12006 return elfcore_write_note (abfd
, buf
, bufsiz
,
12007 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
12011 elfcore_write_aarch_pauth (bfd
*abfd
,
12014 const void *aarch_pauth
,
12017 char *note_name
= "LINUX";
12018 return elfcore_write_note (abfd
, buf
, bufsiz
,
12019 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
12023 elfcore_write_aarch_mte (bfd
*abfd
,
12026 const void *aarch_mte
,
12029 char *note_name
= "LINUX";
12030 return elfcore_write_note (abfd
, buf
, bufsiz
,
12031 note_name
, NT_ARM_TAGGED_ADDR_CTRL
,
12037 elfcore_write_arc_v2 (bfd
*abfd
,
12040 const void *arc_v2
,
12043 char *note_name
= "LINUX";
12044 return elfcore_write_note (abfd
, buf
, bufsiz
,
12045 note_name
, NT_ARC_V2
, arc_v2
, size
);
12048 /* Write the buffer of csr values in CSRS (length SIZE) into the note
12049 buffer BUF and update *BUFSIZ. ABFD is the bfd the note is being
12050 written into. Return a pointer to the new start of the note buffer, to
12051 replace BUF which may no longer be valid. */
12054 elfcore_write_riscv_csr (bfd
*abfd
,
12060 const char *note_name
= "GDB";
12061 return elfcore_write_note (abfd
, buf
, bufsiz
,
12062 note_name
, NT_RISCV_CSR
, csrs
, size
);
12065 /* Write the target description (a string) pointed to by TDESC, length
12066 SIZE, into the note buffer BUF, and update *BUFSIZ. ABFD is the bfd the
12067 note is being written into. Return a pointer to the new start of the
12068 note buffer, to replace BUF which may no longer be valid. */
12071 elfcore_write_gdb_tdesc (bfd
*abfd
,
12077 const char *note_name
= "GDB";
12078 return elfcore_write_note (abfd
, buf
, bufsiz
,
12079 note_name
, NT_GDB_TDESC
, tdesc
, size
);
12083 elfcore_write_register_note (bfd
*abfd
,
12086 const char *section
,
12090 if (strcmp (section
, ".reg2") == 0)
12091 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
12092 if (strcmp (section
, ".reg-xfp") == 0)
12093 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
12094 if (strcmp (section
, ".reg-xstate") == 0)
12095 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
12096 if (strcmp (section
, ".reg-ppc-vmx") == 0)
12097 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
12098 if (strcmp (section
, ".reg-ppc-vsx") == 0)
12099 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
12100 if (strcmp (section
, ".reg-ppc-tar") == 0)
12101 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
12102 if (strcmp (section
, ".reg-ppc-ppr") == 0)
12103 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
12104 if (strcmp (section
, ".reg-ppc-dscr") == 0)
12105 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
12106 if (strcmp (section
, ".reg-ppc-ebb") == 0)
12107 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
12108 if (strcmp (section
, ".reg-ppc-pmu") == 0)
12109 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
12110 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
12111 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
12112 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
12113 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
12114 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
12115 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
12116 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
12117 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
12118 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
12119 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
12120 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
12121 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
12122 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
12123 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
12124 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
12125 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
12126 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
12127 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
12128 if (strcmp (section
, ".reg-s390-timer") == 0)
12129 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
12130 if (strcmp (section
, ".reg-s390-todcmp") == 0)
12131 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
12132 if (strcmp (section
, ".reg-s390-todpreg") == 0)
12133 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
12134 if (strcmp (section
, ".reg-s390-ctrs") == 0)
12135 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
12136 if (strcmp (section
, ".reg-s390-prefix") == 0)
12137 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
12138 if (strcmp (section
, ".reg-s390-last-break") == 0)
12139 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
12140 if (strcmp (section
, ".reg-s390-system-call") == 0)
12141 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
12142 if (strcmp (section
, ".reg-s390-tdb") == 0)
12143 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
12144 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
12145 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
12146 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
12147 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
12148 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
12149 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
12150 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
12151 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
12152 if (strcmp (section
, ".reg-arm-vfp") == 0)
12153 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
12154 if (strcmp (section
, ".reg-aarch-tls") == 0)
12155 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
12156 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
12157 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
12158 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
12159 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
12160 if (strcmp (section
, ".reg-aarch-sve") == 0)
12161 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
12162 if (strcmp (section
, ".reg-aarch-pauth") == 0)
12163 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
12164 if (strcmp (section
, ".reg-aarch-mte") == 0)
12165 return elfcore_write_aarch_mte (abfd
, buf
, bufsiz
, data
, size
);
12166 if (strcmp (section
, ".reg-arc-v2") == 0)
12167 return elfcore_write_arc_v2 (abfd
, buf
, bufsiz
, data
, size
);
12168 if (strcmp (section
, ".gdb-tdesc") == 0)
12169 return elfcore_write_gdb_tdesc (abfd
, buf
, bufsiz
, data
, size
);
12170 if (strcmp (section
, ".reg-riscv-csr") == 0)
12171 return elfcore_write_riscv_csr (abfd
, buf
, bufsiz
, data
, size
);
12176 elfcore_write_file_note (bfd
*obfd
, char *note_data
, int *note_size
,
12177 const void *buf
, int bufsiz
)
12179 return elfcore_write_note (obfd
, note_data
, note_size
,
12180 "CORE", NT_FILE
, buf
, bufsiz
);
12184 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
12189 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
12190 gABI specifies that PT_NOTE alignment should be aligned to 4
12191 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
12192 align is less than 4, we use 4 byte alignment. */
12195 if (align
!= 4 && align
!= 8)
12199 while (p
< buf
+ size
)
12201 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
12202 Elf_Internal_Note in
;
12204 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
12207 in
.type
= H_GET_32 (abfd
, xnp
->type
);
12209 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
12210 in
.namedata
= xnp
->name
;
12211 if (in
.namesz
> buf
- in
.namedata
+ size
)
12214 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
12215 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
12216 in
.descpos
= offset
+ (in
.descdata
- buf
);
12218 && (in
.descdata
>= buf
+ size
12219 || in
.descsz
> buf
- in
.descdata
+ size
))
12222 switch (bfd_get_format (abfd
))
12229 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
12232 const char * string
;
12234 bool (*func
) (bfd
*, Elf_Internal_Note
*);
12238 GROKER_ELEMENT ("", elfcore_grok_note
),
12239 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
12240 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
12241 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
12242 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
12243 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
12244 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
12246 #undef GROKER_ELEMENT
12249 for (i
= ARRAY_SIZE (grokers
); i
--;)
12251 if (in
.namesz
>= grokers
[i
].len
12252 && strncmp (in
.namedata
, grokers
[i
].string
,
12253 grokers
[i
].len
) == 0)
12255 if (! grokers
[i
].func (abfd
, & in
))
12264 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
12266 if (! elfobj_grok_gnu_note (abfd
, &in
))
12269 else if (in
.namesz
== sizeof "stapsdt"
12270 && strcmp (in
.namedata
, "stapsdt") == 0)
12272 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
12278 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
12285 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
12290 if (size
== 0 || (size
+ 1) == 0)
12293 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
12296 buf
= (char *) _bfd_malloc_and_read (abfd
, size
+ 1, size
);
12300 /* PR 17512: file: ec08f814
12301 0-termintate the buffer so that string searches will not overflow. */
12304 if (!elf_parse_notes (abfd
, buf
, size
, offset
, align
))
12314 /* Providing external access to the ELF program header table. */
12316 /* Return an upper bound on the number of bytes required to store a
12317 copy of ABFD's program header table entries. Return -1 if an error
12318 occurs; bfd_get_error will return an appropriate code. */
12321 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
12323 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12325 bfd_set_error (bfd_error_wrong_format
);
12329 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
12332 /* Copy ABFD's program header table entries to *PHDRS. The entries
12333 will be stored as an array of Elf_Internal_Phdr structures, as
12334 defined in include/elf/internal.h. To find out how large the
12335 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
12337 Return the number of program header table entries read, or -1 if an
12338 error occurs; bfd_get_error will return an appropriate code. */
12341 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
12345 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12347 bfd_set_error (bfd_error_wrong_format
);
12351 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
12352 if (num_phdrs
!= 0)
12353 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
12354 num_phdrs
* sizeof (Elf_Internal_Phdr
));
12359 enum elf_reloc_type_class
12360 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12361 const asection
*rel_sec ATTRIBUTE_UNUSED
,
12362 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
12364 return reloc_class_normal
;
12367 /* For RELA architectures, return the relocation value for a
12368 relocation against a local symbol. */
12371 _bfd_elf_rela_local_sym (bfd
*abfd
,
12372 Elf_Internal_Sym
*sym
,
12374 Elf_Internal_Rela
*rel
)
12376 asection
*sec
= *psec
;
12377 bfd_vma relocation
;
12379 relocation
= (sec
->output_section
->vma
12380 + sec
->output_offset
12382 if ((sec
->flags
& SEC_MERGE
)
12383 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
12384 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12387 _bfd_merged_section_offset (abfd
, psec
,
12388 elf_section_data (sec
)->sec_info
,
12389 sym
->st_value
+ rel
->r_addend
);
12392 /* If we have changed the section, and our original section is
12393 marked with SEC_EXCLUDE, it means that the original
12394 SEC_MERGE section has been completely subsumed in some
12395 other SEC_MERGE section. In this case, we need to leave
12396 some info around for --emit-relocs. */
12397 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12398 sec
->kept_section
= *psec
;
12401 rel
->r_addend
-= relocation
;
12402 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12408 _bfd_elf_rel_local_sym (bfd
*abfd
,
12409 Elf_Internal_Sym
*sym
,
12413 asection
*sec
= *psec
;
12415 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12416 return sym
->st_value
+ addend
;
12418 return _bfd_merged_section_offset (abfd
, psec
,
12419 elf_section_data (sec
)->sec_info
,
12420 sym
->st_value
+ addend
);
12423 /* Adjust an address within a section. Given OFFSET within SEC, return
12424 the new offset within the section, based upon changes made to the
12425 section. Returns -1 if the offset is now invalid.
12426 The offset (in abnd out) is in target sized bytes, however big a
12430 _bfd_elf_section_offset (bfd
*abfd
,
12431 struct bfd_link_info
*info
,
12435 switch (sec
->sec_info_type
)
12437 case SEC_INFO_TYPE_STABS
:
12438 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12440 case SEC_INFO_TYPE_EH_FRAME
:
12441 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12444 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12446 /* Reverse the offset. */
12447 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12448 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12450 /* address_size and sec->size are in octets. Convert
12451 to bytes before subtracting the original offset. */
12452 offset
= ((sec
->size
- address_size
)
12453 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12459 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12460 reconstruct an ELF file by reading the segments out of remote memory
12461 based on the ELF file header at EHDR_VMA and the ELF program headers it
12462 points to. If not null, *LOADBASEP is filled in with the difference
12463 between the VMAs from which the segments were read, and the VMAs the
12464 file headers (and hence BFD's idea of each section's VMA) put them at.
12466 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12467 remote memory at target address VMA into the local buffer at MYADDR; it
12468 should return zero on success or an `errno' code on failure. TEMPL must
12469 be a BFD for an ELF target with the word size and byte order found in
12470 the remote memory. */
12473 bfd_elf_bfd_from_remote_memory
12476 bfd_size_type size
,
12477 bfd_vma
*loadbasep
,
12478 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12480 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12481 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12485 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12486 long symcount ATTRIBUTE_UNUSED
,
12487 asymbol
**syms ATTRIBUTE_UNUSED
,
12492 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12495 const char *relplt_name
;
12496 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
12500 Elf_Internal_Shdr
*hdr
;
12506 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12509 if (dynsymcount
<= 0)
12512 if (!bed
->plt_sym_val
)
12515 relplt_name
= bed
->relplt_name
;
12516 if (relplt_name
== NULL
)
12517 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12518 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12519 if (relplt
== NULL
)
12522 hdr
= &elf_section_data (relplt
)->this_hdr
;
12523 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12524 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12527 plt
= bfd_get_section_by_name (abfd
, ".plt");
12531 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12532 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, true))
12535 count
= relplt
->size
/ hdr
->sh_entsize
;
12536 size
= count
* sizeof (asymbol
);
12537 p
= relplt
->relocation
;
12538 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12540 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12541 if (p
->addend
!= 0)
12544 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12546 size
+= sizeof ("+0x") - 1 + 8;
12551 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12555 names
= (char *) (s
+ count
);
12556 p
= relplt
->relocation
;
12558 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12563 addr
= bed
->plt_sym_val (i
, plt
, p
);
12564 if (addr
== (bfd_vma
) -1)
12567 *s
= **p
->sym_ptr_ptr
;
12568 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12569 we are defining a symbol, ensure one of them is set. */
12570 if ((s
->flags
& BSF_LOCAL
) == 0)
12571 s
->flags
|= BSF_GLOBAL
;
12572 s
->flags
|= BSF_SYNTHETIC
;
12574 s
->value
= addr
- plt
->vma
;
12577 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12578 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12580 if (p
->addend
!= 0)
12584 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12585 names
+= sizeof ("+0x") - 1;
12586 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12587 for (a
= buf
; *a
== '0'; ++a
)
12590 memcpy (names
, a
, len
);
12593 memcpy (names
, "@plt", sizeof ("@plt"));
12594 names
+= sizeof ("@plt");
12601 /* It is only used by x86-64 so far.
12602 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12603 but current usage would allow all of _bfd_std_section to be zero. */
12604 static const asymbol lcomm_sym
12605 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12606 asection _bfd_elf_large_com_section
12607 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12608 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12611 _bfd_elf_final_write_processing (bfd
*abfd
)
12613 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12615 i_ehdrp
= elf_elfheader (abfd
);
12617 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12618 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12620 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12621 SHF_GNU_MBIND or SHF_GNU_RETAIN sections or symbols of STT_GNU_IFUNC type
12622 or STB_GNU_UNIQUE binding. */
12623 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12625 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12626 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12627 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12628 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12630 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12631 _bfd_error_handler (_("GNU_MBIND section is supported only by GNU "
12632 "and FreeBSD targets"));
12633 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12634 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is supported "
12635 "only by GNU and FreeBSD targets"));
12636 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12637 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is supported "
12638 "only by GNU and FreeBSD targets"));
12639 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_retain
)
12640 _bfd_error_handler (_("GNU_RETAIN section is supported "
12641 "only by GNU and FreeBSD targets"));
12642 bfd_set_error (bfd_error_sorry
);
12650 /* Return TRUE for ELF symbol types that represent functions.
12651 This is the default version of this function, which is sufficient for
12652 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12655 _bfd_elf_is_function_type (unsigned int type
)
12657 return (type
== STT_FUNC
12658 || type
== STT_GNU_IFUNC
);
12661 /* If the ELF symbol SYM might be a function in SEC, return the
12662 function size and set *CODE_OFF to the function's entry point,
12663 otherwise return zero. */
12666 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12669 bfd_size_type size
;
12670 elf_symbol_type
* elf_sym
= (elf_symbol_type
*) sym
;
12672 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12673 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12674 || sym
->section
!= sec
)
12677 size
= (sym
->flags
& BSF_SYNTHETIC
) ? 0 : elf_sym
->internal_elf_sym
.st_size
;
12679 /* In theory we should check that the symbol's type satisfies
12680 _bfd_elf_is_function_type(), but there are some function-like
12681 symbols which would fail this test. (eg _start). Instead
12682 we check for hidden, local, notype symbols with zero size.
12683 This type of symbol is generated by the annobin plugin for gcc
12684 and clang, and should not be considered to be a function symbol. */
12686 && ((sym
->flags
& (BSF_SYNTHETIC
| BSF_LOCAL
)) == BSF_LOCAL
)
12687 && ELF_ST_TYPE (elf_sym
->internal_elf_sym
.st_info
) == STT_NOTYPE
12688 && ELF_ST_VISIBILITY (elf_sym
->internal_elf_sym
.st_other
) == STV_HIDDEN
)
12691 *code_off
= sym
->value
;
12692 /* Do not return 0 for the function's size. */
12693 return size
? size
: 1;
12696 /* Set to non-zero to enable some debug messages. */
12697 #define DEBUG_SECONDARY_RELOCS 0
12699 /* An internal-to-the-bfd-library only section type
12700 used to indicate a cached secondary reloc section. */
12701 #define SHT_SECONDARY_RELOC (SHT_LOOS + SHT_RELA)
12703 /* Create a BFD section to hold a secondary reloc section. */
12706 _bfd_elf_init_secondary_reloc_section (bfd
* abfd
,
12707 Elf_Internal_Shdr
*hdr
,
12709 unsigned int shindex
)
12711 /* We only support RELA secondary relocs. */
12712 if (hdr
->sh_type
!= SHT_RELA
)
12715 #if DEBUG_SECONDARY_RELOCS
12716 fprintf (stderr
, "secondary reloc section %s encountered\n", name
);
12718 hdr
->sh_type
= SHT_SECONDARY_RELOC
;
12719 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
12722 /* Read in any secondary relocs associated with SEC. */
12725 _bfd_elf_slurp_secondary_reloc_section (bfd
* abfd
,
12727 asymbol
** symbols
,
12730 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12732 bool result
= true;
12733 bfd_vma (*r_sym
) (bfd_vma
);
12735 #if BFD_DEFAULT_TARGET_SIZE > 32
12736 if (bfd_arch_bits_per_address (abfd
) != 32)
12737 r_sym
= elf64_r_sym
;
12740 r_sym
= elf32_r_sym
;
12742 /* Discover if there are any secondary reloc sections
12743 associated with SEC. */
12744 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12746 Elf_Internal_Shdr
* hdr
= & elf_section_data (relsec
)->this_hdr
;
12748 if (hdr
->sh_type
== SHT_SECONDARY_RELOC
12749 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
12750 && (hdr
->sh_entsize
== ebd
->s
->sizeof_rel
12751 || hdr
->sh_entsize
== ebd
->s
->sizeof_rela
))
12753 bfd_byte
* native_relocs
;
12754 bfd_byte
* native_reloc
;
12755 arelent
* internal_relocs
;
12756 arelent
* internal_reloc
;
12758 unsigned int entsize
;
12759 unsigned int symcount
;
12760 unsigned int reloc_count
;
12763 if (ebd
->elf_info_to_howto
== NULL
)
12766 #if DEBUG_SECONDARY_RELOCS
12767 fprintf (stderr
, "read secondary relocs for %s from %s\n",
12768 sec
->name
, relsec
->name
);
12770 entsize
= hdr
->sh_entsize
;
12772 native_relocs
= bfd_malloc (hdr
->sh_size
);
12773 if (native_relocs
== NULL
)
12779 reloc_count
= NUM_SHDR_ENTRIES (hdr
);
12780 if (_bfd_mul_overflow (reloc_count
, sizeof (arelent
), & amt
))
12782 free (native_relocs
);
12783 bfd_set_error (bfd_error_file_too_big
);
12788 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
12789 if (internal_relocs
== NULL
)
12791 free (native_relocs
);
12796 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
12797 || (bfd_bread (native_relocs
, hdr
->sh_size
, abfd
)
12800 free (native_relocs
);
12801 /* The internal_relocs will be freed when
12802 the memory for the bfd is released. */
12808 symcount
= bfd_get_dynamic_symcount (abfd
);
12810 symcount
= bfd_get_symcount (abfd
);
12812 for (i
= 0, internal_reloc
= internal_relocs
,
12813 native_reloc
= native_relocs
;
12815 i
++, internal_reloc
++, native_reloc
+= entsize
)
12818 Elf_Internal_Rela rela
;
12820 if (entsize
== ebd
->s
->sizeof_rel
)
12821 ebd
->s
->swap_reloc_in (abfd
, native_reloc
, & rela
);
12822 else /* entsize == ebd->s->sizeof_rela */
12823 ebd
->s
->swap_reloca_in (abfd
, native_reloc
, & rela
);
12825 /* The address of an ELF reloc is section relative for an object
12826 file, and absolute for an executable file or shared library.
12827 The address of a normal BFD reloc is always section relative,
12828 and the address of a dynamic reloc is absolute.. */
12829 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
12830 internal_reloc
->address
= rela
.r_offset
;
12832 internal_reloc
->address
= rela
.r_offset
- sec
->vma
;
12834 if (r_sym (rela
.r_info
) == STN_UNDEF
)
12836 /* FIXME: This and the error case below mean that we
12837 have a symbol on relocs that is not elf_symbol_type. */
12838 internal_reloc
->sym_ptr_ptr
=
12839 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12841 else if (r_sym (rela
.r_info
) > symcount
)
12844 /* xgettext:c-format */
12845 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
12846 abfd
, sec
, i
, (long) r_sym (rela
.r_info
));
12847 bfd_set_error (bfd_error_bad_value
);
12848 internal_reloc
->sym_ptr_ptr
=
12849 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12856 ps
= symbols
+ r_sym (rela
.r_info
) - 1;
12857 internal_reloc
->sym_ptr_ptr
= ps
;
12858 /* Make sure that this symbol is not removed by strip. */
12859 (*ps
)->flags
|= BSF_KEEP
;
12862 internal_reloc
->addend
= rela
.r_addend
;
12864 res
= ebd
->elf_info_to_howto (abfd
, internal_reloc
, & rela
);
12865 if (! res
|| internal_reloc
->howto
== NULL
)
12867 #if DEBUG_SECONDARY_RELOCS
12868 fprintf (stderr
, "there is no howto associated with reloc %lx\n",
12875 free (native_relocs
);
12876 /* Store the internal relocs. */
12877 elf_section_data (relsec
)->sec_info
= internal_relocs
;
12884 /* Set the ELF section header fields of an output secondary reloc section. */
12887 _bfd_elf_copy_special_section_fields (const bfd
* ibfd ATTRIBUTE_UNUSED
,
12888 bfd
* obfd ATTRIBUTE_UNUSED
,
12889 const Elf_Internal_Shdr
* isection
,
12890 Elf_Internal_Shdr
* osection
)
12894 struct bfd_elf_section_data
* esd
;
12896 if (isection
== NULL
)
12899 if (isection
->sh_type
!= SHT_SECONDARY_RELOC
)
12902 isec
= isection
->bfd_section
;
12906 osec
= osection
->bfd_section
;
12910 esd
= elf_section_data (osec
);
12911 BFD_ASSERT (esd
->sec_info
== NULL
);
12912 esd
->sec_info
= elf_section_data (isec
)->sec_info
;
12913 osection
->sh_type
= SHT_RELA
;
12914 osection
->sh_link
= elf_onesymtab (obfd
);
12915 if (osection
->sh_link
== 0)
12917 /* There is no symbol table - we are hosed... */
12919 /* xgettext:c-format */
12920 (_("%pB(%pA): link section cannot be set because the output file does not have a symbol table"),
12922 bfd_set_error (bfd_error_bad_value
);
12926 /* Find the output section that corresponds to the isection's sh_info link. */
12927 if (isection
->sh_info
== 0
12928 || isection
->sh_info
>= elf_numsections (ibfd
))
12931 /* xgettext:c-format */
12932 (_("%pB(%pA): info section index is invalid"),
12934 bfd_set_error (bfd_error_bad_value
);
12938 isection
= elf_elfsections (ibfd
)[isection
->sh_info
];
12940 if (isection
== NULL
12941 || isection
->bfd_section
== NULL
12942 || isection
->bfd_section
->output_section
== NULL
)
12945 /* xgettext:c-format */
12946 (_("%pB(%pA): info section index cannot be set because the section is not in the output"),
12948 bfd_set_error (bfd_error_bad_value
);
12952 esd
= elf_section_data (isection
->bfd_section
->output_section
);
12953 BFD_ASSERT (esd
!= NULL
);
12954 osection
->sh_info
= esd
->this_idx
;
12955 esd
->has_secondary_relocs
= true;
12956 #if DEBUG_SECONDARY_RELOCS
12957 fprintf (stderr
, "update header of %s, sh_link = %u, sh_info = %u\n",
12958 osec
->name
, osection
->sh_link
, osection
->sh_info
);
12959 fprintf (stderr
, "mark section %s as having secondary relocs\n",
12960 bfd_section_name (isection
->bfd_section
->output_section
));
12966 /* Write out a secondary reloc section.
12968 FIXME: Currently this function can result in a serious performance penalty
12969 for files with secondary relocs and lots of sections. The proper way to
12970 fix this is for _bfd_elf_copy_special_section_fields() to chain secondary
12971 relocs together and then to have this function just walk that chain. */
12974 _bfd_elf_write_secondary_reloc_section (bfd
*abfd
, asection
*sec
)
12976 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12977 bfd_vma addr_offset
;
12979 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
12980 bool result
= true;
12985 #if BFD_DEFAULT_TARGET_SIZE > 32
12986 if (bfd_arch_bits_per_address (abfd
) != 32)
12987 r_info
= elf64_r_info
;
12990 r_info
= elf32_r_info
;
12992 /* The address of an ELF reloc is section relative for an object
12993 file, and absolute for an executable file or shared library.
12994 The address of a BFD reloc is always section relative. */
12996 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
12997 addr_offset
= sec
->vma
;
12999 /* Discover if there are any secondary reloc sections
13000 associated with SEC. */
13001 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
13003 const struct bfd_elf_section_data
* const esd
= elf_section_data (relsec
);
13004 Elf_Internal_Shdr
* const hdr
= (Elf_Internal_Shdr
*) & esd
->this_hdr
;
13006 if (hdr
->sh_type
== SHT_RELA
13007 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
)
13009 asymbol
* last_sym
;
13011 unsigned int reloc_count
;
13013 unsigned int entsize
;
13014 arelent
* src_irel
;
13015 bfd_byte
* dst_rela
;
13017 if (hdr
->contents
!= NULL
)
13020 /* xgettext:c-format */
13021 (_("%pB(%pA): error: secondary reloc section processed twice"),
13023 bfd_set_error (bfd_error_bad_value
);
13028 entsize
= hdr
->sh_entsize
;
13032 /* xgettext:c-format */
13033 (_("%pB(%pA): error: secondary reloc section has zero sized entries"),
13035 bfd_set_error (bfd_error_bad_value
);
13039 else if (entsize
!= ebd
->s
->sizeof_rel
13040 && entsize
!= ebd
->s
->sizeof_rela
)
13043 /* xgettext:c-format */
13044 (_("%pB(%pA): error: secondary reloc section has non-standard sized entries"),
13046 bfd_set_error (bfd_error_bad_value
);
13051 reloc_count
= hdr
->sh_size
/ entsize
;
13052 if (reloc_count
<= 0)
13055 /* xgettext:c-format */
13056 (_("%pB(%pA): error: secondary reloc section is empty!"),
13058 bfd_set_error (bfd_error_bad_value
);
13063 hdr
->contents
= bfd_alloc (abfd
, hdr
->sh_size
);
13064 if (hdr
->contents
== NULL
)
13067 #if DEBUG_SECONDARY_RELOCS
13068 fprintf (stderr
, "write %u secondary relocs for %s from %s\n",
13069 reloc_count
, sec
->name
, relsec
->name
);
13073 dst_rela
= hdr
->contents
;
13074 src_irel
= (arelent
*) esd
->sec_info
;
13075 if (src_irel
== NULL
)
13078 /* xgettext:c-format */
13079 (_("%pB(%pA): error: internal relocs missing for secondary reloc section"),
13081 bfd_set_error (bfd_error_bad_value
);
13086 for (idx
= 0; idx
< reloc_count
; idx
++, dst_rela
+= entsize
)
13088 Elf_Internal_Rela src_rela
;
13093 ptr
= src_irel
+ idx
;
13097 /* xgettext:c-format */
13098 (_("%pB(%pA): error: reloc table entry %u is empty"),
13099 abfd
, relsec
, idx
);
13100 bfd_set_error (bfd_error_bad_value
);
13105 if (ptr
->sym_ptr_ptr
== NULL
)
13107 /* FIXME: Is this an error ? */
13112 sym
= *ptr
->sym_ptr_ptr
;
13114 if (sym
== last_sym
)
13118 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, & sym
);
13122 /* xgettext:c-format */
13123 (_("%pB(%pA): error: secondary reloc %u references a missing symbol"),
13124 abfd
, relsec
, idx
);
13125 bfd_set_error (bfd_error_bad_value
);
13134 if (sym
->the_bfd
!= NULL
13135 && sym
->the_bfd
->xvec
!= abfd
->xvec
13136 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
13139 /* xgettext:c-format */
13140 (_("%pB(%pA): error: secondary reloc %u references a deleted symbol"),
13141 abfd
, relsec
, idx
);
13142 bfd_set_error (bfd_error_bad_value
);
13148 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
13149 if (ptr
->howto
== NULL
)
13152 /* xgettext:c-format */
13153 (_("%pB(%pA): error: secondary reloc %u is of an unknown type"),
13154 abfd
, relsec
, idx
);
13155 bfd_set_error (bfd_error_bad_value
);
13157 src_rela
.r_info
= r_info (0, 0);
13160 src_rela
.r_info
= r_info (n
, ptr
->howto
->type
);
13161 src_rela
.r_addend
= ptr
->addend
;
13163 if (entsize
== ebd
->s
->sizeof_rel
)
13164 ebd
->s
->swap_reloc_out (abfd
, &src_rela
, dst_rela
);
13165 else /* entsize == ebd->s->sizeof_rela */
13166 ebd
->s
->swap_reloca_out (abfd
, &src_rela
, dst_rela
);