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"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2729 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2730 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2731 { NULL
, 0, 0, 0, 0 }
2734 static const struct bfd_elf_special_section special_sections_r
[] =
2736 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2737 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2738 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2739 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2740 { NULL
, 0, 0, 0, 0 }
2743 static const struct bfd_elf_special_section special_sections_s
[] =
2745 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2746 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2747 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2748 /* See struct bfd_elf_special_section declaration for the semantics of
2749 this special case where .prefix_length != strlen (.prefix). */
2750 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2751 { NULL
, 0, 0, 0, 0 }
2754 static const struct bfd_elf_special_section special_sections_t
[] =
2756 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2757 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2758 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2759 { NULL
, 0, 0, 0, 0 }
2762 static const struct bfd_elf_special_section special_sections_z
[] =
2764 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2765 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2766 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2767 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2768 { NULL
, 0, 0, 0, 0 }
2771 static const struct bfd_elf_special_section
* const special_sections
[] =
2773 special_sections_b
, /* 'b' */
2774 special_sections_c
, /* 'c' */
2775 special_sections_d
, /* 'd' */
2777 special_sections_f
, /* 'f' */
2778 special_sections_g
, /* 'g' */
2779 special_sections_h
, /* 'h' */
2780 special_sections_i
, /* 'i' */
2783 special_sections_l
, /* 'l' */
2785 special_sections_n
, /* 'n' */
2787 special_sections_p
, /* 'p' */
2789 special_sections_r
, /* 'r' */
2790 special_sections_s
, /* 's' */
2791 special_sections_t
, /* 't' */
2797 special_sections_z
/* 'z' */
2800 const struct bfd_elf_special_section
*
2801 _bfd_elf_get_special_section (const char *name
,
2802 const struct bfd_elf_special_section
*spec
,
2808 len
= strlen (name
);
2810 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2813 int prefix_len
= spec
[i
].prefix_length
;
2815 if (len
< prefix_len
)
2817 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2820 suffix_len
= spec
[i
].suffix_length
;
2821 if (suffix_len
<= 0)
2823 if (name
[prefix_len
] != 0)
2825 if (suffix_len
== 0)
2827 if (name
[prefix_len
] != '.'
2828 && (suffix_len
== -2
2829 || (rela
&& spec
[i
].type
== SHT_REL
)))
2835 if (len
< prefix_len
+ suffix_len
)
2837 if (memcmp (name
+ len
- suffix_len
,
2838 spec
[i
].prefix
+ prefix_len
,
2848 const struct bfd_elf_special_section
*
2849 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2852 const struct bfd_elf_special_section
*spec
;
2853 const struct elf_backend_data
*bed
;
2855 /* See if this is one of the special sections. */
2856 if (sec
->name
== NULL
)
2859 bed
= get_elf_backend_data (abfd
);
2860 spec
= bed
->special_sections
;
2863 spec
= _bfd_elf_get_special_section (sec
->name
,
2864 bed
->special_sections
,
2870 if (sec
->name
[0] != '.')
2873 i
= sec
->name
[1] - 'b';
2874 if (i
< 0 || i
> 'z' - 'b')
2877 spec
= special_sections
[i
];
2882 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2886 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2888 struct bfd_elf_section_data
*sdata
;
2889 const struct elf_backend_data
*bed
;
2890 const struct bfd_elf_special_section
*ssect
;
2892 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2895 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2899 sec
->used_by_bfd
= sdata
;
2902 /* Indicate whether or not this section should use RELA relocations. */
2903 bed
= get_elf_backend_data (abfd
);
2904 sec
->use_rela_p
= bed
->default_use_rela_p
;
2906 /* Set up ELF section type and flags for newly created sections, if
2907 there is an ABI mandated section. */
2908 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2911 elf_section_type (sec
) = ssect
->type
;
2912 elf_section_flags (sec
) = ssect
->attr
;
2915 return _bfd_generic_new_section_hook (abfd
, sec
);
2918 /* Create a new bfd section from an ELF program header.
2920 Since program segments have no names, we generate a synthetic name
2921 of the form segment<NUM>, where NUM is generally the index in the
2922 program header table. For segments that are split (see below) we
2923 generate the names segment<NUM>a and segment<NUM>b.
2925 Note that some program segments may have a file size that is different than
2926 (less than) the memory size. All this means is that at execution the
2927 system must allocate the amount of memory specified by the memory size,
2928 but only initialize it with the first "file size" bytes read from the
2929 file. This would occur for example, with program segments consisting
2930 of combined data+bss.
2932 To handle the above situation, this routine generates TWO bfd sections
2933 for the single program segment. The first has the length specified by
2934 the file size of the segment, and the second has the length specified
2935 by the difference between the two sizes. In effect, the segment is split
2936 into its initialized and uninitialized parts.
2941 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2942 Elf_Internal_Phdr
*hdr
,
2944 const char *type_name
)
2951 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
2953 split
= ((hdr
->p_memsz
> 0)
2954 && (hdr
->p_filesz
> 0)
2955 && (hdr
->p_memsz
> hdr
->p_filesz
));
2957 if (hdr
->p_filesz
> 0)
2959 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2960 len
= strlen (namebuf
) + 1;
2961 name
= (char *) bfd_alloc (abfd
, len
);
2964 memcpy (name
, namebuf
, len
);
2965 newsect
= bfd_make_section (abfd
, name
);
2966 if (newsect
== NULL
)
2968 newsect
->vma
= hdr
->p_vaddr
/ opb
;
2969 newsect
->lma
= hdr
->p_paddr
/ opb
;
2970 newsect
->size
= hdr
->p_filesz
;
2971 newsect
->filepos
= hdr
->p_offset
;
2972 newsect
->flags
|= SEC_HAS_CONTENTS
;
2973 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2974 if (hdr
->p_type
== PT_LOAD
)
2976 newsect
->flags
|= SEC_ALLOC
;
2977 newsect
->flags
|= SEC_LOAD
;
2978 if (hdr
->p_flags
& PF_X
)
2980 /* FIXME: all we known is that it has execute PERMISSION,
2982 newsect
->flags
|= SEC_CODE
;
2985 if (!(hdr
->p_flags
& PF_W
))
2987 newsect
->flags
|= SEC_READONLY
;
2991 if (hdr
->p_memsz
> hdr
->p_filesz
)
2995 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2996 len
= strlen (namebuf
) + 1;
2997 name
= (char *) bfd_alloc (abfd
, len
);
3000 memcpy (name
, namebuf
, len
);
3001 newsect
= bfd_make_section (abfd
, name
);
3002 if (newsect
== NULL
)
3004 newsect
->vma
= (hdr
->p_vaddr
+ hdr
->p_filesz
) / opb
;
3005 newsect
->lma
= (hdr
->p_paddr
+ hdr
->p_filesz
) / opb
;
3006 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
3007 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
3008 align
= newsect
->vma
& -newsect
->vma
;
3009 if (align
== 0 || align
> hdr
->p_align
)
3010 align
= hdr
->p_align
;
3011 newsect
->alignment_power
= bfd_log2 (align
);
3012 if (hdr
->p_type
== PT_LOAD
)
3014 newsect
->flags
|= SEC_ALLOC
;
3015 if (hdr
->p_flags
& PF_X
)
3016 newsect
->flags
|= SEC_CODE
;
3018 if (!(hdr
->p_flags
& PF_W
))
3019 newsect
->flags
|= SEC_READONLY
;
3026 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3028 /* The return value is ignored. Build-ids are considered optional. */
3029 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3030 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3036 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3038 const struct elf_backend_data
*bed
;
3040 switch (hdr
->p_type
)
3043 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3046 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3048 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3049 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3053 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3056 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3059 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3061 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3067 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3070 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3072 case PT_GNU_EH_FRAME
:
3073 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3077 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3080 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3083 /* Check for any processor-specific program segment types. */
3084 bed
= get_elf_backend_data (abfd
);
3085 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3089 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3093 _bfd_elf_single_rel_hdr (asection
*sec
)
3095 if (elf_section_data (sec
)->rel
.hdr
)
3097 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3098 return elf_section_data (sec
)->rel
.hdr
;
3101 return elf_section_data (sec
)->rela
.hdr
;
3105 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3106 Elf_Internal_Shdr
*rel_hdr
,
3107 const char *sec_name
,
3110 char *name
= (char *) bfd_alloc (abfd
,
3111 sizeof ".rela" + strlen (sec_name
));
3115 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3117 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3119 if (rel_hdr
->sh_name
== (unsigned int) -1)
3125 /* Allocate and initialize a section-header for a new reloc section,
3126 containing relocations against ASECT. It is stored in RELDATA. If
3127 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3131 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3132 struct bfd_elf_section_reloc_data
*reldata
,
3133 const char *sec_name
,
3135 bool delay_st_name_p
)
3137 Elf_Internal_Shdr
*rel_hdr
;
3138 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3140 BFD_ASSERT (reldata
->hdr
== NULL
);
3141 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3142 reldata
->hdr
= rel_hdr
;
3144 if (delay_st_name_p
)
3145 rel_hdr
->sh_name
= (unsigned int) -1;
3146 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3149 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3150 rel_hdr
->sh_entsize
= (use_rela_p
3151 ? bed
->s
->sizeof_rela
3152 : bed
->s
->sizeof_rel
);
3153 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3154 rel_hdr
->sh_flags
= 0;
3155 rel_hdr
->sh_addr
= 0;
3156 rel_hdr
->sh_size
= 0;
3157 rel_hdr
->sh_offset
= 0;
3162 /* Return the default section type based on the passed in section flags. */
3165 bfd_elf_get_default_section_type (flagword flags
)
3167 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3168 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3170 return SHT_PROGBITS
;
3173 struct fake_section_arg
3175 struct bfd_link_info
*link_info
;
3179 /* Set up an ELF internal section header for a section. */
3182 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3184 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3185 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3186 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3187 Elf_Internal_Shdr
*this_hdr
;
3188 unsigned int sh_type
;
3189 const char *name
= asect
->name
;
3190 bool delay_st_name_p
= false;
3195 /* We already failed; just get out of the bfd_map_over_sections
3200 this_hdr
= &esd
->this_hdr
;
3204 /* ld: compress DWARF debug sections with names: .debug_*. */
3205 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3206 && (asect
->flags
& SEC_DEBUGGING
)
3210 /* Set SEC_ELF_COMPRESS to indicate this section should be
3212 asect
->flags
|= SEC_ELF_COMPRESS
;
3213 /* If this section will be compressed, delay adding section
3214 name to section name section after it is compressed in
3215 _bfd_elf_assign_file_positions_for_non_load. */
3216 delay_st_name_p
= true;
3219 else if ((asect
->flags
& SEC_ELF_RENAME
))
3221 /* objcopy: rename output DWARF debug section. */
3222 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3224 /* When we decompress or compress with SHF_COMPRESSED,
3225 convert section name from .zdebug_* to .debug_* if
3229 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3230 if (new_name
== NULL
)
3238 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3240 /* PR binutils/18087: Compression does not always make a
3241 section smaller. So only rename the section when
3242 compression has actually taken place. If input section
3243 name is .zdebug_*, we should never compress it again. */
3244 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3245 if (new_name
== NULL
)
3250 BFD_ASSERT (name
[1] != 'z');
3255 if (delay_st_name_p
)
3256 this_hdr
->sh_name
= (unsigned int) -1;
3260 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3262 if (this_hdr
->sh_name
== (unsigned int) -1)
3269 /* Don't clear sh_flags. Assembler may set additional bits. */
3271 if ((asect
->flags
& SEC_ALLOC
) != 0
3272 || asect
->user_set_vma
)
3273 this_hdr
->sh_addr
= asect
->vma
* bfd_octets_per_byte (abfd
, asect
);
3275 this_hdr
->sh_addr
= 0;
3277 this_hdr
->sh_offset
= 0;
3278 this_hdr
->sh_size
= asect
->size
;
3279 this_hdr
->sh_link
= 0;
3280 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3281 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3284 /* xgettext:c-format */
3285 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3286 abfd
, asect
->alignment_power
, asect
);
3290 /* Set sh_addralign to the highest power of two given by alignment
3291 consistent with the section VMA. Linker scripts can force VMA. */
3292 mask
= ((bfd_vma
) 1 << asect
->alignment_power
) | this_hdr
->sh_addr
;
3293 this_hdr
->sh_addralign
= mask
& -mask
;
3294 /* The sh_entsize and sh_info fields may have been set already by
3295 copy_private_section_data. */
3297 this_hdr
->bfd_section
= asect
;
3298 this_hdr
->contents
= NULL
;
3300 /* If the section type is unspecified, we set it based on
3302 if ((asect
->flags
& SEC_GROUP
) != 0)
3303 sh_type
= SHT_GROUP
;
3305 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3307 if (this_hdr
->sh_type
== SHT_NULL
)
3308 this_hdr
->sh_type
= sh_type
;
3309 else if (this_hdr
->sh_type
== SHT_NOBITS
3310 && sh_type
== SHT_PROGBITS
3311 && (asect
->flags
& SEC_ALLOC
) != 0)
3313 /* Warn if we are changing a NOBITS section to PROGBITS, but
3314 allow the link to proceed. This can happen when users link
3315 non-bss input sections to bss output sections, or emit data
3316 to a bss output section via a linker script. */
3318 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3319 this_hdr
->sh_type
= sh_type
;
3322 switch (this_hdr
->sh_type
)
3333 case SHT_INIT_ARRAY
:
3334 case SHT_FINI_ARRAY
:
3335 case SHT_PREINIT_ARRAY
:
3336 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3340 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3344 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3348 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3352 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3353 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3357 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3358 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3361 case SHT_GNU_versym
:
3362 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3365 case SHT_GNU_verdef
:
3366 this_hdr
->sh_entsize
= 0;
3367 /* objcopy or strip will copy over sh_info, but may not set
3368 cverdefs. The linker will set cverdefs, but sh_info will be
3370 if (this_hdr
->sh_info
== 0)
3371 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3373 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3374 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3377 case SHT_GNU_verneed
:
3378 this_hdr
->sh_entsize
= 0;
3379 /* objcopy or strip will copy over sh_info, but may not set
3380 cverrefs. The linker will set cverrefs, but sh_info will be
3382 if (this_hdr
->sh_info
== 0)
3383 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3385 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3386 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3390 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3394 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3398 if ((asect
->flags
& SEC_ALLOC
) != 0)
3399 this_hdr
->sh_flags
|= SHF_ALLOC
;
3400 if ((asect
->flags
& SEC_READONLY
) == 0)
3401 this_hdr
->sh_flags
|= SHF_WRITE
;
3402 if ((asect
->flags
& SEC_CODE
) != 0)
3403 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3404 if ((asect
->flags
& SEC_MERGE
) != 0)
3406 this_hdr
->sh_flags
|= SHF_MERGE
;
3407 this_hdr
->sh_entsize
= asect
->entsize
;
3409 if ((asect
->flags
& SEC_STRINGS
) != 0)
3410 this_hdr
->sh_flags
|= SHF_STRINGS
;
3411 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3412 this_hdr
->sh_flags
|= SHF_GROUP
;
3413 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3415 this_hdr
->sh_flags
|= SHF_TLS
;
3416 if (asect
->size
== 0
3417 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3419 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3421 this_hdr
->sh_size
= 0;
3424 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3425 if (this_hdr
->sh_size
!= 0)
3426 this_hdr
->sh_type
= SHT_NOBITS
;
3430 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3431 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3433 /* If the section has relocs, set up a section header for the
3434 SHT_REL[A] section. If two relocation sections are required for
3435 this section, it is up to the processor-specific back-end to
3436 create the other. */
3437 if ((asect
->flags
& SEC_RELOC
) != 0)
3439 /* When doing a relocatable link, create both REL and RELA sections if
3442 /* Do the normal setup if we wouldn't create any sections here. */
3443 && esd
->rel
.count
+ esd
->rela
.count
> 0
3444 && (bfd_link_relocatable (arg
->link_info
)
3445 || arg
->link_info
->emitrelocations
))
3447 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3448 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3449 false, delay_st_name_p
))
3454 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3455 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3456 true, delay_st_name_p
))
3462 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3464 ? &esd
->rela
: &esd
->rel
),
3474 /* Check for processor-specific section types. */
3475 sh_type
= this_hdr
->sh_type
;
3476 if (bed
->elf_backend_fake_sections
3477 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3483 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3485 /* Don't change the header type from NOBITS if we are being
3486 called for objcopy --only-keep-debug. */
3487 this_hdr
->sh_type
= sh_type
;
3491 /* Fill in the contents of a SHT_GROUP section. Called from
3492 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3493 when ELF targets use the generic linker, ld. Called for ld -r
3494 from bfd_elf_final_link. */
3497 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3499 bool *failedptr
= (bool *) failedptrarg
;
3500 asection
*elt
, *first
;
3504 /* Ignore linker created group section. See elfNN_ia64_object_p in
3506 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3511 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3513 unsigned long symindx
= 0;
3515 /* elf_group_id will have been set up by objcopy and the
3517 if (elf_group_id (sec
) != NULL
)
3518 symindx
= elf_group_id (sec
)->udata
.i
;
3522 /* If called from the assembler, swap_out_syms will have set up
3524 PR 25699: A corrupt input file could contain bogus group info. */
3525 if (elf_section_syms (abfd
) == NULL
)
3530 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3532 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3534 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3536 /* The ELF backend linker sets sh_info to -2 when the group
3537 signature symbol is global, and thus the index can't be
3538 set until all local symbols are output. */
3540 struct bfd_elf_section_data
*sec_data
;
3541 unsigned long symndx
;
3542 unsigned long extsymoff
;
3543 struct elf_link_hash_entry
*h
;
3545 /* The point of this little dance to the first SHF_GROUP section
3546 then back to the SHT_GROUP section is that this gets us to
3547 the SHT_GROUP in the input object. */
3548 igroup
= elf_sec_group (elf_next_in_group (sec
));
3549 sec_data
= elf_section_data (igroup
);
3550 symndx
= sec_data
->this_hdr
.sh_info
;
3552 if (!elf_bad_symtab (igroup
->owner
))
3554 Elf_Internal_Shdr
*symtab_hdr
;
3556 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3557 extsymoff
= symtab_hdr
->sh_info
;
3559 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3560 while (h
->root
.type
== bfd_link_hash_indirect
3561 || h
->root
.type
== bfd_link_hash_warning
)
3562 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3564 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3567 /* The contents won't be allocated for "ld -r" or objcopy. */
3569 if (sec
->contents
== NULL
)
3572 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3574 /* Arrange for the section to be written out. */
3575 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3576 if (sec
->contents
== NULL
)
3583 loc
= sec
->contents
+ sec
->size
;
3585 /* Get the pointer to the first section in the group that gas
3586 squirreled away here. objcopy arranges for this to be set to the
3587 start of the input section group. */
3588 first
= elt
= elf_next_in_group (sec
);
3590 /* First element is a flag word. Rest of section is elf section
3591 indices for all the sections of the group. Write them backwards
3592 just to keep the group in the same order as given in .section
3593 directives, not that it matters. */
3600 s
= s
->output_section
;
3602 && !bfd_is_abs_section (s
))
3604 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3605 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3607 if (elf_sec
->rel
.hdr
!= NULL
3609 || (input_elf_sec
->rel
.hdr
!= NULL
3610 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3612 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3614 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3616 if (elf_sec
->rela
.hdr
!= NULL
3618 || (input_elf_sec
->rela
.hdr
!= NULL
3619 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3621 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3623 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3626 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3628 elt
= elf_next_in_group (elt
);
3634 BFD_ASSERT (loc
== sec
->contents
);
3636 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3639 /* Given NAME, the name of a relocation section stripped of its
3640 .rel/.rela prefix, return the section in ABFD to which the
3641 relocations apply. */
3644 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3646 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3647 section likely apply to .got.plt or .got section. */
3648 if (get_elf_backend_data (abfd
)->want_got_plt
3649 && strcmp (name
, ".plt") == 0)
3654 sec
= bfd_get_section_by_name (abfd
, name
);
3660 return bfd_get_section_by_name (abfd
, name
);
3663 /* Return the section to which RELOC_SEC applies. */
3666 elf_get_reloc_section (asection
*reloc_sec
)
3671 const struct elf_backend_data
*bed
;
3673 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3674 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3677 /* We look up the section the relocs apply to by name. */
3678 name
= reloc_sec
->name
;
3679 if (!startswith (name
, ".rel"))
3682 if (type
== SHT_RELA
&& *name
++ != 'a')
3685 abfd
= reloc_sec
->owner
;
3686 bed
= get_elf_backend_data (abfd
);
3687 return bed
->get_reloc_section (abfd
, name
);
3690 /* Assign all ELF section numbers. The dummy first section is handled here
3691 too. The link/info pointers for the standard section types are filled
3692 in here too, while we're at it. LINK_INFO will be 0 when arriving
3693 here for objcopy, and when using the generic ELF linker. */
3696 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3698 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3700 unsigned int section_number
;
3701 Elf_Internal_Shdr
**i_shdrp
;
3702 struct bfd_elf_section_data
*d
;
3708 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3710 /* SHT_GROUP sections are in relocatable files only. */
3711 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3713 size_t reloc_count
= 0;
3715 /* Put SHT_GROUP sections first. */
3716 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3718 d
= elf_section_data (sec
);
3720 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3722 if (sec
->flags
& SEC_LINKER_CREATED
)
3724 /* Remove the linker created SHT_GROUP sections. */
3725 bfd_section_list_remove (abfd
, sec
);
3726 abfd
->section_count
--;
3729 d
->this_idx
= section_number
++;
3732 /* Count relocations. */
3733 reloc_count
+= sec
->reloc_count
;
3736 /* Clear HAS_RELOC if there are no relocations. */
3737 if (reloc_count
== 0)
3738 abfd
->flags
&= ~HAS_RELOC
;
3741 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3743 d
= elf_section_data (sec
);
3745 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3746 d
->this_idx
= section_number
++;
3747 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3748 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3751 d
->rel
.idx
= section_number
++;
3752 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3753 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3760 d
->rela
.idx
= section_number
++;
3761 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3762 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3768 need_symtab
= (bfd_get_symcount (abfd
) > 0
3769 || (link_info
== NULL
3770 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3774 elf_onesymtab (abfd
) = section_number
++;
3775 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3776 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3778 elf_section_list
*entry
;
3780 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3782 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3783 entry
->ndx
= section_number
++;
3784 elf_symtab_shndx_list (abfd
) = entry
;
3786 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3787 ".symtab_shndx", false);
3788 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3791 elf_strtab_sec (abfd
) = section_number
++;
3792 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3795 elf_shstrtab_sec (abfd
) = section_number
++;
3796 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3797 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3799 if (section_number
>= SHN_LORESERVE
)
3801 /* xgettext:c-format */
3802 _bfd_error_handler (_("%pB: too many sections: %u"),
3803 abfd
, section_number
);
3807 elf_numsections (abfd
) = section_number
;
3808 elf_elfheader (abfd
)->e_shnum
= section_number
;
3810 /* Set up the list of section header pointers, in agreement with the
3812 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
3813 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc (abfd
, amt
);
3814 if (i_shdrp
== NULL
)
3817 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3818 sizeof (Elf_Internal_Shdr
));
3819 if (i_shdrp
[0] == NULL
)
3821 bfd_release (abfd
, i_shdrp
);
3825 elf_elfsections (abfd
) = i_shdrp
;
3827 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3830 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3831 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3833 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3834 BFD_ASSERT (entry
!= NULL
);
3835 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3836 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3838 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3839 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3842 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3846 d
= elf_section_data (sec
);
3848 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3849 if (d
->rel
.idx
!= 0)
3850 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3851 if (d
->rela
.idx
!= 0)
3852 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3854 /* Fill in the sh_link and sh_info fields while we're at it. */
3856 /* sh_link of a reloc section is the section index of the symbol
3857 table. sh_info is the section index of the section to which
3858 the relocation entries apply. */
3859 if (d
->rel
.idx
!= 0)
3861 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3862 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3863 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3865 if (d
->rela
.idx
!= 0)
3867 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3868 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3869 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3872 /* We need to set up sh_link for SHF_LINK_ORDER. */
3873 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3875 s
= elf_linked_to_section (sec
);
3876 /* We can now have a NULL linked section pointer.
3877 This happens when the sh_link field is 0, which is done
3878 when a linked to section is discarded but the linking
3879 section has been retained for some reason. */
3882 /* Check discarded linkonce section. */
3883 if (discarded_section (s
))
3887 /* xgettext:c-format */
3888 (_("%pB: sh_link of section `%pA' points to"
3889 " discarded section `%pA' of `%pB'"),
3890 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3891 /* Point to the kept section if it has the same
3892 size as the discarded one. */
3893 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3896 bfd_set_error (bfd_error_bad_value
);
3901 /* Handle objcopy. */
3902 else if (s
->output_section
== NULL
)
3905 /* xgettext:c-format */
3906 (_("%pB: sh_link of section `%pA' points to"
3907 " removed section `%pA' of `%pB'"),
3908 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3909 bfd_set_error (bfd_error_bad_value
);
3912 s
= s
->output_section
;
3913 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3917 switch (d
->this_hdr
.sh_type
)
3921 /* A reloc section which we are treating as a normal BFD
3922 section. sh_link is the section index of the symbol
3923 table. sh_info is the section index of the section to
3924 which the relocation entries apply. We assume that an
3925 allocated reloc section uses the dynamic symbol table.
3926 FIXME: How can we be sure? */
3927 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3929 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3931 s
= elf_get_reloc_section (sec
);
3934 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3935 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3940 /* We assume that a section named .stab*str is a stabs
3941 string section. We look for a section with the same name
3942 but without the trailing ``str'', and set its sh_link
3943 field to point to this section. */
3944 if (startswith (sec
->name
, ".stab")
3945 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3950 len
= strlen (sec
->name
);
3951 alc
= (char *) bfd_malloc (len
- 2);
3954 memcpy (alc
, sec
->name
, len
- 3);
3955 alc
[len
- 3] = '\0';
3956 s
= bfd_get_section_by_name (abfd
, alc
);
3960 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3962 /* This is a .stab section. */
3963 elf_section_data (s
)->this_hdr
.sh_entsize
= 12;
3970 case SHT_GNU_verneed
:
3971 case SHT_GNU_verdef
:
3972 /* sh_link is the section header index of the string table
3973 used for the dynamic entries, or the symbol table, or the
3975 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3977 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3980 case SHT_GNU_LIBLIST
:
3981 /* sh_link is the section header index of the prelink library
3982 list used for the dynamic entries, or the symbol table, or
3983 the version strings. */
3984 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3985 ? ".dynstr" : ".gnu.libstr");
3987 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3992 case SHT_GNU_versym
:
3993 /* sh_link is the section header index of the symbol table
3994 this hash table or version table is for. */
3995 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3997 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4001 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
4005 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
4006 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
4007 debug section name from .debug_* to .zdebug_* if needed. */
4013 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4015 /* If the backend has a special mapping, use it. */
4016 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4017 if (bed
->elf_backend_sym_is_global
)
4018 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4020 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4021 || bfd_is_und_section (bfd_asymbol_section (sym
))
4022 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4025 /* Filter global symbols of ABFD to include in the import library. All
4026 SYMCOUNT symbols of ABFD can be examined from their pointers in
4027 SYMS. Pointers of symbols to keep should be stored contiguously at
4028 the beginning of that array.
4030 Returns the number of symbols to keep. */
4033 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4034 asymbol
**syms
, long symcount
)
4036 long src_count
, dst_count
= 0;
4038 for (src_count
= 0; src_count
< symcount
; src_count
++)
4040 asymbol
*sym
= syms
[src_count
];
4041 char *name
= (char *) bfd_asymbol_name (sym
);
4042 struct bfd_link_hash_entry
*h
;
4044 if (!sym_is_global (abfd
, sym
))
4047 h
= bfd_link_hash_lookup (info
->hash
, name
, false, false, false);
4050 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4052 if (h
->linker_def
|| h
->ldscript_def
)
4055 syms
[dst_count
++] = sym
;
4058 syms
[dst_count
] = NULL
;
4063 /* Don't output section symbols for sections that are not going to be
4064 output, that are duplicates or there is no BFD section. */
4067 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4069 elf_symbol_type
*type_ptr
;
4074 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4077 /* Ignore the section symbol if it isn't used. */
4078 if ((sym
->flags
& BSF_SECTION_SYM_USED
) == 0)
4081 if (sym
->section
== NULL
)
4084 type_ptr
= elf_symbol_from (sym
);
4085 return ((type_ptr
!= NULL
4086 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4087 && bfd_is_abs_section (sym
->section
))
4088 || !(sym
->section
->owner
== abfd
4089 || (sym
->section
->output_section
!= NULL
4090 && sym
->section
->output_section
->owner
== abfd
4091 && sym
->section
->output_offset
== 0)
4092 || bfd_is_abs_section (sym
->section
)));
4095 /* Map symbol from it's internal number to the external number, moving
4096 all local symbols to be at the head of the list. */
4099 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4101 unsigned int symcount
= bfd_get_symcount (abfd
);
4102 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4103 asymbol
**sect_syms
;
4104 unsigned int num_locals
= 0;
4105 unsigned int num_globals
= 0;
4106 unsigned int num_locals2
= 0;
4107 unsigned int num_globals2
= 0;
4108 unsigned int max_index
= 0;
4115 fprintf (stderr
, "elf_map_symbols\n");
4119 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4121 if (max_index
< asect
->index
)
4122 max_index
= asect
->index
;
4126 amt
= max_index
* sizeof (asymbol
*);
4127 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
4128 if (sect_syms
== NULL
)
4130 elf_section_syms (abfd
) = sect_syms
;
4131 elf_num_section_syms (abfd
) = max_index
;
4133 /* Init sect_syms entries for any section symbols we have already
4134 decided to output. */
4135 for (idx
= 0; idx
< symcount
; idx
++)
4137 asymbol
*sym
= syms
[idx
];
4139 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4141 && !ignore_section_sym (abfd
, sym
)
4142 && !bfd_is_abs_section (sym
->section
))
4144 asection
*sec
= sym
->section
;
4146 if (sec
->owner
!= abfd
)
4147 sec
= sec
->output_section
;
4149 sect_syms
[sec
->index
] = syms
[idx
];
4153 /* Classify all of the symbols. */
4154 for (idx
= 0; idx
< symcount
; idx
++)
4156 if (sym_is_global (abfd
, syms
[idx
]))
4158 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4162 /* We will be adding a section symbol for each normal BFD section. Most
4163 sections will already have a section symbol in outsymbols, but
4164 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4165 at least in that case. */
4166 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4168 asymbol
*sym
= asect
->symbol
;
4169 /* Don't include ignored section symbols. */
4170 if (!ignore_section_sym (abfd
, sym
)
4171 && sect_syms
[asect
->index
] == NULL
)
4173 if (!sym_is_global (abfd
, asect
->symbol
))
4180 /* Now sort the symbols so the local symbols are first. */
4181 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
4182 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
4183 if (new_syms
== NULL
)
4186 for (idx
= 0; idx
< symcount
; idx
++)
4188 asymbol
*sym
= syms
[idx
];
4191 if (sym_is_global (abfd
, sym
))
4192 i
= num_locals
+ num_globals2
++;
4193 /* Don't include ignored section symbols. */
4194 else if (!ignore_section_sym (abfd
, sym
))
4199 sym
->udata
.i
= i
+ 1;
4201 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4203 asymbol
*sym
= asect
->symbol
;
4204 if (!ignore_section_sym (abfd
, sym
)
4205 && sect_syms
[asect
->index
] == NULL
)
4209 sect_syms
[asect
->index
] = sym
;
4210 if (!sym_is_global (abfd
, sym
))
4213 i
= num_locals
+ num_globals2
++;
4215 sym
->udata
.i
= i
+ 1;
4219 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4221 *pnum_locals
= num_locals
;
4225 /* Align to the maximum file alignment that could be required for any
4226 ELF data structure. */
4228 static inline file_ptr
4229 align_file_position (file_ptr off
, int align
)
4231 return (off
+ align
- 1) & ~(align
- 1);
4234 /* Assign a file position to a section, optionally aligning to the
4235 required section alignment. */
4238 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4242 if (align
&& i_shdrp
->sh_addralign
> 1)
4243 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4244 i_shdrp
->sh_offset
= offset
;
4245 if (i_shdrp
->bfd_section
!= NULL
)
4246 i_shdrp
->bfd_section
->filepos
= offset
;
4247 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4248 offset
+= i_shdrp
->sh_size
;
4252 /* Compute the file positions we are going to put the sections at, and
4253 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4254 is not NULL, this is being called by the ELF backend linker. */
4257 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4258 struct bfd_link_info
*link_info
)
4260 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4261 struct fake_section_arg fsargs
;
4263 struct elf_strtab_hash
*strtab
= NULL
;
4264 Elf_Internal_Shdr
*shstrtab_hdr
;
4267 if (abfd
->output_has_begun
)
4270 /* Do any elf backend specific processing first. */
4271 if (bed
->elf_backend_begin_write_processing
)
4272 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4274 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4277 fsargs
.failed
= false;
4278 fsargs
.link_info
= link_info
;
4279 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4283 if (!assign_section_numbers (abfd
, link_info
))
4286 /* The backend linker builds symbol table information itself. */
4287 need_symtab
= (link_info
== NULL
4288 && (bfd_get_symcount (abfd
) > 0
4289 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4293 /* Non-zero if doing a relocatable link. */
4294 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4296 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
, link_info
))
4301 if (link_info
== NULL
)
4303 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4308 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4309 /* sh_name was set in init_file_header. */
4310 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4311 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4312 shstrtab_hdr
->sh_addr
= 0;
4313 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4314 shstrtab_hdr
->sh_entsize
= 0;
4315 shstrtab_hdr
->sh_link
= 0;
4316 shstrtab_hdr
->sh_info
= 0;
4317 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4318 shstrtab_hdr
->sh_addralign
= 1;
4320 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4326 Elf_Internal_Shdr
*hdr
;
4328 off
= elf_next_file_pos (abfd
);
4330 hdr
= & elf_symtab_hdr (abfd
);
4331 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4333 if (elf_symtab_shndx_list (abfd
) != NULL
)
4335 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4336 if (hdr
->sh_size
!= 0)
4337 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4338 /* FIXME: What about other symtab_shndx sections in the list ? */
4341 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4342 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
4344 elf_next_file_pos (abfd
) = off
;
4346 /* Now that we know where the .strtab section goes, write it
4348 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4349 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4351 _bfd_elf_strtab_free (strtab
);
4354 abfd
->output_has_begun
= true;
4359 /* Make an initial estimate of the size of the program header. If we
4360 get the number wrong here, we'll redo section placement. */
4362 static bfd_size_type
4363 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4367 const struct elf_backend_data
*bed
;
4369 /* Assume we will need exactly two PT_LOAD segments: one for text
4370 and one for data. */
4373 s
= bfd_get_section_by_name (abfd
, ".interp");
4374 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4376 /* If we have a loadable interpreter section, we need a
4377 PT_INTERP segment. In this case, assume we also need a
4378 PT_PHDR segment, although that may not be true for all
4383 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4385 /* We need a PT_DYNAMIC segment. */
4389 if (info
!= NULL
&& info
->relro
)
4391 /* We need a PT_GNU_RELRO segment. */
4395 if (elf_eh_frame_hdr (abfd
))
4397 /* We need a PT_GNU_EH_FRAME segment. */
4401 if (elf_stack_flags (abfd
))
4403 /* We need a PT_GNU_STACK segment. */
4407 s
= bfd_get_section_by_name (abfd
,
4408 NOTE_GNU_PROPERTY_SECTION_NAME
);
4409 if (s
!= NULL
&& s
->size
!= 0)
4411 /* We need a PT_GNU_PROPERTY segment. */
4415 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4417 if ((s
->flags
& SEC_LOAD
) != 0
4418 && elf_section_type (s
) == SHT_NOTE
)
4420 unsigned int alignment_power
;
4421 /* We need a PT_NOTE segment. */
4423 /* Try to create just one PT_NOTE segment for all adjacent
4424 loadable SHT_NOTE sections. gABI requires that within a
4425 PT_NOTE segment (and also inside of each SHT_NOTE section)
4426 each note should have the same alignment. So we check
4427 whether the sections are correctly aligned. */
4428 alignment_power
= s
->alignment_power
;
4429 while (s
->next
!= NULL
4430 && s
->next
->alignment_power
== alignment_power
4431 && (s
->next
->flags
& SEC_LOAD
) != 0
4432 && elf_section_type (s
->next
) == SHT_NOTE
)
4437 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4439 if (s
->flags
& SEC_THREAD_LOCAL
)
4441 /* We need a PT_TLS segment. */
4447 bed
= get_elf_backend_data (abfd
);
4449 if ((abfd
->flags
& D_PAGED
) != 0
4450 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4452 /* Add a PT_GNU_MBIND segment for each mbind section. */
4453 bfd_vma commonpagesize
;
4454 unsigned int page_align_power
;
4457 commonpagesize
= info
->commonpagesize
;
4459 commonpagesize
= bed
->commonpagesize
;
4460 page_align_power
= bfd_log2 (commonpagesize
);
4461 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4462 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4464 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4467 /* xgettext:c-format */
4468 (_("%pB: GNU_MBIND section `%pA' has invalid "
4469 "sh_info field: %d"),
4470 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4473 /* Align mbind section to page size. */
4474 if (s
->alignment_power
< page_align_power
)
4475 s
->alignment_power
= page_align_power
;
4480 /* Let the backend count up any program headers it might need. */
4481 if (bed
->elf_backend_additional_program_headers
)
4485 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4491 return segs
* bed
->s
->sizeof_phdr
;
4494 /* Find the segment that contains the output_section of section. */
4497 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4499 struct elf_segment_map
*m
;
4500 Elf_Internal_Phdr
*p
;
4502 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4508 for (i
= m
->count
- 1; i
>= 0; i
--)
4509 if (m
->sections
[i
] == section
)
4516 /* Create a mapping from a set of sections to a program segment. */
4518 static struct elf_segment_map
*
4519 make_mapping (bfd
*abfd
,
4520 asection
**sections
,
4525 struct elf_segment_map
*m
;
4530 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4531 amt
+= (to
- from
) * sizeof (asection
*);
4532 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4536 m
->p_type
= PT_LOAD
;
4537 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4538 m
->sections
[i
- from
] = *hdrpp
;
4539 m
->count
= to
- from
;
4541 if (from
== 0 && phdr
)
4543 /* Include the headers in the first PT_LOAD segment. */
4544 m
->includes_filehdr
= 1;
4545 m
->includes_phdrs
= 1;
4551 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4554 struct elf_segment_map
*
4555 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4557 struct elf_segment_map
*m
;
4559 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4560 sizeof (struct elf_segment_map
));
4564 m
->p_type
= PT_DYNAMIC
;
4566 m
->sections
[0] = dynsec
;
4571 /* Possibly add or remove segments from the segment map. */
4574 elf_modify_segment_map (bfd
*abfd
,
4575 struct bfd_link_info
*info
,
4576 bool remove_empty_load
)
4578 struct elf_segment_map
**m
;
4579 const struct elf_backend_data
*bed
;
4581 /* The placement algorithm assumes that non allocated sections are
4582 not in PT_LOAD segments. We ensure this here by removing such
4583 sections from the segment map. We also remove excluded
4584 sections. Finally, any PT_LOAD segment without sections is
4586 m
= &elf_seg_map (abfd
);
4589 unsigned int i
, new_count
;
4591 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4593 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4594 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4595 || (*m
)->p_type
!= PT_LOAD
))
4597 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4601 (*m
)->count
= new_count
;
4603 if (remove_empty_load
4604 && (*m
)->p_type
== PT_LOAD
4606 && !(*m
)->includes_phdrs
)
4612 bed
= get_elf_backend_data (abfd
);
4613 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4615 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4622 #define IS_TBSS(s) \
4623 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4625 /* Set up a mapping from BFD sections to program segments. */
4628 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4631 struct elf_segment_map
*m
;
4632 asection
**sections
= NULL
;
4633 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4636 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4639 info
->user_phdrs
= !no_user_phdrs
;
4641 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4645 struct elf_segment_map
*mfirst
;
4646 struct elf_segment_map
**pm
;
4649 unsigned int hdr_index
;
4650 bfd_vma maxpagesize
;
4652 bool phdr_in_segment
;
4655 unsigned int tls_count
= 0;
4656 asection
*first_tls
= NULL
;
4657 asection
*first_mbind
= NULL
;
4658 asection
*dynsec
, *eh_frame_hdr
;
4660 bfd_vma addr_mask
, wrap_to
= 0; /* Bytes. */
4661 bfd_size_type phdr_size
; /* Octets/bytes. */
4662 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
4664 /* Select the allocated sections, and sort them. */
4666 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
4667 sections
= (asection
**) bfd_malloc (amt
);
4668 if (sections
== NULL
)
4671 /* Calculate top address, avoiding undefined behaviour of shift
4672 left operator when shift count is equal to size of type
4674 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4675 addr_mask
= (addr_mask
<< 1) + 1;
4678 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4680 if ((s
->flags
& SEC_ALLOC
) != 0)
4682 /* target_index is unused until bfd_elf_final_link
4683 starts output of section symbols. Use it to make
4685 s
->target_index
= i
;
4688 /* A wrapping section potentially clashes with header. */
4689 if (((s
->lma
+ s
->size
/ opb
) & addr_mask
) < (s
->lma
& addr_mask
))
4690 wrap_to
= (s
->lma
+ s
->size
/ opb
) & addr_mask
;
4693 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4696 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4698 phdr_size
= elf_program_header_size (abfd
);
4699 if (phdr_size
== (bfd_size_type
) -1)
4700 phdr_size
= get_program_header_size (abfd
, info
);
4701 phdr_size
+= bed
->s
->sizeof_ehdr
;
4702 /* phdr_size is compared to LMA values which are in bytes. */
4705 maxpagesize
= info
->maxpagesize
;
4707 maxpagesize
= bed
->maxpagesize
;
4708 if (maxpagesize
== 0)
4710 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4712 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4713 >= (phdr_size
& (maxpagesize
- 1))))
4714 /* For compatibility with old scripts that may not be using
4715 SIZEOF_HEADERS, add headers when it looks like space has
4716 been left for them. */
4717 phdr_in_segment
= true;
4719 /* Build the mapping. */
4723 /* If we have a .interp section, then create a PT_PHDR segment for
4724 the program headers and a PT_INTERP segment for the .interp
4726 s
= bfd_get_section_by_name (abfd
, ".interp");
4727 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4729 amt
= sizeof (struct elf_segment_map
);
4730 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4734 m
->p_type
= PT_PHDR
;
4736 m
->p_flags_valid
= 1;
4737 m
->includes_phdrs
= 1;
4738 phdr_in_segment
= true;
4742 amt
= sizeof (struct elf_segment_map
);
4743 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4747 m
->p_type
= PT_INTERP
;
4755 /* Look through the sections. We put sections in the same program
4756 segment when the start of the second section can be placed within
4757 a few bytes of the end of the first section. */
4763 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4765 && (dynsec
->flags
& SEC_LOAD
) == 0)
4768 if ((abfd
->flags
& D_PAGED
) == 0)
4769 phdr_in_segment
= false;
4771 /* Deal with -Ttext or something similar such that the first section
4772 is not adjacent to the program headers. This is an
4773 approximation, since at this point we don't know exactly how many
4774 program headers we will need. */
4775 if (phdr_in_segment
&& count
> 0)
4777 bfd_vma phdr_lma
; /* Bytes. */
4778 bool separate_phdr
= false;
4780 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4782 && info
->separate_code
4783 && (sections
[0]->flags
& SEC_CODE
) != 0)
4785 /* If data sections should be separate from code and
4786 thus not executable, and the first section is
4787 executable then put the file and program headers in
4788 their own PT_LOAD. */
4789 separate_phdr
= true;
4790 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4791 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4793 /* The file and program headers are currently on the
4794 same page as the first section. Put them on the
4795 previous page if we can. */
4796 if (phdr_lma
>= maxpagesize
)
4797 phdr_lma
-= maxpagesize
;
4799 separate_phdr
= false;
4802 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4803 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4804 /* If file and program headers would be placed at the end
4805 of memory then it's probably better to omit them. */
4806 phdr_in_segment
= false;
4807 else if (phdr_lma
< wrap_to
)
4808 /* If a section wraps around to where we'll be placing
4809 file and program headers, then the headers will be
4811 phdr_in_segment
= false;
4812 else if (separate_phdr
)
4814 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4817 m
->p_paddr
= phdr_lma
* opb
;
4819 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4820 m
->p_paddr_valid
= 1;
4823 phdr_in_segment
= false;
4827 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4834 /* See if this section and the last one will fit in the same
4837 if (last_hdr
== NULL
)
4839 /* If we don't have a segment yet, then we don't need a new
4840 one (we build the last one after this loop). */
4841 new_segment
= false;
4843 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4845 /* If this section has a different relation between the
4846 virtual address and the load address, then we need a new
4850 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4851 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4853 /* If this section has a load address that makes it overlap
4854 the previous section, then we need a new segment. */
4857 else if ((abfd
->flags
& D_PAGED
) != 0
4858 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4859 == (hdr
->lma
& -maxpagesize
)))
4861 /* If we are demand paged then we can't map two disk
4862 pages onto the same memory page. */
4863 new_segment
= false;
4865 /* In the next test we have to be careful when last_hdr->lma is close
4866 to the end of the address space. If the aligned address wraps
4867 around to the start of the address space, then there are no more
4868 pages left in memory and it is OK to assume that the current
4869 section can be included in the current segment. */
4870 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4871 + maxpagesize
> last_hdr
->lma
)
4872 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4873 + maxpagesize
<= hdr
->lma
))
4875 /* If putting this section in this segment would force us to
4876 skip a page in the segment, then we need a new segment. */
4879 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4880 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4882 /* We don't want to put a loaded section after a
4883 nonloaded (ie. bss style) section in the same segment
4884 as that will force the non-loaded section to be loaded.
4885 Consider .tbss sections as loaded for this purpose. */
4888 else if ((abfd
->flags
& D_PAGED
) == 0)
4890 /* If the file is not demand paged, which means that we
4891 don't require the sections to be correctly aligned in the
4892 file, then there is no other reason for a new segment. */
4893 new_segment
= false;
4895 else if (info
!= NULL
4896 && info
->separate_code
4897 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4902 && (hdr
->flags
& SEC_READONLY
) == 0)
4904 /* We don't want to put a writable section in a read only
4910 /* Otherwise, we can use the same segment. */
4911 new_segment
= false;
4914 /* Allow interested parties a chance to override our decision. */
4915 if (last_hdr
!= NULL
4917 && info
->callbacks
->override_segment_assignment
!= NULL
)
4919 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4925 if ((hdr
->flags
& SEC_READONLY
) == 0)
4927 if ((hdr
->flags
& SEC_CODE
) != 0)
4930 /* .tbss sections effectively have zero size. */
4931 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4935 /* We need a new program segment. We must create a new program
4936 header holding all the sections from hdr_index until hdr. */
4938 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4945 if ((hdr
->flags
& SEC_READONLY
) == 0)
4950 if ((hdr
->flags
& SEC_CODE
) == 0)
4956 /* .tbss sections effectively have zero size. */
4957 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4959 phdr_in_segment
= false;
4962 /* Create a final PT_LOAD program segment, but not if it's just
4964 if (last_hdr
!= NULL
4965 && (i
- hdr_index
!= 1
4966 || !IS_TBSS (last_hdr
)))
4968 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4976 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4979 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4986 /* For each batch of consecutive loadable SHT_NOTE sections,
4987 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4988 because if we link together nonloadable .note sections and
4989 loadable .note sections, we will generate two .note sections
4990 in the output file. */
4991 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4993 if ((s
->flags
& SEC_LOAD
) != 0
4994 && elf_section_type (s
) == SHT_NOTE
)
4997 unsigned int alignment_power
= s
->alignment_power
;
5000 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
5002 if (s2
->next
->alignment_power
== alignment_power
5003 && (s2
->next
->flags
& SEC_LOAD
) != 0
5004 && elf_section_type (s2
->next
) == SHT_NOTE
5005 && align_power (s2
->lma
+ s2
->size
/ opb
,
5012 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5013 amt
+= count
* sizeof (asection
*);
5014 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5018 m
->p_type
= PT_NOTE
;
5022 m
->sections
[m
->count
- count
--] = s
;
5023 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5026 m
->sections
[m
->count
- 1] = s
;
5027 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5031 if (s
->flags
& SEC_THREAD_LOCAL
)
5037 if (first_mbind
== NULL
5038 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5042 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5045 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5046 amt
+= tls_count
* sizeof (asection
*);
5047 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5052 m
->count
= tls_count
;
5053 /* Mandated PF_R. */
5055 m
->p_flags_valid
= 1;
5057 for (i
= 0; i
< tls_count
; ++i
)
5059 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5062 (_("%pB: TLS sections are not adjacent:"), abfd
);
5065 while (i
< tls_count
)
5067 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5069 _bfd_error_handler (_(" TLS: %pA"), s
);
5073 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5076 bfd_set_error (bfd_error_bad_value
);
5088 && (abfd
->flags
& D_PAGED
) != 0
5089 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5090 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5091 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5092 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5094 /* Mandated PF_R. */
5095 unsigned long p_flags
= PF_R
;
5096 if ((s
->flags
& SEC_READONLY
) == 0)
5098 if ((s
->flags
& SEC_CODE
) != 0)
5101 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5102 m
= bfd_zalloc (abfd
, amt
);
5106 m
->p_type
= (PT_GNU_MBIND_LO
5107 + elf_section_data (s
)->this_hdr
.sh_info
);
5109 m
->p_flags_valid
= 1;
5111 m
->p_flags
= p_flags
;
5117 s
= bfd_get_section_by_name (abfd
,
5118 NOTE_GNU_PROPERTY_SECTION_NAME
);
5119 if (s
!= NULL
&& s
->size
!= 0)
5121 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5122 m
= bfd_zalloc (abfd
, amt
);
5126 m
->p_type
= PT_GNU_PROPERTY
;
5128 m
->p_flags_valid
= 1;
5135 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5137 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5138 if (eh_frame_hdr
!= NULL
5139 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5141 amt
= sizeof (struct elf_segment_map
);
5142 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5146 m
->p_type
= PT_GNU_EH_FRAME
;
5148 m
->sections
[0] = eh_frame_hdr
->output_section
;
5154 if (elf_stack_flags (abfd
))
5156 amt
= sizeof (struct elf_segment_map
);
5157 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5161 m
->p_type
= PT_GNU_STACK
;
5162 m
->p_flags
= elf_stack_flags (abfd
);
5163 m
->p_align
= bed
->stack_align
;
5164 m
->p_flags_valid
= 1;
5165 m
->p_align_valid
= m
->p_align
!= 0;
5166 if (info
->stacksize
> 0)
5168 m
->p_size
= info
->stacksize
;
5169 m
->p_size_valid
= 1;
5176 if (info
!= NULL
&& info
->relro
)
5178 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5180 if (m
->p_type
== PT_LOAD
5182 && m
->sections
[0]->vma
>= info
->relro_start
5183 && m
->sections
[0]->vma
< info
->relro_end
)
5186 while (--i
!= (unsigned) -1)
5188 if (m
->sections
[i
]->size
> 0
5189 && (m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5190 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5194 if (i
!= (unsigned) -1)
5199 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5202 amt
= sizeof (struct elf_segment_map
);
5203 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5207 m
->p_type
= PT_GNU_RELRO
;
5214 elf_seg_map (abfd
) = mfirst
;
5217 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5220 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5222 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5231 /* Sort sections by address. */
5234 elf_sort_sections (const void *arg1
, const void *arg2
)
5236 const asection
*sec1
= *(const asection
**) arg1
;
5237 const asection
*sec2
= *(const asection
**) arg2
;
5238 bfd_size_type size1
, size2
;
5240 /* Sort by LMA first, since this is the address used to
5241 place the section into a segment. */
5242 if (sec1
->lma
< sec2
->lma
)
5244 else if (sec1
->lma
> sec2
->lma
)
5247 /* Then sort by VMA. Normally the LMA and the VMA will be
5248 the same, and this will do nothing. */
5249 if (sec1
->vma
< sec2
->vma
)
5251 else if (sec1
->vma
> sec2
->vma
)
5254 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5256 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0 \
5264 else if (TOEND (sec2
))
5269 /* Sort by size, to put zero sized sections
5270 before others at the same address. */
5272 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5273 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5280 return sec1
->target_index
- sec2
->target_index
;
5283 /* This qsort comparison functions sorts PT_LOAD segments first and
5284 by p_paddr, for assign_file_positions_for_load_sections. */
5287 elf_sort_segments (const void *arg1
, const void *arg2
)
5289 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5290 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5292 if (m1
->p_type
!= m2
->p_type
)
5294 if (m1
->p_type
== PT_NULL
)
5296 if (m2
->p_type
== PT_NULL
)
5298 return m1
->p_type
< m2
->p_type
? -1 : 1;
5300 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5301 return m1
->includes_filehdr
? -1 : 1;
5302 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5303 return m1
->no_sort_lma
? -1 : 1;
5304 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5306 bfd_vma lma1
, lma2
; /* Octets. */
5308 if (m1
->p_paddr_valid
)
5310 else if (m1
->count
!= 0)
5312 unsigned int opb
= bfd_octets_per_byte (m1
->sections
[0]->owner
,
5314 lma1
= (m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
) * opb
;
5317 if (m2
->p_paddr_valid
)
5319 else if (m2
->count
!= 0)
5321 unsigned int opb
= bfd_octets_per_byte (m2
->sections
[0]->owner
,
5323 lma2
= (m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
) * opb
;
5326 return lma1
< lma2
? -1 : 1;
5328 if (m1
->idx
!= m2
->idx
)
5329 return m1
->idx
< m2
->idx
? -1 : 1;
5333 /* Ian Lance Taylor writes:
5335 We shouldn't be using % with a negative signed number. That's just
5336 not good. We have to make sure either that the number is not
5337 negative, or that the number has an unsigned type. When the types
5338 are all the same size they wind up as unsigned. When file_ptr is a
5339 larger signed type, the arithmetic winds up as signed long long,
5342 What we're trying to say here is something like ``increase OFF by
5343 the least amount that will cause it to be equal to the VMA modulo
5345 /* In other words, something like:
5347 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5348 off_offset = off % bed->maxpagesize;
5349 if (vma_offset < off_offset)
5350 adjustment = vma_offset + bed->maxpagesize - off_offset;
5352 adjustment = vma_offset - off_offset;
5354 which can be collapsed into the expression below. */
5357 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5359 /* PR binutils/16199: Handle an alignment of zero. */
5360 if (maxpagesize
== 0)
5362 return ((vma
- off
) % maxpagesize
);
5366 print_segment_map (const struct elf_segment_map
*m
)
5369 const char *pt
= get_segment_type (m
->p_type
);
5374 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5375 sprintf (buf
, "LOPROC+%7.7x",
5376 (unsigned int) (m
->p_type
- PT_LOPROC
));
5377 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5378 sprintf (buf
, "LOOS+%7.7x",
5379 (unsigned int) (m
->p_type
- PT_LOOS
));
5381 snprintf (buf
, sizeof (buf
), "%8.8x",
5382 (unsigned int) m
->p_type
);
5386 fprintf (stderr
, "%s:", pt
);
5387 for (j
= 0; j
< m
->count
; j
++)
5388 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5394 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5399 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5401 buf
= bfd_zmalloc (len
);
5404 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5409 /* Assign file positions to the sections based on the mapping from
5410 sections to segments. This function also sets up some fields in
5414 assign_file_positions_for_load_sections (bfd
*abfd
,
5415 struct bfd_link_info
*link_info
)
5417 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5418 struct elf_segment_map
*m
;
5419 struct elf_segment_map
*phdr_load_seg
;
5420 Elf_Internal_Phdr
*phdrs
;
5421 Elf_Internal_Phdr
*p
;
5422 file_ptr off
; /* Octets. */
5423 bfd_size_type maxpagesize
;
5424 unsigned int alloc
, actual
;
5426 struct elf_segment_map
**sorted_seg_map
;
5427 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
5429 if (link_info
== NULL
5430 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5434 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5439 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5440 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5444 /* PR binutils/12467. */
5445 elf_elfheader (abfd
)->e_phoff
= 0;
5446 elf_elfheader (abfd
)->e_phentsize
= 0;
5449 elf_elfheader (abfd
)->e_phnum
= alloc
;
5451 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5454 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5458 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5459 BFD_ASSERT (elf_program_header_size (abfd
)
5460 == actual
* bed
->s
->sizeof_phdr
);
5461 BFD_ASSERT (actual
>= alloc
);
5466 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5470 /* We're writing the size in elf_program_header_size (abfd),
5471 see assign_file_positions_except_relocs, so make sure we have
5472 that amount allocated, with trailing space cleared.
5473 The variable alloc contains the computed need, while
5474 elf_program_header_size (abfd) contains the size used for the
5476 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5477 where the layout is forced to according to a larger size in the
5478 last iterations for the testcase ld-elf/header. */
5479 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5480 + alloc
* sizeof (*sorted_seg_map
)));
5481 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5482 elf_tdata (abfd
)->phdr
= phdrs
;
5486 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5488 sorted_seg_map
[j
] = m
;
5489 /* If elf_segment_map is not from map_sections_to_segments, the
5490 sections may not be correctly ordered. NOTE: sorting should
5491 not be done to the PT_NOTE section of a corefile, which may
5492 contain several pseudo-sections artificially created by bfd.
5493 Sorting these pseudo-sections breaks things badly. */
5495 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5496 && m
->p_type
== PT_NOTE
))
5498 for (i
= 0; i
< m
->count
; i
++)
5499 m
->sections
[i
]->target_index
= i
;
5500 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5505 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5509 if ((abfd
->flags
& D_PAGED
) != 0)
5511 if (link_info
!= NULL
)
5512 maxpagesize
= link_info
->maxpagesize
;
5514 maxpagesize
= bed
->maxpagesize
;
5517 /* Sections must map to file offsets past the ELF file header. */
5518 off
= bed
->s
->sizeof_ehdr
;
5519 /* And if one of the PT_LOAD headers doesn't include the program
5520 headers then we'll be mapping program headers in the usual
5521 position after the ELF file header. */
5522 phdr_load_seg
= NULL
;
5523 for (j
= 0; j
< alloc
; j
++)
5525 m
= sorted_seg_map
[j
];
5526 if (m
->p_type
!= PT_LOAD
)
5528 if (m
->includes_phdrs
)
5534 if (phdr_load_seg
== NULL
)
5535 off
+= actual
* bed
->s
->sizeof_phdr
;
5537 for (j
= 0; j
< alloc
; j
++)
5540 bfd_vma off_adjust
; /* Octets. */
5543 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5544 number of sections with contents contributing to both p_filesz
5545 and p_memsz, followed by a number of sections with no contents
5546 that just contribute to p_memsz. In this loop, OFF tracks next
5547 available file offset for PT_LOAD and PT_NOTE segments. */
5548 m
= sorted_seg_map
[j
];
5550 p
->p_type
= m
->p_type
;
5551 p
->p_flags
= m
->p_flags
;
5554 p
->p_vaddr
= m
->p_vaddr_offset
* opb
;
5556 p
->p_vaddr
= (m
->sections
[0]->vma
+ m
->p_vaddr_offset
) * opb
;
5558 if (m
->p_paddr_valid
)
5559 p
->p_paddr
= m
->p_paddr
;
5560 else if (m
->count
== 0)
5563 p
->p_paddr
= (m
->sections
[0]->lma
+ m
->p_vaddr_offset
) * opb
;
5565 if (p
->p_type
== PT_LOAD
5566 && (abfd
->flags
& D_PAGED
) != 0)
5568 /* p_align in demand paged PT_LOAD segments effectively stores
5569 the maximum page size. When copying an executable with
5570 objcopy, we set m->p_align from the input file. Use this
5571 value for maxpagesize rather than bed->maxpagesize, which
5572 may be different. Note that we use maxpagesize for PT_TLS
5573 segment alignment later in this function, so we are relying
5574 on at least one PT_LOAD segment appearing before a PT_TLS
5576 if (m
->p_align_valid
)
5577 maxpagesize
= m
->p_align
;
5579 p
->p_align
= maxpagesize
;
5581 else if (m
->p_align_valid
)
5582 p
->p_align
= m
->p_align
;
5583 else if (m
->count
== 0)
5584 p
->p_align
= 1 << bed
->s
->log_file_align
;
5586 if (m
== phdr_load_seg
)
5588 if (!m
->includes_filehdr
)
5590 off
+= actual
* bed
->s
->sizeof_phdr
;
5593 no_contents
= false;
5595 if (p
->p_type
== PT_LOAD
5598 bfd_size_type align
; /* Bytes. */
5599 unsigned int align_power
= 0;
5601 if (m
->p_align_valid
)
5605 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5607 unsigned int secalign
;
5609 secalign
= bfd_section_alignment (*secpp
);
5610 if (secalign
> align_power
)
5611 align_power
= secalign
;
5613 align
= (bfd_size_type
) 1 << align_power
;
5614 if (align
< maxpagesize
)
5615 align
= maxpagesize
;
5618 for (i
= 0; i
< m
->count
; i
++)
5619 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5620 /* If we aren't making room for this section, then
5621 it must be SHT_NOBITS regardless of what we've
5622 set via struct bfd_elf_special_section. */
5623 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5625 /* Find out whether this segment contains any loadable
5628 for (i
= 0; i
< m
->count
; i
++)
5629 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5631 no_contents
= false;
5635 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
* opb
);
5637 /* Broken hardware and/or kernel require that files do not
5638 map the same page with different permissions on some hppa
5641 && (abfd
->flags
& D_PAGED
) != 0
5642 && bed
->no_page_alias
5643 && (off
& (maxpagesize
- 1)) != 0
5644 && ((off
& -maxpagesize
)
5645 == ((off
+ off_adjust
) & -maxpagesize
)))
5646 off_adjust
+= maxpagesize
;
5650 /* We shouldn't need to align the segment on disk since
5651 the segment doesn't need file space, but the gABI
5652 arguably requires the alignment and glibc ld.so
5653 checks it. So to comply with the alignment
5654 requirement but not waste file space, we adjust
5655 p_offset for just this segment. (OFF_ADJUST is
5656 subtracted from OFF later.) This may put p_offset
5657 past the end of file, but that shouldn't matter. */
5662 /* Make sure the .dynamic section is the first section in the
5663 PT_DYNAMIC segment. */
5664 else if (p
->p_type
== PT_DYNAMIC
5666 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5669 (_("%pB: The first section in the PT_DYNAMIC segment"
5670 " is not the .dynamic section"),
5672 bfd_set_error (bfd_error_bad_value
);
5675 /* Set the note section type to SHT_NOTE. */
5676 else if (p
->p_type
== PT_NOTE
)
5677 for (i
= 0; i
< m
->count
; i
++)
5678 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5680 if (m
->includes_filehdr
)
5682 if (!m
->p_flags_valid
)
5684 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5685 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5686 if (p
->p_type
== PT_LOAD
)
5690 if (p
->p_vaddr
< (bfd_vma
) off
5691 || (!m
->p_paddr_valid
5692 && p
->p_paddr
< (bfd_vma
) off
))
5695 (_("%pB: not enough room for program headers,"
5696 " try linking with -N"),
5698 bfd_set_error (bfd_error_bad_value
);
5702 if (!m
->p_paddr_valid
)
5706 else if (sorted_seg_map
[0]->includes_filehdr
)
5708 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5709 p
->p_vaddr
= filehdr
->p_vaddr
;
5710 if (!m
->p_paddr_valid
)
5711 p
->p_paddr
= filehdr
->p_paddr
;
5715 if (m
->includes_phdrs
)
5717 if (!m
->p_flags_valid
)
5719 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5720 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5721 if (!m
->includes_filehdr
)
5723 if (p
->p_type
== PT_LOAD
)
5725 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5728 p
->p_vaddr
-= off
- p
->p_offset
;
5729 if (!m
->p_paddr_valid
)
5730 p
->p_paddr
-= off
- p
->p_offset
;
5733 else if (phdr_load_seg
!= NULL
)
5735 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5736 bfd_vma phdr_off
= 0; /* Octets. */
5737 if (phdr_load_seg
->includes_filehdr
)
5738 phdr_off
= bed
->s
->sizeof_ehdr
;
5739 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5740 if (!m
->p_paddr_valid
)
5741 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5742 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5745 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5749 if (p
->p_type
== PT_LOAD
5750 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5752 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5757 /* Put meaningless p_offset for PT_LOAD segments
5758 without file contents somewhere within the first
5759 page, in an attempt to not point past EOF. */
5760 bfd_size_type align
= maxpagesize
;
5761 if (align
< p
->p_align
)
5765 p
->p_offset
= off
% align
;
5770 file_ptr adjust
; /* Octets. */
5772 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5774 p
->p_filesz
+= adjust
;
5775 p
->p_memsz
+= adjust
;
5779 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5780 maps. Set filepos for sections in PT_LOAD segments, and in
5781 core files, for sections in PT_NOTE segments.
5782 assign_file_positions_for_non_load_sections will set filepos
5783 for other sections and update p_filesz for other segments. */
5784 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5787 bfd_size_type align
;
5788 Elf_Internal_Shdr
*this_hdr
;
5791 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5792 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5794 if ((p
->p_type
== PT_LOAD
5795 || p
->p_type
== PT_TLS
)
5796 && (this_hdr
->sh_type
!= SHT_NOBITS
5797 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5798 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5799 || p
->p_type
== PT_TLS
))))
5801 bfd_vma p_start
= p
->p_paddr
; /* Octets. */
5802 bfd_vma p_end
= p_start
+ p
->p_memsz
; /* Octets. */
5803 bfd_vma s_start
= sec
->lma
* opb
; /* Octets. */
5804 bfd_vma adjust
= s_start
- p_end
; /* Octets. */
5808 || p_end
< p_start
))
5811 /* xgettext:c-format */
5812 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5813 abfd
, sec
, (uint64_t) s_start
/ opb
,
5814 (uint64_t) p_end
/ opb
);
5816 sec
->lma
= p_end
/ opb
;
5818 p
->p_memsz
+= adjust
;
5820 if (p
->p_type
== PT_LOAD
)
5822 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5825 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5827 /* We have a PROGBITS section following NOBITS ones.
5828 Allocate file space for the NOBITS section(s) and
5830 adjust
= p
->p_memsz
- p
->p_filesz
;
5831 if (!write_zeros (abfd
, off
, adjust
))
5835 /* We only adjust sh_offset in SHT_NOBITS sections
5836 as would seem proper for their address when the
5837 section is first in the segment. sh_offset
5838 doesn't really have any significance for
5839 SHT_NOBITS anyway, apart from a notional position
5840 relative to other sections. Historically we
5841 didn't bother with adjusting sh_offset and some
5842 programs depend on it not being adjusted. See
5843 pr12921 and pr25662. */
5844 if (this_hdr
->sh_type
!= SHT_NOBITS
|| i
== 0)
5847 if (this_hdr
->sh_type
== SHT_NOBITS
)
5848 off_adjust
+= adjust
;
5851 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5852 p
->p_filesz
+= adjust
;
5855 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5857 /* The section at i == 0 is the one that actually contains
5861 this_hdr
->sh_offset
= sec
->filepos
= off
;
5862 off
+= this_hdr
->sh_size
;
5863 p
->p_filesz
= this_hdr
->sh_size
;
5869 /* The rest are fake sections that shouldn't be written. */
5878 if (p
->p_type
== PT_LOAD
)
5880 this_hdr
->sh_offset
= sec
->filepos
= off
;
5881 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5882 off
+= this_hdr
->sh_size
;
5884 else if (this_hdr
->sh_type
== SHT_NOBITS
5885 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5886 && this_hdr
->sh_offset
== 0)
5888 /* This is a .tbss section that didn't get a PT_LOAD.
5889 (See _bfd_elf_map_sections_to_segments "Create a
5890 final PT_LOAD".) Set sh_offset to the value it
5891 would have if we had created a zero p_filesz and
5892 p_memsz PT_LOAD header for the section. This
5893 also makes the PT_TLS header have the same
5895 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5897 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5900 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5902 p
->p_filesz
+= this_hdr
->sh_size
;
5903 /* A load section without SHF_ALLOC is something like
5904 a note section in a PT_NOTE segment. These take
5905 file space but are not loaded into memory. */
5906 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5907 p
->p_memsz
+= this_hdr
->sh_size
;
5909 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5911 if (p
->p_type
== PT_TLS
)
5912 p
->p_memsz
+= this_hdr
->sh_size
;
5914 /* .tbss is special. It doesn't contribute to p_memsz of
5916 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5917 p
->p_memsz
+= this_hdr
->sh_size
;
5920 if (align
> p
->p_align
5921 && !m
->p_align_valid
5922 && (p
->p_type
!= PT_LOAD
5923 || (abfd
->flags
& D_PAGED
) == 0))
5927 if (!m
->p_flags_valid
)
5930 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5932 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5939 /* PR ld/20815 - Check that the program header segment, if
5940 present, will be loaded into memory. */
5941 if (p
->p_type
== PT_PHDR
5942 && phdr_load_seg
== NULL
5943 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5944 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5946 /* The fix for this error is usually to edit the linker script being
5947 used and set up the program headers manually. Either that or
5948 leave room for the headers at the start of the SECTIONS. */
5949 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5950 " by LOAD segment"),
5952 if (link_info
== NULL
)
5954 /* Arrange for the linker to exit with an error, deleting
5955 the output file unless --noinhibit-exec is given. */
5956 link_info
->callbacks
->info ("%X");
5959 /* Check that all sections are in a PT_LOAD segment.
5960 Don't check funky gdb generated core files. */
5961 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5963 bool check_vma
= true;
5965 for (i
= 1; i
< m
->count
; i
++)
5966 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5967 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5968 ->this_hdr
), p
) != 0
5969 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5970 ->this_hdr
), p
) != 0)
5972 /* Looks like we have overlays packed into the segment. */
5977 for (i
= 0; i
< m
->count
; i
++)
5979 Elf_Internal_Shdr
*this_hdr
;
5982 sec
= m
->sections
[i
];
5983 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5984 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5985 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5988 /* xgettext:c-format */
5989 (_("%pB: section `%pA' can't be allocated in segment %d"),
5991 print_segment_map (m
);
5997 elf_next_file_pos (abfd
) = off
;
5999 if (link_info
!= NULL
6000 && phdr_load_seg
!= NULL
6001 && phdr_load_seg
->includes_filehdr
)
6003 /* There is a segment that contains both the file headers and the
6004 program headers, so provide a symbol __ehdr_start pointing there.
6005 A program can use this to examine itself robustly. */
6007 struct elf_link_hash_entry
*hash
6008 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
6009 false, false, true);
6010 /* If the symbol was referenced and not defined, define it. */
6012 && (hash
->root
.type
== bfd_link_hash_new
6013 || hash
->root
.type
== bfd_link_hash_undefined
6014 || hash
->root
.type
== bfd_link_hash_undefweak
6015 || hash
->root
.type
== bfd_link_hash_common
))
6018 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
/ opb
;
6020 if (phdr_load_seg
->count
!= 0)
6021 /* The segment contains sections, so use the first one. */
6022 s
= phdr_load_seg
->sections
[0];
6024 /* Use the first (i.e. lowest-addressed) section in any segment. */
6025 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6026 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6034 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6035 hash
->root
.u
.def
.section
= s
;
6039 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6040 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6043 hash
->root
.type
= bfd_link_hash_defined
;
6044 hash
->def_regular
= 1;
6052 /* Determine if a bfd is a debuginfo file. Unfortunately there
6053 is no defined method for detecting such files, so we have to
6054 use heuristics instead. */
6057 is_debuginfo_file (bfd
*abfd
)
6059 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6062 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6063 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6064 Elf_Internal_Shdr
**headerp
;
6066 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6068 Elf_Internal_Shdr
*header
= * headerp
;
6070 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6071 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6072 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6073 && header
->sh_type
!= SHT_NOBITS
6074 && header
->sh_type
!= SHT_NOTE
)
6081 /* Assign file positions for the other sections, except for compressed debugging
6082 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6085 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6086 struct bfd_link_info
*link_info
)
6088 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6089 Elf_Internal_Shdr
**i_shdrpp
;
6090 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6091 Elf_Internal_Phdr
*phdrs
;
6092 Elf_Internal_Phdr
*p
;
6093 struct elf_segment_map
*m
;
6095 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
6096 bfd_vma maxpagesize
;
6098 if (link_info
!= NULL
)
6099 maxpagesize
= link_info
->maxpagesize
;
6101 maxpagesize
= bed
->maxpagesize
;
6102 i_shdrpp
= elf_elfsections (abfd
);
6103 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6104 off
= elf_next_file_pos (abfd
);
6105 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6107 Elf_Internal_Shdr
*hdr
;
6110 if (hdr
->bfd_section
!= NULL
6111 && (hdr
->bfd_section
->filepos
!= 0
6112 || (hdr
->sh_type
== SHT_NOBITS
6113 && hdr
->contents
== NULL
)))
6114 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6115 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6117 if (hdr
->sh_size
!= 0
6118 /* PR 24717 - debuginfo files are known to be not strictly
6119 compliant with the ELF standard. In particular they often
6120 have .note.gnu.property sections that are outside of any
6121 loadable segment. This is not a problem for such files,
6122 so do not warn about them. */
6123 && ! is_debuginfo_file (abfd
))
6125 /* xgettext:c-format */
6126 (_("%pB: warning: allocated section `%s' not in segment"),
6128 (hdr
->bfd_section
== NULL
6130 : hdr
->bfd_section
->name
));
6131 /* We don't need to page align empty sections. */
6132 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6133 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6136 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6138 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6141 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6142 && hdr
->bfd_section
== NULL
)
6143 /* We don't know the offset of these sections yet: their size has
6144 not been decided. */
6145 || (hdr
->bfd_section
!= NULL
6146 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6147 || (bfd_section_is_ctf (hdr
->bfd_section
)
6148 && abfd
->is_linker_output
)))
6149 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6150 || (elf_symtab_shndx_list (abfd
) != NULL
6151 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6152 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6153 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6154 hdr
->sh_offset
= -1;
6156 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6158 elf_next_file_pos (abfd
) = off
;
6160 /* Now that we have set the section file positions, we can set up
6161 the file positions for the non PT_LOAD segments. */
6162 phdrs
= elf_tdata (abfd
)->phdr
;
6163 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6165 if (p
->p_type
== PT_GNU_RELRO
)
6167 bfd_vma start
, end
; /* Bytes. */
6170 if (link_info
!= NULL
)
6172 /* During linking the range of the RELRO segment is passed
6173 in link_info. Note that there may be padding between
6174 relro_start and the first RELRO section. */
6175 start
= link_info
->relro_start
;
6176 end
= link_info
->relro_end
;
6178 else if (m
->count
!= 0)
6180 if (!m
->p_size_valid
)
6182 start
= m
->sections
[0]->vma
;
6183 end
= start
+ m
->p_size
/ opb
;
6194 struct elf_segment_map
*lm
;
6195 const Elf_Internal_Phdr
*lp
;
6198 /* Find a LOAD segment containing a section in the RELRO
6200 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6202 lm
= lm
->next
, lp
++)
6204 if (lp
->p_type
== PT_LOAD
6206 && (lm
->sections
[lm
->count
- 1]->vma
6207 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6208 ? lm
->sections
[lm
->count
- 1]->size
/ opb
6210 && lm
->sections
[0]->vma
< end
)
6216 /* Find the section starting the RELRO segment. */
6217 for (i
= 0; i
< lm
->count
; i
++)
6219 asection
*s
= lm
->sections
[i
];
6228 p
->p_vaddr
= lm
->sections
[i
]->vma
* opb
;
6229 p
->p_paddr
= lm
->sections
[i
]->lma
* opb
;
6230 p
->p_offset
= lm
->sections
[i
]->filepos
;
6231 p
->p_memsz
= end
* opb
- p
->p_vaddr
;
6232 p
->p_filesz
= p
->p_memsz
;
6234 /* The RELRO segment typically ends a few bytes
6235 into .got.plt but other layouts are possible.
6236 In cases where the end does not match any
6237 loaded section (for instance is in file
6238 padding), trim p_filesz back to correspond to
6239 the end of loaded section contents. */
6240 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6241 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6243 /* Preserve the alignment and flags if they are
6244 valid. The gold linker generates RW/4 for
6245 the PT_GNU_RELRO section. It is better for
6246 objcopy/strip to honor these attributes
6247 otherwise gdb will choke when using separate
6249 if (!m
->p_align_valid
)
6251 if (!m
->p_flags_valid
)
6257 if (link_info
!= NULL
)
6260 memset (p
, 0, sizeof *p
);
6262 else if (p
->p_type
== PT_GNU_STACK
)
6264 if (m
->p_size_valid
)
6265 p
->p_memsz
= m
->p_size
;
6267 else if (m
->count
!= 0)
6271 if (p
->p_type
!= PT_LOAD
6272 && (p
->p_type
!= PT_NOTE
6273 || bfd_get_format (abfd
) != bfd_core
))
6275 /* A user specified segment layout may include a PHDR
6276 segment that overlaps with a LOAD segment... */
6277 if (p
->p_type
== PT_PHDR
)
6283 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6285 /* PR 17512: file: 2195325e. */
6287 (_("%pB: error: non-load segment %d includes file header "
6288 "and/or program header"),
6289 abfd
, (int) (p
- phdrs
));
6294 p
->p_offset
= m
->sections
[0]->filepos
;
6295 for (i
= m
->count
; i
-- != 0;)
6297 asection
*sect
= m
->sections
[i
];
6298 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6299 if (hdr
->sh_type
!= SHT_NOBITS
)
6301 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6303 /* NB: p_memsz of the loadable PT_NOTE segment
6304 should be the same as p_filesz. */
6305 if (p
->p_type
== PT_NOTE
6306 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
6307 p
->p_memsz
= p
->p_filesz
;
6318 static elf_section_list
*
6319 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6321 for (;list
!= NULL
; list
= list
->next
)
6327 /* Work out the file positions of all the sections. This is called by
6328 _bfd_elf_compute_section_file_positions. All the section sizes and
6329 VMAs must be known before this is called.
6331 Reloc sections come in two flavours: Those processed specially as
6332 "side-channel" data attached to a section to which they apply, and those that
6333 bfd doesn't process as relocations. The latter sort are stored in a normal
6334 bfd section by bfd_section_from_shdr. We don't consider the former sort
6335 here, unless they form part of the loadable image. Reloc sections not
6336 assigned here (and compressed debugging sections and CTF sections which
6337 nothing else in the file can rely upon) will be handled later by
6338 assign_file_positions_for_relocs.
6340 We also don't set the positions of the .symtab and .strtab here. */
6343 assign_file_positions_except_relocs (bfd
*abfd
,
6344 struct bfd_link_info
*link_info
)
6346 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6347 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6348 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6351 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6352 && bfd_get_format (abfd
) != bfd_core
)
6354 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6355 unsigned int num_sec
= elf_numsections (abfd
);
6356 Elf_Internal_Shdr
**hdrpp
;
6360 /* Start after the ELF header. */
6361 off
= i_ehdrp
->e_ehsize
;
6363 /* We are not creating an executable, which means that we are
6364 not creating a program header, and that the actual order of
6365 the sections in the file is unimportant. */
6366 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6368 Elf_Internal_Shdr
*hdr
;
6371 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6372 && hdr
->bfd_section
== NULL
)
6373 /* Do not assign offsets for these sections yet: we don't know
6375 || (hdr
->bfd_section
!= NULL
6376 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6377 || (bfd_section_is_ctf (hdr
->bfd_section
)
6378 && abfd
->is_linker_output
)))
6379 || i
== elf_onesymtab (abfd
)
6380 || (elf_symtab_shndx_list (abfd
) != NULL
6381 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6382 || i
== elf_strtab_sec (abfd
)
6383 || i
== elf_shstrtab_sec (abfd
))
6385 hdr
->sh_offset
= -1;
6388 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6391 elf_next_file_pos (abfd
) = off
;
6392 elf_program_header_size (abfd
) = 0;
6396 /* Assign file positions for the loaded sections based on the
6397 assignment of sections to segments. */
6398 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6401 /* And for non-load sections. */
6402 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6406 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6409 /* Write out the program headers. */
6410 alloc
= i_ehdrp
->e_phnum
;
6413 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6414 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6422 _bfd_elf_init_file_header (bfd
*abfd
,
6423 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6425 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6426 struct elf_strtab_hash
*shstrtab
;
6427 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6429 i_ehdrp
= elf_elfheader (abfd
);
6431 shstrtab
= _bfd_elf_strtab_init ();
6432 if (shstrtab
== NULL
)
6435 elf_shstrtab (abfd
) = shstrtab
;
6437 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6438 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6439 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6440 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6442 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6443 i_ehdrp
->e_ident
[EI_DATA
] =
6444 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6445 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6447 if ((abfd
->flags
& DYNAMIC
) != 0)
6448 i_ehdrp
->e_type
= ET_DYN
;
6449 else if ((abfd
->flags
& EXEC_P
) != 0)
6450 i_ehdrp
->e_type
= ET_EXEC
;
6451 else if (bfd_get_format (abfd
) == bfd_core
)
6452 i_ehdrp
->e_type
= ET_CORE
;
6454 i_ehdrp
->e_type
= ET_REL
;
6456 switch (bfd_get_arch (abfd
))
6458 case bfd_arch_unknown
:
6459 i_ehdrp
->e_machine
= EM_NONE
;
6462 /* There used to be a long list of cases here, each one setting
6463 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6464 in the corresponding bfd definition. To avoid duplication,
6465 the switch was removed. Machines that need special handling
6466 can generally do it in elf_backend_final_write_processing(),
6467 unless they need the information earlier than the final write.
6468 Such need can generally be supplied by replacing the tests for
6469 e_machine with the conditions used to determine it. */
6471 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6474 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6475 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6477 /* No program header, for now. */
6478 i_ehdrp
->e_phoff
= 0;
6479 i_ehdrp
->e_phentsize
= 0;
6480 i_ehdrp
->e_phnum
= 0;
6482 /* Each bfd section is section header entry. */
6483 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6484 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6486 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6487 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
6488 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6489 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
6490 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6491 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
6492 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6493 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6494 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6500 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6502 FIXME: We used to have code here to sort the PT_LOAD segments into
6503 ascending order, as per the ELF spec. But this breaks some programs,
6504 including the Linux kernel. But really either the spec should be
6505 changed or the programs updated. */
6508 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6510 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6512 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6513 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6514 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6515 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6516 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6518 /* Find the lowest p_vaddr in PT_LOAD segments. */
6519 bfd_vma p_vaddr
= (bfd_vma
) -1;
6520 for (; segment
< end_segment
; segment
++)
6521 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6522 p_vaddr
= segment
->p_vaddr
;
6524 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6525 segments is non-zero. */
6527 i_ehdrp
->e_type
= ET_EXEC
;
6532 /* Assign file positions for all the reloc sections which are not part
6533 of the loadable file image, and the file position of section headers. */
6536 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6539 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6540 Elf_Internal_Shdr
*shdrp
;
6541 Elf_Internal_Ehdr
*i_ehdrp
;
6542 const struct elf_backend_data
*bed
;
6544 off
= elf_next_file_pos (abfd
);
6546 shdrpp
= elf_elfsections (abfd
);
6547 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6548 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6551 if (shdrp
->sh_offset
== -1)
6553 asection
*sec
= shdrp
->bfd_section
;
6554 bool is_rel
= (shdrp
->sh_type
== SHT_REL
6555 || shdrp
->sh_type
== SHT_RELA
);
6556 bool is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6559 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6561 if (!is_rel
&& !is_ctf
)
6563 const char *name
= sec
->name
;
6564 struct bfd_elf_section_data
*d
;
6566 /* Compress DWARF debug sections. */
6567 if (!bfd_compress_section (abfd
, sec
,
6571 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6572 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6574 /* If section is compressed with zlib-gnu, convert
6575 section name from .debug_* to .zdebug_*. */
6577 = convert_debug_to_zdebug (abfd
, name
);
6578 if (new_name
== NULL
)
6582 /* Add section name to section name section. */
6583 if (shdrp
->sh_name
!= (unsigned int) -1)
6586 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6588 d
= elf_section_data (sec
);
6590 /* Add reloc section name to section name section. */
6592 && !_bfd_elf_set_reloc_sh_name (abfd
,
6597 && !_bfd_elf_set_reloc_sh_name (abfd
,
6602 /* Update section size and contents. */
6603 shdrp
->sh_size
= sec
->size
;
6604 shdrp
->contents
= sec
->contents
;
6605 shdrp
->bfd_section
->contents
= NULL
;
6609 /* Update section size and contents. */
6610 shdrp
->sh_size
= sec
->size
;
6611 shdrp
->contents
= sec
->contents
;
6614 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6621 /* Place section name section after DWARF debug sections have been
6623 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6624 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6625 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6626 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
6628 /* Place the section headers. */
6629 i_ehdrp
= elf_elfheader (abfd
);
6630 bed
= get_elf_backend_data (abfd
);
6631 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6632 i_ehdrp
->e_shoff
= off
;
6633 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6634 elf_next_file_pos (abfd
) = off
;
6640 _bfd_elf_write_object_contents (bfd
*abfd
)
6642 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6643 Elf_Internal_Shdr
**i_shdrp
;
6645 unsigned int count
, num_sec
;
6646 struct elf_obj_tdata
*t
;
6648 if (! abfd
->output_has_begun
6649 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6651 /* Do not rewrite ELF data when the BFD has been opened for update.
6652 abfd->output_has_begun was set to TRUE on opening, so creation of new
6653 sections, and modification of existing section sizes was restricted.
6654 This means the ELF header, program headers and section headers can't have
6656 If the contents of any sections has been modified, then those changes have
6657 already been written to the BFD. */
6658 else if (abfd
->direction
== both_direction
)
6660 BFD_ASSERT (abfd
->output_has_begun
);
6664 i_shdrp
= elf_elfsections (abfd
);
6667 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6671 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6674 /* After writing the headers, we need to write the sections too... */
6675 num_sec
= elf_numsections (abfd
);
6676 for (count
= 1; count
< num_sec
; count
++)
6678 i_shdrp
[count
]->sh_name
6679 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6680 i_shdrp
[count
]->sh_name
);
6681 if (bed
->elf_backend_section_processing
)
6682 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6684 if (i_shdrp
[count
]->contents
)
6686 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6688 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6689 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6694 /* Write out the section header names. */
6695 t
= elf_tdata (abfd
);
6696 if (elf_shstrtab (abfd
) != NULL
6697 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6698 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6701 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6704 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6707 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6708 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6709 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6715 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6717 /* Hopefully this can be done just like an object file. */
6718 return _bfd_elf_write_object_contents (abfd
);
6721 /* Given a section, search the header to find them. */
6724 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6726 const struct elf_backend_data
*bed
;
6727 unsigned int sec_index
;
6729 if (elf_section_data (asect
) != NULL
6730 && elf_section_data (asect
)->this_idx
!= 0)
6731 return elf_section_data (asect
)->this_idx
;
6733 if (bfd_is_abs_section (asect
))
6734 sec_index
= SHN_ABS
;
6735 else if (bfd_is_com_section (asect
))
6736 sec_index
= SHN_COMMON
;
6737 else if (bfd_is_und_section (asect
))
6738 sec_index
= SHN_UNDEF
;
6740 sec_index
= SHN_BAD
;
6742 bed
= get_elf_backend_data (abfd
);
6743 if (bed
->elf_backend_section_from_bfd_section
)
6745 int retval
= sec_index
;
6747 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6751 if (sec_index
== SHN_BAD
)
6752 bfd_set_error (bfd_error_nonrepresentable_section
);
6757 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6761 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6763 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6765 flagword flags
= asym_ptr
->flags
;
6767 /* When gas creates relocations against local labels, it creates its
6768 own symbol for the section, but does put the symbol into the
6769 symbol chain, so udata is 0. When the linker is generating
6770 relocatable output, this section symbol may be for one of the
6771 input sections rather than the output section. */
6772 if (asym_ptr
->udata
.i
== 0
6773 && (flags
& BSF_SECTION_SYM
)
6774 && asym_ptr
->section
)
6779 sec
= asym_ptr
->section
;
6780 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6781 sec
= sec
->output_section
;
6782 if (sec
->owner
== abfd
6783 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6784 && elf_section_syms (abfd
)[indx
] != NULL
)
6785 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6788 idx
= asym_ptr
->udata
.i
;
6792 /* This case can occur when using --strip-symbol on a symbol
6793 which is used in a relocation entry. */
6795 /* xgettext:c-format */
6796 (_("%pB: symbol `%s' required but not present"),
6797 abfd
, bfd_asymbol_name (asym_ptr
));
6798 bfd_set_error (bfd_error_no_symbols
);
6805 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6806 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6814 /* Rewrite program header information. */
6817 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
, bfd_vma maxpagesize
)
6819 Elf_Internal_Ehdr
*iehdr
;
6820 struct elf_segment_map
*map
;
6821 struct elf_segment_map
*map_first
;
6822 struct elf_segment_map
**pointer_to_map
;
6823 Elf_Internal_Phdr
*segment
;
6826 unsigned int num_segments
;
6827 bool phdr_included
= false;
6829 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6830 unsigned int phdr_adjust_num
= 0;
6831 const struct elf_backend_data
*bed
;
6832 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
6834 bed
= get_elf_backend_data (ibfd
);
6835 iehdr
= elf_elfheader (ibfd
);
6838 pointer_to_map
= &map_first
;
6840 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6842 /* Returns the end address of the segment + 1. */
6843 #define SEGMENT_END(segment, start) \
6844 (start + (segment->p_memsz > segment->p_filesz \
6845 ? segment->p_memsz : segment->p_filesz))
6847 #define SECTION_SIZE(section, segment) \
6848 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6849 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6850 ? section->size : 0)
6852 /* Returns TRUE if the given section is contained within
6853 the given segment. VMA addresses are compared. */
6854 #define IS_CONTAINED_BY_VMA(section, segment, opb) \
6855 (section->vma * (opb) >= segment->p_vaddr \
6856 && (section->vma * (opb) + SECTION_SIZE (section, segment) \
6857 <= (SEGMENT_END (segment, segment->p_vaddr))))
6859 /* Returns TRUE if the given section is contained within
6860 the given segment. LMA addresses are compared. */
6861 #define IS_CONTAINED_BY_LMA(section, segment, base, opb) \
6862 (section->lma * (opb) >= base \
6863 && (section->lma + SECTION_SIZE (section, segment) / (opb) >= section->lma) \
6864 && (section->lma * (opb) + SECTION_SIZE (section, segment) \
6865 <= SEGMENT_END (segment, base)))
6867 /* Handle PT_NOTE segment. */
6868 #define IS_NOTE(p, s) \
6869 (p->p_type == PT_NOTE \
6870 && elf_section_type (s) == SHT_NOTE \
6871 && (bfd_vma) s->filepos >= p->p_offset \
6872 && ((bfd_vma) s->filepos + s->size \
6873 <= p->p_offset + p->p_filesz))
6875 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6877 #define IS_COREFILE_NOTE(p, s) \
6879 && bfd_get_format (ibfd) == bfd_core \
6883 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6884 linker, which generates a PT_INTERP section with p_vaddr and
6885 p_memsz set to 0. */
6886 #define IS_SOLARIS_PT_INTERP(p, s) \
6888 && p->p_paddr == 0 \
6889 && p->p_memsz == 0 \
6890 && p->p_filesz > 0 \
6891 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6893 && (bfd_vma) s->filepos >= p->p_offset \
6894 && ((bfd_vma) s->filepos + s->size \
6895 <= p->p_offset + p->p_filesz))
6897 /* Decide if the given section should be included in the given segment.
6898 A section will be included if:
6899 1. It is within the address space of the segment -- we use the LMA
6900 if that is set for the segment and the VMA otherwise,
6901 2. It is an allocated section or a NOTE section in a PT_NOTE
6903 3. There is an output section associated with it,
6904 4. The section has not already been allocated to a previous segment.
6905 5. PT_GNU_STACK segments do not include any sections.
6906 6. PT_TLS segment includes only SHF_TLS sections.
6907 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6908 8. PT_DYNAMIC should not contain empty sections at the beginning
6909 (with the possible exception of .dynamic). */
6910 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed, opb) \
6911 ((((segment->p_paddr \
6912 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr, opb) \
6913 : IS_CONTAINED_BY_VMA (section, segment, opb)) \
6914 && (section->flags & SEC_ALLOC) != 0) \
6915 || IS_NOTE (segment, section)) \
6916 && segment->p_type != PT_GNU_STACK \
6917 && (segment->p_type != PT_TLS \
6918 || (section->flags & SEC_THREAD_LOCAL)) \
6919 && (segment->p_type == PT_LOAD \
6920 || segment->p_type == PT_TLS \
6921 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6922 && (segment->p_type != PT_DYNAMIC \
6923 || SECTION_SIZE (section, segment) > 0 \
6924 || (segment->p_paddr \
6925 ? segment->p_paddr != section->lma * (opb) \
6926 : segment->p_vaddr != section->vma * (opb)) \
6927 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6928 && (segment->p_type != PT_LOAD || !section->segment_mark))
6930 /* If the output section of a section in the input segment is NULL,
6931 it is removed from the corresponding output segment. */
6932 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed, opb) \
6933 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed, opb) \
6934 && section->output_section != NULL)
6936 /* Returns TRUE iff seg1 starts after the end of seg2. */
6937 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6938 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6940 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6941 their VMA address ranges and their LMA address ranges overlap.
6942 It is possible to have overlapping VMA ranges without overlapping LMA
6943 ranges. RedBoot images for example can have both .data and .bss mapped
6944 to the same VMA range, but with the .data section mapped to a different
6946 #define SEGMENT_OVERLAPS(seg1, seg2) \
6947 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6948 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6949 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6950 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6952 /* Initialise the segment mark field. */
6953 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6954 section
->segment_mark
= false;
6956 /* The Solaris linker creates program headers in which all the
6957 p_paddr fields are zero. When we try to objcopy or strip such a
6958 file, we get confused. Check for this case, and if we find it
6959 don't set the p_paddr_valid fields. */
6960 p_paddr_valid
= false;
6961 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6964 if (segment
->p_paddr
!= 0)
6966 p_paddr_valid
= true;
6970 /* Scan through the segments specified in the program header
6971 of the input BFD. For this first scan we look for overlaps
6972 in the loadable segments. These can be created by weird
6973 parameters to objcopy. Also, fix some solaris weirdness. */
6974 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6979 Elf_Internal_Phdr
*segment2
;
6981 if (segment
->p_type
== PT_INTERP
)
6982 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6983 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6985 /* Mininal change so that the normal section to segment
6986 assignment code will work. */
6987 segment
->p_vaddr
= section
->vma
* opb
;
6991 if (segment
->p_type
!= PT_LOAD
)
6993 /* Remove PT_GNU_RELRO segment. */
6994 if (segment
->p_type
== PT_GNU_RELRO
)
6995 segment
->p_type
= PT_NULL
;
6999 /* Determine if this segment overlaps any previous segments. */
7000 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
7002 bfd_signed_vma extra_length
;
7004 if (segment2
->p_type
!= PT_LOAD
7005 || !SEGMENT_OVERLAPS (segment
, segment2
))
7008 /* Merge the two segments together. */
7009 if (segment2
->p_vaddr
< segment
->p_vaddr
)
7011 /* Extend SEGMENT2 to include SEGMENT and then delete
7013 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
7014 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
7016 if (extra_length
> 0)
7018 segment2
->p_memsz
+= extra_length
;
7019 segment2
->p_filesz
+= extra_length
;
7022 segment
->p_type
= PT_NULL
;
7024 /* Since we have deleted P we must restart the outer loop. */
7026 segment
= elf_tdata (ibfd
)->phdr
;
7031 /* Extend SEGMENT to include SEGMENT2 and then delete
7033 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7034 - SEGMENT_END (segment
, segment
->p_vaddr
));
7036 if (extra_length
> 0)
7038 segment
->p_memsz
+= extra_length
;
7039 segment
->p_filesz
+= extra_length
;
7042 segment2
->p_type
= PT_NULL
;
7047 /* The second scan attempts to assign sections to segments. */
7048 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7052 unsigned int section_count
;
7053 asection
**sections
;
7054 asection
*output_section
;
7056 asection
*matching_lma
;
7057 asection
*suggested_lma
;
7060 asection
*first_section
;
7062 if (segment
->p_type
== PT_NULL
)
7065 first_section
= NULL
;
7066 /* Compute how many sections might be placed into this segment. */
7067 for (section
= ibfd
->sections
, section_count
= 0;
7069 section
= section
->next
)
7071 /* Find the first section in the input segment, which may be
7072 removed from the corresponding output segment. */
7073 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
, opb
))
7075 if (first_section
== NULL
)
7076 first_section
= section
;
7077 if (section
->output_section
!= NULL
)
7082 /* Allocate a segment map big enough to contain
7083 all of the sections we have selected. */
7084 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7085 amt
+= section_count
* sizeof (asection
*);
7086 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7090 /* Initialise the fields of the segment map. Default to
7091 using the physical address of the segment in the input BFD. */
7093 map
->p_type
= segment
->p_type
;
7094 map
->p_flags
= segment
->p_flags
;
7095 map
->p_flags_valid
= 1;
7097 if (map
->p_type
== PT_LOAD
7098 && (ibfd
->flags
& D_PAGED
) != 0
7100 && segment
->p_align
> 1)
7102 map
->p_align
= segment
->p_align
;
7103 if (segment
->p_align
> maxpagesize
)
7104 map
->p_align
= maxpagesize
;
7105 map
->p_align_valid
= 1;
7108 /* If the first section in the input segment is removed, there is
7109 no need to preserve segment physical address in the corresponding
7111 if (!first_section
|| first_section
->output_section
!= NULL
)
7113 map
->p_paddr
= segment
->p_paddr
;
7114 map
->p_paddr_valid
= p_paddr_valid
;
7117 /* Determine if this segment contains the ELF file header
7118 and if it contains the program headers themselves. */
7119 map
->includes_filehdr
= (segment
->p_offset
== 0
7120 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7121 map
->includes_phdrs
= 0;
7123 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7125 map
->includes_phdrs
=
7126 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7127 && (segment
->p_offset
+ segment
->p_filesz
7128 >= ((bfd_vma
) iehdr
->e_phoff
7129 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7131 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7132 phdr_included
= true;
7135 if (section_count
== 0)
7137 /* Special segments, such as the PT_PHDR segment, may contain
7138 no sections, but ordinary, loadable segments should contain
7139 something. They are allowed by the ELF spec however, so only
7140 a warning is produced.
7141 There is however the valid use case of embedded systems which
7142 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7143 flash memory with zeros. No warning is shown for that case. */
7144 if (segment
->p_type
== PT_LOAD
7145 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7146 /* xgettext:c-format */
7148 (_("%pB: warning: empty loadable segment detected"
7149 " at vaddr=%#" PRIx64
", is this intentional?"),
7150 ibfd
, (uint64_t) segment
->p_vaddr
);
7152 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7154 *pointer_to_map
= map
;
7155 pointer_to_map
= &map
->next
;
7160 /* Now scan the sections in the input BFD again and attempt
7161 to add their corresponding output sections to the segment map.
7162 The problem here is how to handle an output section which has
7163 been moved (ie had its LMA changed). There are four possibilities:
7165 1. None of the sections have been moved.
7166 In this case we can continue to use the segment LMA from the
7169 2. All of the sections have been moved by the same amount.
7170 In this case we can change the segment's LMA to match the LMA
7171 of the first section.
7173 3. Some of the sections have been moved, others have not.
7174 In this case those sections which have not been moved can be
7175 placed in the current segment which will have to have its size,
7176 and possibly its LMA changed, and a new segment or segments will
7177 have to be created to contain the other sections.
7179 4. The sections have been moved, but not by the same amount.
7180 In this case we can change the segment's LMA to match the LMA
7181 of the first section and we will have to create a new segment
7182 or segments to contain the other sections.
7184 In order to save time, we allocate an array to hold the section
7185 pointers that we are interested in. As these sections get assigned
7186 to a segment, they are removed from this array. */
7188 amt
= section_count
* sizeof (asection
*);
7189 sections
= (asection
**) bfd_malloc (amt
);
7190 if (sections
== NULL
)
7193 /* Step One: Scan for segment vs section LMA conflicts.
7194 Also add the sections to the section array allocated above.
7195 Also add the sections to the current segment. In the common
7196 case, where the sections have not been moved, this means that
7197 we have completely filled the segment, and there is nothing
7200 matching_lma
= NULL
;
7201 suggested_lma
= NULL
;
7203 for (section
= first_section
, j
= 0;
7205 section
= section
->next
)
7207 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
, opb
))
7209 output_section
= section
->output_section
;
7211 sections
[j
++] = section
;
7213 /* The Solaris native linker always sets p_paddr to 0.
7214 We try to catch that case here, and set it to the
7215 correct value. Note - some backends require that
7216 p_paddr be left as zero. */
7218 && segment
->p_vaddr
!= 0
7219 && !bed
->want_p_paddr_set_to_zero
7221 && output_section
->lma
!= 0
7222 && (align_power (segment
->p_vaddr
7223 + (map
->includes_filehdr
7224 ? iehdr
->e_ehsize
: 0)
7225 + (map
->includes_phdrs
7226 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7228 output_section
->alignment_power
* opb
)
7229 == (output_section
->vma
* opb
)))
7230 map
->p_paddr
= segment
->p_vaddr
;
7232 /* Match up the physical address of the segment with the
7233 LMA address of the output section. */
7234 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7236 || IS_COREFILE_NOTE (segment
, section
)
7237 || (bed
->want_p_paddr_set_to_zero
7238 && IS_CONTAINED_BY_VMA (output_section
, segment
, opb
)))
7240 if (matching_lma
== NULL
7241 || output_section
->lma
< matching_lma
->lma
)
7242 matching_lma
= output_section
;
7244 /* We assume that if the section fits within the segment
7245 then it does not overlap any other section within that
7247 map
->sections
[isec
++] = output_section
;
7249 else if (suggested_lma
== NULL
)
7250 suggested_lma
= output_section
;
7252 if (j
== section_count
)
7257 BFD_ASSERT (j
== section_count
);
7259 /* Step Two: Adjust the physical address of the current segment,
7261 if (isec
== section_count
)
7263 /* All of the sections fitted within the segment as currently
7264 specified. This is the default case. Add the segment to
7265 the list of built segments and carry on to process the next
7266 program header in the input BFD. */
7267 map
->count
= section_count
;
7268 *pointer_to_map
= map
;
7269 pointer_to_map
= &map
->next
;
7272 && !bed
->want_p_paddr_set_to_zero
)
7274 bfd_vma hdr_size
= 0;
7275 if (map
->includes_filehdr
)
7276 hdr_size
= iehdr
->e_ehsize
;
7277 if (map
->includes_phdrs
)
7278 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7280 /* Account for padding before the first section in the
7282 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7283 - matching_lma
->lma
);
7291 /* Change the current segment's physical address to match
7292 the LMA of the first section that fitted, or if no
7293 section fitted, the first section. */
7294 if (matching_lma
== NULL
)
7295 matching_lma
= suggested_lma
;
7297 map
->p_paddr
= matching_lma
->lma
* opb
;
7299 /* Offset the segment physical address from the lma
7300 to allow for space taken up by elf headers. */
7301 if (map
->includes_phdrs
)
7303 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7305 /* iehdr->e_phnum is just an estimate of the number
7306 of program headers that we will need. Make a note
7307 here of the number we used and the segment we chose
7308 to hold these headers, so that we can adjust the
7309 offset when we know the correct value. */
7310 phdr_adjust_num
= iehdr
->e_phnum
;
7311 phdr_adjust_seg
= map
;
7314 if (map
->includes_filehdr
)
7316 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7317 map
->p_paddr
-= iehdr
->e_ehsize
;
7318 /* We've subtracted off the size of headers from the
7319 first section lma, but there may have been some
7320 alignment padding before that section too. Try to
7321 account for that by adjusting the segment lma down to
7322 the same alignment. */
7323 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7324 align
= segment
->p_align
;
7325 map
->p_paddr
&= -(align
* opb
);
7329 /* Step Three: Loop over the sections again, this time assigning
7330 those that fit to the current segment and removing them from the
7331 sections array; but making sure not to leave large gaps. Once all
7332 possible sections have been assigned to the current segment it is
7333 added to the list of built segments and if sections still remain
7334 to be assigned, a new segment is constructed before repeating
7340 suggested_lma
= NULL
;
7342 /* Fill the current segment with sections that fit. */
7343 for (j
= 0; j
< section_count
; j
++)
7345 section
= sections
[j
];
7347 if (section
== NULL
)
7350 output_section
= section
->output_section
;
7352 BFD_ASSERT (output_section
!= NULL
);
7354 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7356 || IS_COREFILE_NOTE (segment
, section
))
7358 if (map
->count
== 0)
7360 /* If the first section in a segment does not start at
7361 the beginning of the segment, then something is
7363 if (align_power (map
->p_paddr
7364 + (map
->includes_filehdr
7365 ? iehdr
->e_ehsize
: 0)
7366 + (map
->includes_phdrs
7367 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7369 output_section
->alignment_power
* opb
)
7370 != output_section
->lma
* opb
)
7377 prev_sec
= map
->sections
[map
->count
- 1];
7379 /* If the gap between the end of the previous section
7380 and the start of this section is more than
7381 maxpagesize then we need to start a new segment. */
7382 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7384 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7385 || (prev_sec
->lma
+ prev_sec
->size
7386 > output_section
->lma
))
7388 if (suggested_lma
== NULL
)
7389 suggested_lma
= output_section
;
7395 map
->sections
[map
->count
++] = output_section
;
7398 if (segment
->p_type
== PT_LOAD
)
7399 section
->segment_mark
= true;
7401 else if (suggested_lma
== NULL
)
7402 suggested_lma
= output_section
;
7405 /* PR 23932. A corrupt input file may contain sections that cannot
7406 be assigned to any segment - because for example they have a
7407 negative size - or segments that do not contain any sections.
7408 But there are also valid reasons why a segment can be empty.
7409 So allow a count of zero. */
7411 /* Add the current segment to the list of built segments. */
7412 *pointer_to_map
= map
;
7413 pointer_to_map
= &map
->next
;
7415 if (isec
< section_count
)
7417 /* We still have not allocated all of the sections to
7418 segments. Create a new segment here, initialise it
7419 and carry on looping. */
7420 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7421 amt
+= section_count
* sizeof (asection
*);
7422 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7429 /* Initialise the fields of the segment map. Set the physical
7430 physical address to the LMA of the first section that has
7431 not yet been assigned. */
7433 map
->p_type
= segment
->p_type
;
7434 map
->p_flags
= segment
->p_flags
;
7435 map
->p_flags_valid
= 1;
7436 map
->p_paddr
= suggested_lma
->lma
* opb
;
7437 map
->p_paddr_valid
= p_paddr_valid
;
7438 map
->includes_filehdr
= 0;
7439 map
->includes_phdrs
= 0;
7444 bfd_set_error (bfd_error_sorry
);
7448 while (isec
< section_count
);
7453 elf_seg_map (obfd
) = map_first
;
7455 /* If we had to estimate the number of program headers that were
7456 going to be needed, then check our estimate now and adjust
7457 the offset if necessary. */
7458 if (phdr_adjust_seg
!= NULL
)
7462 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7465 if (count
> phdr_adjust_num
)
7466 phdr_adjust_seg
->p_paddr
7467 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7469 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7470 if (map
->p_type
== PT_PHDR
)
7473 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7474 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7481 #undef IS_CONTAINED_BY_VMA
7482 #undef IS_CONTAINED_BY_LMA
7484 #undef IS_COREFILE_NOTE
7485 #undef IS_SOLARIS_PT_INTERP
7486 #undef IS_SECTION_IN_INPUT_SEGMENT
7487 #undef INCLUDE_SECTION_IN_SEGMENT
7488 #undef SEGMENT_AFTER_SEGMENT
7489 #undef SEGMENT_OVERLAPS
7493 /* Copy ELF program header information. */
7496 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7498 Elf_Internal_Ehdr
*iehdr
;
7499 struct elf_segment_map
*map
;
7500 struct elf_segment_map
*map_first
;
7501 struct elf_segment_map
**pointer_to_map
;
7502 Elf_Internal_Phdr
*segment
;
7504 unsigned int num_segments
;
7505 bool phdr_included
= false;
7507 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
7509 iehdr
= elf_elfheader (ibfd
);
7512 pointer_to_map
= &map_first
;
7514 /* If all the segment p_paddr fields are zero, don't set
7515 map->p_paddr_valid. */
7516 p_paddr_valid
= false;
7517 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7518 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7521 if (segment
->p_paddr
!= 0)
7523 p_paddr_valid
= true;
7527 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7532 unsigned int section_count
;
7534 Elf_Internal_Shdr
*this_hdr
;
7535 asection
*first_section
= NULL
;
7536 asection
*lowest_section
;
7538 /* Compute how many sections are in this segment. */
7539 for (section
= ibfd
->sections
, section_count
= 0;
7541 section
= section
->next
)
7543 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7544 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7546 if (first_section
== NULL
)
7547 first_section
= section
;
7552 /* Allocate a segment map big enough to contain
7553 all of the sections we have selected. */
7554 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7555 amt
+= section_count
* sizeof (asection
*);
7556 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7560 /* Initialize the fields of the output segment map with the
7563 map
->p_type
= segment
->p_type
;
7564 map
->p_flags
= segment
->p_flags
;
7565 map
->p_flags_valid
= 1;
7566 map
->p_paddr
= segment
->p_paddr
;
7567 map
->p_paddr_valid
= p_paddr_valid
;
7568 map
->p_align
= segment
->p_align
;
7569 map
->p_align_valid
= 1;
7570 map
->p_vaddr_offset
= 0;
7572 if (map
->p_type
== PT_GNU_RELRO
7573 || map
->p_type
== PT_GNU_STACK
)
7575 /* The PT_GNU_RELRO segment may contain the first a few
7576 bytes in the .got.plt section even if the whole .got.plt
7577 section isn't in the PT_GNU_RELRO segment. We won't
7578 change the size of the PT_GNU_RELRO segment.
7579 Similarly, PT_GNU_STACK size is significant on uclinux
7581 map
->p_size
= segment
->p_memsz
;
7582 map
->p_size_valid
= 1;
7585 /* Determine if this segment contains the ELF file header
7586 and if it contains the program headers themselves. */
7587 map
->includes_filehdr
= (segment
->p_offset
== 0
7588 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7590 map
->includes_phdrs
= 0;
7591 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7593 map
->includes_phdrs
=
7594 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7595 && (segment
->p_offset
+ segment
->p_filesz
7596 >= ((bfd_vma
) iehdr
->e_phoff
7597 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7599 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7600 phdr_included
= true;
7603 lowest_section
= NULL
;
7604 if (section_count
!= 0)
7606 unsigned int isec
= 0;
7608 for (section
= first_section
;
7610 section
= section
->next
)
7612 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7613 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7615 map
->sections
[isec
++] = section
->output_section
;
7616 if ((section
->flags
& SEC_ALLOC
) != 0)
7620 if (lowest_section
== NULL
7621 || section
->lma
< lowest_section
->lma
)
7622 lowest_section
= section
;
7624 /* Section lmas are set up from PT_LOAD header
7625 p_paddr in _bfd_elf_make_section_from_shdr.
7626 If this header has a p_paddr that disagrees
7627 with the section lma, flag the p_paddr as
7629 if ((section
->flags
& SEC_LOAD
) != 0)
7630 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7632 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7633 if (section
->lma
* opb
- segment
->p_paddr
!= seg_off
)
7634 map
->p_paddr_valid
= false;
7636 if (isec
== section_count
)
7642 if (section_count
== 0)
7643 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7644 else if (map
->p_paddr_valid
)
7646 /* Account for padding before the first section in the segment. */
7647 bfd_vma hdr_size
= 0;
7648 if (map
->includes_filehdr
)
7649 hdr_size
= iehdr
->e_ehsize
;
7650 if (map
->includes_phdrs
)
7651 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7653 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7654 - (lowest_section
? lowest_section
->lma
: 0));
7657 map
->count
= section_count
;
7658 *pointer_to_map
= map
;
7659 pointer_to_map
= &map
->next
;
7662 elf_seg_map (obfd
) = map_first
;
7666 /* Copy private BFD data. This copies or rewrites ELF program header
7670 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7672 bfd_vma maxpagesize
;
7674 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7675 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7678 if (elf_tdata (ibfd
)->phdr
== NULL
)
7681 if (ibfd
->xvec
== obfd
->xvec
)
7683 /* Check to see if any sections in the input BFD
7684 covered by ELF program header have changed. */
7685 Elf_Internal_Phdr
*segment
;
7686 asection
*section
, *osec
;
7687 unsigned int i
, num_segments
;
7688 Elf_Internal_Shdr
*this_hdr
;
7689 const struct elf_backend_data
*bed
;
7691 bed
= get_elf_backend_data (ibfd
);
7693 /* Regenerate the segment map if p_paddr is set to 0. */
7694 if (bed
->want_p_paddr_set_to_zero
)
7697 /* Initialize the segment mark field. */
7698 for (section
= obfd
->sections
; section
!= NULL
;
7699 section
= section
->next
)
7700 section
->segment_mark
= false;
7702 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7703 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7707 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7708 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7709 which severly confuses things, so always regenerate the segment
7710 map in this case. */
7711 if (segment
->p_paddr
== 0
7712 && segment
->p_memsz
== 0
7713 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7716 for (section
= ibfd
->sections
;
7717 section
!= NULL
; section
= section
->next
)
7719 /* We mark the output section so that we know it comes
7720 from the input BFD. */
7721 osec
= section
->output_section
;
7723 osec
->segment_mark
= true;
7725 /* Check if this section is covered by the segment. */
7726 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7727 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7729 /* FIXME: Check if its output section is changed or
7730 removed. What else do we need to check? */
7732 || section
->flags
!= osec
->flags
7733 || section
->lma
!= osec
->lma
7734 || section
->vma
!= osec
->vma
7735 || section
->size
!= osec
->size
7736 || section
->rawsize
!= osec
->rawsize
7737 || section
->alignment_power
!= osec
->alignment_power
)
7743 /* Check to see if any output section do not come from the
7745 for (section
= obfd
->sections
; section
!= NULL
;
7746 section
= section
->next
)
7748 if (!section
->segment_mark
)
7751 section
->segment_mark
= false;
7754 return copy_elf_program_header (ibfd
, obfd
);
7759 if (ibfd
->xvec
== obfd
->xvec
)
7761 /* When rewriting program header, set the output maxpagesize to
7762 the maximum alignment of input PT_LOAD segments. */
7763 Elf_Internal_Phdr
*segment
;
7765 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7767 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7770 if (segment
->p_type
== PT_LOAD
7771 && maxpagesize
< segment
->p_align
)
7773 /* PR 17512: file: f17299af. */
7774 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7775 /* xgettext:c-format */
7776 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7777 PRIx64
" is too large"),
7778 ibfd
, (uint64_t) segment
->p_align
);
7780 maxpagesize
= segment
->p_align
;
7783 if (maxpagesize
== 0)
7784 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
7786 return rewrite_elf_program_header (ibfd
, obfd
, maxpagesize
);
7789 /* Initialize private output section information from input section. */
7792 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7796 struct bfd_link_info
*link_info
)
7799 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7800 bool final_link
= (link_info
!= NULL
7801 && !bfd_link_relocatable (link_info
));
7803 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7804 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7807 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7809 /* If this is a known ABI section, ELF section type and flags may
7810 have been set up when OSEC was created. For normal sections we
7811 allow the user to override the type and flags other than
7812 SHF_MASKOS and SHF_MASKPROC. */
7813 if (elf_section_type (osec
) == SHT_PROGBITS
7814 || elf_section_type (osec
) == SHT_NOTE
7815 || elf_section_type (osec
) == SHT_NOBITS
)
7816 elf_section_type (osec
) = SHT_NULL
;
7817 /* For objcopy and relocatable link, copy the ELF section type from
7818 the input file if the BFD section flags are the same. (If they
7819 are different the user may be doing something like
7820 "objcopy --set-section-flags .text=alloc,data".) For a final
7821 link allow some flags that the linker clears to differ. */
7822 if (elf_section_type (osec
) == SHT_NULL
7823 && (osec
->flags
== isec
->flags
7825 && ((osec
->flags
^ isec
->flags
)
7826 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7827 elf_section_type (osec
) = elf_section_type (isec
);
7829 /* FIXME: Is this correct for all OS/PROC specific flags? */
7830 elf_section_flags (osec
) = (elf_section_flags (isec
)
7831 & (SHF_MASKOS
| SHF_MASKPROC
));
7833 /* Copy sh_info from input for mbind section. */
7834 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7835 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7836 elf_section_data (osec
)->this_hdr
.sh_info
7837 = elf_section_data (isec
)->this_hdr
.sh_info
;
7839 /* Set things up for objcopy and relocatable link. The output
7840 SHT_GROUP section will have its elf_next_in_group pointing back
7841 to the input group members. Ignore linker created group section.
7842 See elfNN_ia64_object_p in elfxx-ia64.c. */
7843 if ((link_info
== NULL
7844 || !link_info
->resolve_section_groups
)
7845 && (elf_sec_group (isec
) == NULL
7846 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7848 if (elf_section_flags (isec
) & SHF_GROUP
)
7849 elf_section_flags (osec
) |= SHF_GROUP
;
7850 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7851 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7854 /* If not decompress, preserve SHF_COMPRESSED. */
7855 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7856 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7859 ihdr
= &elf_section_data (isec
)->this_hdr
;
7861 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7862 don't use the output section of the linked-to section since it
7863 may be NULL at this point. */
7864 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7866 ohdr
= &elf_section_data (osec
)->this_hdr
;
7867 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7868 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7871 osec
->use_rela_p
= isec
->use_rela_p
;
7876 /* Copy private section information. This copies over the entsize
7877 field, and sometimes the info field. */
7880 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7885 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7887 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7888 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7891 ihdr
= &elf_section_data (isec
)->this_hdr
;
7892 ohdr
= &elf_section_data (osec
)->this_hdr
;
7894 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7896 if (ihdr
->sh_type
== SHT_SYMTAB
7897 || ihdr
->sh_type
== SHT_DYNSYM
7898 || ihdr
->sh_type
== SHT_GNU_verneed
7899 || ihdr
->sh_type
== SHT_GNU_verdef
)
7900 ohdr
->sh_info
= ihdr
->sh_info
;
7902 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7906 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7907 necessary if we are removing either the SHT_GROUP section or any of
7908 the group member sections. DISCARDED is the value that a section's
7909 output_section has if the section will be discarded, NULL when this
7910 function is called from objcopy, bfd_abs_section_ptr when called
7914 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7918 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7919 if (elf_section_type (isec
) == SHT_GROUP
)
7921 asection
*first
= elf_next_in_group (isec
);
7922 asection
*s
= first
;
7923 bfd_size_type removed
= 0;
7927 /* If this member section is being output but the
7928 SHT_GROUP section is not, then clear the group info
7929 set up by _bfd_elf_copy_private_section_data. */
7930 if (s
->output_section
!= discarded
7931 && isec
->output_section
== discarded
)
7933 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7934 elf_group_name (s
->output_section
) = NULL
;
7938 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7939 if (s
->output_section
== discarded
7940 && isec
->output_section
!= discarded
)
7942 /* Conversely, if the member section is not being
7943 output but the SHT_GROUP section is, then adjust
7946 if (elf_sec
->rel
.hdr
!= NULL
7947 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7949 if (elf_sec
->rela
.hdr
!= NULL
7950 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7955 /* Also adjust for zero-sized relocation member
7957 if (elf_sec
->rel
.hdr
!= NULL
7958 && elf_sec
->rel
.hdr
->sh_size
== 0)
7960 if (elf_sec
->rela
.hdr
!= NULL
7961 && elf_sec
->rela
.hdr
->sh_size
== 0)
7965 s
= elf_next_in_group (s
);
7971 if (discarded
!= NULL
)
7973 /* If we've been called for ld -r, then we need to
7974 adjust the input section size. */
7975 if (isec
->rawsize
== 0)
7976 isec
->rawsize
= isec
->size
;
7977 isec
->size
= isec
->rawsize
- removed
;
7978 if (isec
->size
<= 4)
7981 isec
->flags
|= SEC_EXCLUDE
;
7986 /* Adjust the output section size when called from
7988 isec
->output_section
->size
-= removed
;
7989 if (isec
->output_section
->size
<= 4)
7991 isec
->output_section
->size
= 0;
7992 isec
->output_section
->flags
|= SEC_EXCLUDE
;
8001 /* Copy private header information. */
8004 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
8006 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8007 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8010 /* Copy over private BFD data if it has not already been copied.
8011 This must be done here, rather than in the copy_private_bfd_data
8012 entry point, because the latter is called after the section
8013 contents have been set, which means that the program headers have
8014 already been worked out. */
8015 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
8017 if (! copy_private_bfd_data (ibfd
, obfd
))
8021 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
8024 /* Copy private symbol information. If this symbol is in a section
8025 which we did not map into a BFD section, try to map the section
8026 index correctly. We use special macro definitions for the mapped
8027 section indices; these definitions are interpreted by the
8028 swap_out_syms function. */
8030 #define MAP_ONESYMTAB (SHN_HIOS + 1)
8031 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
8032 #define MAP_STRTAB (SHN_HIOS + 3)
8033 #define MAP_SHSTRTAB (SHN_HIOS + 4)
8034 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
8037 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
8042 elf_symbol_type
*isym
, *osym
;
8044 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8045 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8048 isym
= elf_symbol_from (isymarg
);
8049 osym
= elf_symbol_from (osymarg
);
8052 && isym
->internal_elf_sym
.st_shndx
!= 0
8054 && bfd_is_abs_section (isym
->symbol
.section
))
8058 shndx
= isym
->internal_elf_sym
.st_shndx
;
8059 if (shndx
== elf_onesymtab (ibfd
))
8060 shndx
= MAP_ONESYMTAB
;
8061 else if (shndx
== elf_dynsymtab (ibfd
))
8062 shndx
= MAP_DYNSYMTAB
;
8063 else if (shndx
== elf_strtab_sec (ibfd
))
8065 else if (shndx
== elf_shstrtab_sec (ibfd
))
8066 shndx
= MAP_SHSTRTAB
;
8067 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
8068 shndx
= MAP_SYM_SHNDX
;
8069 osym
->internal_elf_sym
.st_shndx
= shndx
;
8075 /* Swap out the symbols. */
8078 swap_out_syms (bfd
*abfd
,
8079 struct elf_strtab_hash
**sttp
,
8081 struct bfd_link_info
*info
)
8083 const struct elf_backend_data
*bed
;
8084 unsigned int symcount
;
8086 struct elf_strtab_hash
*stt
;
8087 Elf_Internal_Shdr
*symtab_hdr
;
8088 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8089 Elf_Internal_Shdr
*symstrtab_hdr
;
8090 struct elf_sym_strtab
*symstrtab
;
8091 bfd_byte
*outbound_syms
;
8092 bfd_byte
*outbound_shndx
;
8093 unsigned long outbound_syms_index
;
8094 unsigned long outbound_shndx_index
;
8096 unsigned int num_locals
;
8098 bool name_local_sections
;
8100 if (!elf_map_symbols (abfd
, &num_locals
))
8103 /* Dump out the symtabs. */
8104 stt
= _bfd_elf_strtab_init ();
8108 bed
= get_elf_backend_data (abfd
);
8109 symcount
= bfd_get_symcount (abfd
);
8110 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8111 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8112 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8113 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8114 symtab_hdr
->sh_info
= num_locals
+ 1;
8115 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8117 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8118 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8120 /* Allocate buffer to swap out the .strtab section. */
8121 if (_bfd_mul_overflow (symcount
+ 1, sizeof (*symstrtab
), &amt
)
8122 || (symstrtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
)) == NULL
)
8124 bfd_set_error (bfd_error_no_memory
);
8125 _bfd_elf_strtab_free (stt
);
8129 if (_bfd_mul_overflow (symcount
+ 1, bed
->s
->sizeof_sym
, &amt
)
8130 || (outbound_syms
= (bfd_byte
*) bfd_alloc (abfd
, amt
)) == NULL
)
8133 bfd_set_error (bfd_error_no_memory
);
8136 _bfd_elf_strtab_free (stt
);
8139 symtab_hdr
->contents
= outbound_syms
;
8140 outbound_syms_index
= 0;
8142 outbound_shndx
= NULL
;
8143 outbound_shndx_index
= 0;
8145 if (elf_symtab_shndx_list (abfd
))
8147 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8148 if (symtab_shndx_hdr
->sh_name
!= 0)
8150 if (_bfd_mul_overflow (symcount
+ 1,
8151 sizeof (Elf_External_Sym_Shndx
), &amt
))
8153 outbound_shndx
= (bfd_byte
*) bfd_zalloc (abfd
, amt
);
8154 if (outbound_shndx
== NULL
)
8157 symtab_shndx_hdr
->contents
= outbound_shndx
;
8158 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8159 symtab_shndx_hdr
->sh_size
= amt
;
8160 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8161 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8163 /* FIXME: What about any other headers in the list ? */
8166 /* Now generate the data (for "contents"). */
8168 /* Fill in zeroth symbol and swap it out. */
8169 Elf_Internal_Sym sym
;
8175 sym
.st_shndx
= SHN_UNDEF
;
8176 sym
.st_target_internal
= 0;
8177 symstrtab
[0].sym
= sym
;
8178 symstrtab
[0].dest_index
= outbound_syms_index
;
8179 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8180 outbound_syms_index
++;
8181 if (outbound_shndx
!= NULL
)
8182 outbound_shndx_index
++;
8186 = (bed
->elf_backend_name_local_section_symbols
8187 && bed
->elf_backend_name_local_section_symbols (abfd
));
8189 syms
= bfd_get_outsymbols (abfd
);
8190 for (idx
= 0; idx
< symcount
;)
8192 Elf_Internal_Sym sym
;
8193 bfd_vma value
= syms
[idx
]->value
;
8194 elf_symbol_type
*type_ptr
;
8195 flagword flags
= syms
[idx
]->flags
;
8198 if (!name_local_sections
8199 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8201 /* Local section symbols have no name. */
8202 sym
.st_name
= (unsigned long) -1;
8206 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8207 to get the final offset for st_name. */
8209 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8211 if (sym
.st_name
== (unsigned long) -1)
8215 type_ptr
= elf_symbol_from (syms
[idx
]);
8217 if ((flags
& BSF_SECTION_SYM
) == 0
8218 && bfd_is_com_section (syms
[idx
]->section
))
8220 /* ELF common symbols put the alignment into the `value' field,
8221 and the size into the `size' field. This is backwards from
8222 how BFD handles it, so reverse it here. */
8223 sym
.st_size
= value
;
8224 if (type_ptr
== NULL
8225 || type_ptr
->internal_elf_sym
.st_value
== 0)
8226 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8228 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8229 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8230 (abfd
, syms
[idx
]->section
);
8234 asection
*sec
= syms
[idx
]->section
;
8237 if (sec
->output_section
)
8239 value
+= sec
->output_offset
;
8240 sec
= sec
->output_section
;
8243 /* Don't add in the section vma for relocatable output. */
8244 if (! relocatable_p
)
8246 sym
.st_value
= value
;
8247 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8249 if (bfd_is_abs_section (sec
)
8251 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8253 /* This symbol is in a real ELF section which we did
8254 not create as a BFD section. Undo the mapping done
8255 by copy_private_symbol_data. */
8256 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8260 shndx
= elf_onesymtab (abfd
);
8263 shndx
= elf_dynsymtab (abfd
);
8266 shndx
= elf_strtab_sec (abfd
);
8269 shndx
= elf_shstrtab_sec (abfd
);
8272 if (elf_symtab_shndx_list (abfd
))
8273 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8280 if (shndx
>= SHN_LOPROC
&& shndx
<= SHN_HIOS
)
8282 if (bed
->symbol_section_index
)
8283 shndx
= bed
->symbol_section_index (abfd
, type_ptr
);
8284 /* Otherwise just leave the index alone. */
8288 if (shndx
> SHN_HIOS
&& shndx
< SHN_HIRESERVE
)
8289 _bfd_error_handler (_("%pB: \
8290 Unable to handle section index %x in ELF symbol. Using ABS instead."),
8299 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8301 if (shndx
== SHN_BAD
)
8305 /* Writing this would be a hell of a lot easier if
8306 we had some decent documentation on bfd, and
8307 knew what to expect of the library, and what to
8308 demand of applications. For example, it
8309 appears that `objcopy' might not set the
8310 section of a symbol to be a section that is
8311 actually in the output file. */
8312 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8314 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8315 if (shndx
== SHN_BAD
)
8317 /* xgettext:c-format */
8319 (_("unable to find equivalent output section"
8320 " for symbol '%s' from section '%s'"),
8321 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8323 bfd_set_error (bfd_error_invalid_operation
);
8329 sym
.st_shndx
= shndx
;
8332 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8334 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8335 type
= STT_GNU_IFUNC
;
8336 else if ((flags
& BSF_FUNCTION
) != 0)
8338 else if ((flags
& BSF_OBJECT
) != 0)
8340 else if ((flags
& BSF_RELC
) != 0)
8342 else if ((flags
& BSF_SRELC
) != 0)
8347 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8350 /* Processor-specific types. */
8351 if (type_ptr
!= NULL
8352 && bed
->elf_backend_get_symbol_type
)
8353 type
= ((*bed
->elf_backend_get_symbol_type
)
8354 (&type_ptr
->internal_elf_sym
, type
));
8356 if (flags
& BSF_SECTION_SYM
)
8358 if (flags
& BSF_GLOBAL
)
8359 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8361 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8363 else if (bfd_is_com_section (syms
[idx
]->section
))
8365 if (type
!= STT_TLS
)
8367 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8368 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8369 ? STT_COMMON
: STT_OBJECT
);
8371 type
= ((flags
& BSF_ELF_COMMON
) != 0
8372 ? STT_COMMON
: STT_OBJECT
);
8374 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8376 else if (bfd_is_und_section (syms
[idx
]->section
))
8377 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8381 else if (flags
& BSF_FILE
)
8382 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8385 int bind
= STB_LOCAL
;
8387 if (flags
& BSF_LOCAL
)
8389 else if (flags
& BSF_GNU_UNIQUE
)
8390 bind
= STB_GNU_UNIQUE
;
8391 else if (flags
& BSF_WEAK
)
8393 else if (flags
& BSF_GLOBAL
)
8396 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8399 if (type_ptr
!= NULL
)
8401 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8402 sym
.st_target_internal
8403 = type_ptr
->internal_elf_sym
.st_target_internal
;
8408 sym
.st_target_internal
= 0;
8412 symstrtab
[idx
].sym
= sym
;
8413 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8414 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8416 outbound_syms_index
++;
8417 if (outbound_shndx
!= NULL
)
8418 outbound_shndx_index
++;
8421 /* Finalize the .strtab section. */
8422 _bfd_elf_strtab_finalize (stt
);
8424 /* Swap out the .strtab section. */
8425 for (idx
= 0; idx
<= symcount
; idx
++)
8427 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8428 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8429 elfsym
->sym
.st_name
= 0;
8431 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8432 elfsym
->sym
.st_name
);
8433 if (info
&& info
->callbacks
->ctf_new_symbol
)
8434 info
->callbacks
->ctf_new_symbol (elfsym
->dest_index
,
8437 /* Inform the linker of the addition of this symbol. */
8439 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8441 + (elfsym
->dest_index
8442 * bed
->s
->sizeof_sym
)),
8444 + (elfsym
->destshndx_index
8445 * sizeof (Elf_External_Sym_Shndx
))));
8450 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8451 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8452 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8453 symstrtab_hdr
->sh_addr
= 0;
8454 symstrtab_hdr
->sh_entsize
= 0;
8455 symstrtab_hdr
->sh_link
= 0;
8456 symstrtab_hdr
->sh_info
= 0;
8457 symstrtab_hdr
->sh_addralign
= 1;
8462 /* Return the number of bytes required to hold the symtab vector.
8464 Note that we base it on the count plus 1, since we will null terminate
8465 the vector allocated based on this size. However, the ELF symbol table
8466 always has a dummy entry as symbol #0, so it ends up even. */
8469 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8471 bfd_size_type symcount
;
8473 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8475 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8476 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8478 bfd_set_error (bfd_error_file_too_big
);
8481 symtab_size
= symcount
* (sizeof (asymbol
*));
8483 symtab_size
= sizeof (asymbol
*);
8484 else if (!bfd_write_p (abfd
))
8486 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8488 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8490 bfd_set_error (bfd_error_file_truncated
);
8499 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8501 bfd_size_type symcount
;
8503 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8505 if (elf_dynsymtab (abfd
) == 0)
8507 bfd_set_error (bfd_error_invalid_operation
);
8511 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8512 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8514 bfd_set_error (bfd_error_file_too_big
);
8517 symtab_size
= symcount
* (sizeof (asymbol
*));
8519 symtab_size
= sizeof (asymbol
*);
8520 else if (!bfd_write_p (abfd
))
8522 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8524 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8526 bfd_set_error (bfd_error_file_truncated
);
8535 _bfd_elf_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
8537 if (asect
->reloc_count
!= 0 && !bfd_write_p (abfd
))
8539 /* Sanity check reloc section size. */
8540 struct bfd_elf_section_data
*d
= elf_section_data (asect
);
8541 Elf_Internal_Shdr
*rel_hdr
= &d
->this_hdr
;
8542 bfd_size_type ext_rel_size
= rel_hdr
->sh_size
;
8543 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8545 if (filesize
!= 0 && ext_rel_size
> filesize
)
8547 bfd_set_error (bfd_error_file_truncated
);
8552 #if SIZEOF_LONG == SIZEOF_INT
8553 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8555 bfd_set_error (bfd_error_file_too_big
);
8559 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8562 /* Canonicalize the relocs. */
8565 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8572 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8574 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
8577 tblptr
= section
->relocation
;
8578 for (i
= 0; i
< section
->reloc_count
; i
++)
8579 *relptr
++ = tblptr
++;
8583 return section
->reloc_count
;
8587 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8589 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8590 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, false);
8593 abfd
->symcount
= symcount
;
8598 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8599 asymbol
**allocation
)
8601 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8602 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, true);
8605 abfd
->dynsymcount
= symcount
;
8609 /* Return the size required for the dynamic reloc entries. Any loadable
8610 section that was actually installed in the BFD, and has type SHT_REL
8611 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8612 dynamic reloc section. */
8615 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8617 bfd_size_type count
, ext_rel_size
;
8620 if (elf_dynsymtab (abfd
) == 0)
8622 bfd_set_error (bfd_error_invalid_operation
);
8628 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8629 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8630 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8631 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8633 ext_rel_size
+= s
->size
;
8634 if (ext_rel_size
< s
->size
)
8636 bfd_set_error (bfd_error_file_truncated
);
8639 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8640 if (count
> LONG_MAX
/ sizeof (arelent
*))
8642 bfd_set_error (bfd_error_file_too_big
);
8646 if (count
> 1 && !bfd_write_p (abfd
))
8648 /* Sanity check reloc section sizes. */
8649 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8650 if (filesize
!= 0 && ext_rel_size
> filesize
)
8652 bfd_set_error (bfd_error_file_truncated
);
8656 return count
* sizeof (arelent
*);
8659 /* Canonicalize the dynamic relocation entries. Note that we return the
8660 dynamic relocations as a single block, although they are actually
8661 associated with particular sections; the interface, which was
8662 designed for SunOS style shared libraries, expects that there is only
8663 one set of dynamic relocs. Any loadable section that was actually
8664 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8665 dynamic symbol table, is considered to be a dynamic reloc section. */
8668 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8672 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
8676 if (elf_dynsymtab (abfd
) == 0)
8678 bfd_set_error (bfd_error_invalid_operation
);
8682 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8684 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8686 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8687 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8688 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8693 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
8695 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8697 for (i
= 0; i
< count
; i
++)
8708 /* Read in the version information. */
8711 _bfd_elf_slurp_version_tables (bfd
*abfd
, bool default_imported_symver
)
8713 bfd_byte
*contents
= NULL
;
8714 unsigned int freeidx
= 0;
8717 if (elf_dynverref (abfd
) != 0)
8719 Elf_Internal_Shdr
*hdr
;
8720 Elf_External_Verneed
*everneed
;
8721 Elf_Internal_Verneed
*iverneed
;
8723 bfd_byte
*contents_end
;
8725 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8727 if (hdr
->sh_info
== 0
8728 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8730 error_return_bad_verref
:
8732 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8733 bfd_set_error (bfd_error_bad_value
);
8734 error_return_verref
:
8735 elf_tdata (abfd
)->verref
= NULL
;
8736 elf_tdata (abfd
)->cverrefs
= 0;
8740 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8741 goto error_return_verref
;
8742 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8743 if (contents
== NULL
)
8744 goto error_return_verref
;
8746 if (_bfd_mul_overflow (hdr
->sh_info
, sizeof (Elf_Internal_Verneed
), &amt
))
8748 bfd_set_error (bfd_error_file_too_big
);
8749 goto error_return_verref
;
8751 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*) bfd_alloc (abfd
, amt
);
8752 if (elf_tdata (abfd
)->verref
== NULL
)
8753 goto error_return_verref
;
8755 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8756 == sizeof (Elf_External_Vernaux
));
8757 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8758 everneed
= (Elf_External_Verneed
*) contents
;
8759 iverneed
= elf_tdata (abfd
)->verref
;
8760 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8762 Elf_External_Vernaux
*evernaux
;
8763 Elf_Internal_Vernaux
*ivernaux
;
8766 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8768 iverneed
->vn_bfd
= abfd
;
8770 iverneed
->vn_filename
=
8771 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8773 if (iverneed
->vn_filename
== NULL
)
8774 goto error_return_bad_verref
;
8776 if (iverneed
->vn_cnt
== 0)
8777 iverneed
->vn_auxptr
= NULL
;
8780 if (_bfd_mul_overflow (iverneed
->vn_cnt
,
8781 sizeof (Elf_Internal_Vernaux
), &amt
))
8783 bfd_set_error (bfd_error_file_too_big
);
8784 goto error_return_verref
;
8786 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8787 bfd_alloc (abfd
, amt
);
8788 if (iverneed
->vn_auxptr
== NULL
)
8789 goto error_return_verref
;
8792 if (iverneed
->vn_aux
8793 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8794 goto error_return_bad_verref
;
8796 evernaux
= ((Elf_External_Vernaux
*)
8797 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8798 ivernaux
= iverneed
->vn_auxptr
;
8799 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8801 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8803 ivernaux
->vna_nodename
=
8804 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8805 ivernaux
->vna_name
);
8806 if (ivernaux
->vna_nodename
== NULL
)
8807 goto error_return_bad_verref
;
8809 if (ivernaux
->vna_other
> freeidx
)
8810 freeidx
= ivernaux
->vna_other
;
8812 ivernaux
->vna_nextptr
= NULL
;
8813 if (ivernaux
->vna_next
== 0)
8815 iverneed
->vn_cnt
= j
+ 1;
8818 if (j
+ 1 < iverneed
->vn_cnt
)
8819 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8821 if (ivernaux
->vna_next
8822 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8823 goto error_return_bad_verref
;
8825 evernaux
= ((Elf_External_Vernaux
*)
8826 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8829 iverneed
->vn_nextref
= NULL
;
8830 if (iverneed
->vn_next
== 0)
8832 if (i
+ 1 < hdr
->sh_info
)
8833 iverneed
->vn_nextref
= iverneed
+ 1;
8835 if (iverneed
->vn_next
8836 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8837 goto error_return_bad_verref
;
8839 everneed
= ((Elf_External_Verneed
*)
8840 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8842 elf_tdata (abfd
)->cverrefs
= i
;
8848 if (elf_dynverdef (abfd
) != 0)
8850 Elf_Internal_Shdr
*hdr
;
8851 Elf_External_Verdef
*everdef
;
8852 Elf_Internal_Verdef
*iverdef
;
8853 Elf_Internal_Verdef
*iverdefarr
;
8854 Elf_Internal_Verdef iverdefmem
;
8856 unsigned int maxidx
;
8857 bfd_byte
*contents_end_def
, *contents_end_aux
;
8859 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8861 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8863 error_return_bad_verdef
:
8865 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8866 bfd_set_error (bfd_error_bad_value
);
8867 error_return_verdef
:
8868 elf_tdata (abfd
)->verdef
= NULL
;
8869 elf_tdata (abfd
)->cverdefs
= 0;
8873 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8874 goto error_return_verdef
;
8875 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8876 if (contents
== NULL
)
8877 goto error_return_verdef
;
8879 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8880 >= sizeof (Elf_External_Verdaux
));
8881 contents_end_def
= contents
+ hdr
->sh_size
8882 - sizeof (Elf_External_Verdef
);
8883 contents_end_aux
= contents
+ hdr
->sh_size
8884 - sizeof (Elf_External_Verdaux
);
8886 /* We know the number of entries in the section but not the maximum
8887 index. Therefore we have to run through all entries and find
8889 everdef
= (Elf_External_Verdef
*) contents
;
8891 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8893 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8895 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8896 goto error_return_bad_verdef
;
8897 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8898 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8900 if (iverdefmem
.vd_next
== 0)
8903 if (iverdefmem
.vd_next
8904 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8905 goto error_return_bad_verdef
;
8907 everdef
= ((Elf_External_Verdef
*)
8908 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8911 if (default_imported_symver
)
8913 if (freeidx
> maxidx
)
8918 if (_bfd_mul_overflow (maxidx
, sizeof (Elf_Internal_Verdef
), &amt
))
8920 bfd_set_error (bfd_error_file_too_big
);
8921 goto error_return_verdef
;
8923 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
8924 if (elf_tdata (abfd
)->verdef
== NULL
)
8925 goto error_return_verdef
;
8927 elf_tdata (abfd
)->cverdefs
= maxidx
;
8929 everdef
= (Elf_External_Verdef
*) contents
;
8930 iverdefarr
= elf_tdata (abfd
)->verdef
;
8931 for (i
= 0; i
< hdr
->sh_info
; i
++)
8933 Elf_External_Verdaux
*everdaux
;
8934 Elf_Internal_Verdaux
*iverdaux
;
8937 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8939 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8940 goto error_return_bad_verdef
;
8942 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8943 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8945 iverdef
->vd_bfd
= abfd
;
8947 if (iverdef
->vd_cnt
== 0)
8948 iverdef
->vd_auxptr
= NULL
;
8951 if (_bfd_mul_overflow (iverdef
->vd_cnt
,
8952 sizeof (Elf_Internal_Verdaux
), &amt
))
8954 bfd_set_error (bfd_error_file_too_big
);
8955 goto error_return_verdef
;
8957 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8958 bfd_alloc (abfd
, amt
);
8959 if (iverdef
->vd_auxptr
== NULL
)
8960 goto error_return_verdef
;
8964 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8965 goto error_return_bad_verdef
;
8967 everdaux
= ((Elf_External_Verdaux
*)
8968 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8969 iverdaux
= iverdef
->vd_auxptr
;
8970 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8972 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8974 iverdaux
->vda_nodename
=
8975 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8976 iverdaux
->vda_name
);
8977 if (iverdaux
->vda_nodename
== NULL
)
8978 goto error_return_bad_verdef
;
8980 iverdaux
->vda_nextptr
= NULL
;
8981 if (iverdaux
->vda_next
== 0)
8983 iverdef
->vd_cnt
= j
+ 1;
8986 if (j
+ 1 < iverdef
->vd_cnt
)
8987 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8989 if (iverdaux
->vda_next
8990 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8991 goto error_return_bad_verdef
;
8993 everdaux
= ((Elf_External_Verdaux
*)
8994 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8997 iverdef
->vd_nodename
= NULL
;
8998 if (iverdef
->vd_cnt
)
8999 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
9001 iverdef
->vd_nextdef
= NULL
;
9002 if (iverdef
->vd_next
== 0)
9004 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
9005 iverdef
->vd_nextdef
= iverdef
+ 1;
9007 everdef
= ((Elf_External_Verdef
*)
9008 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
9014 else if (default_imported_symver
)
9021 if (_bfd_mul_overflow (freeidx
, sizeof (Elf_Internal_Verdef
), &amt
))
9023 bfd_set_error (bfd_error_file_too_big
);
9026 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
9027 if (elf_tdata (abfd
)->verdef
== NULL
)
9030 elf_tdata (abfd
)->cverdefs
= freeidx
;
9033 /* Create a default version based on the soname. */
9034 if (default_imported_symver
)
9036 Elf_Internal_Verdef
*iverdef
;
9037 Elf_Internal_Verdaux
*iverdaux
;
9039 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
9041 iverdef
->vd_version
= VER_DEF_CURRENT
;
9042 iverdef
->vd_flags
= 0;
9043 iverdef
->vd_ndx
= freeidx
;
9044 iverdef
->vd_cnt
= 1;
9046 iverdef
->vd_bfd
= abfd
;
9048 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
9049 if (iverdef
->vd_nodename
== NULL
)
9050 goto error_return_verdef
;
9051 iverdef
->vd_nextdef
= NULL
;
9052 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
9053 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
9054 if (iverdef
->vd_auxptr
== NULL
)
9055 goto error_return_verdef
;
9057 iverdaux
= iverdef
->vd_auxptr
;
9058 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
9069 _bfd_elf_make_empty_symbol (bfd
*abfd
)
9071 elf_symbol_type
*newsym
;
9073 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
9076 newsym
->symbol
.the_bfd
= abfd
;
9077 return &newsym
->symbol
;
9081 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
9085 bfd_symbol_info (symbol
, ret
);
9088 /* Return whether a symbol name implies a local symbol. Most targets
9089 use this function for the is_local_label_name entry point, but some
9093 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
9096 /* Normal local symbols start with ``.L''. */
9097 if (name
[0] == '.' && name
[1] == 'L')
9100 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
9101 DWARF debugging symbols starting with ``..''. */
9102 if (name
[0] == '.' && name
[1] == '.')
9105 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
9106 emitting DWARF debugging output. I suspect this is actually a
9107 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
9108 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
9109 underscore to be emitted on some ELF targets). For ease of use,
9110 we treat such symbols as local. */
9111 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
9114 /* Treat assembler generated fake symbols, dollar local labels and
9115 forward-backward labels (aka local labels) as locals.
9116 These labels have the form:
9118 L0^A.* (fake symbols)
9120 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
9122 Versions which start with .L will have already been matched above,
9123 so we only need to match the rest. */
9124 if (name
[0] == 'L' && ISDIGIT (name
[1]))
9130 for (p
= name
+ 2; (c
= *p
); p
++)
9132 if (c
== 1 || c
== 2)
9134 if (c
== 1 && p
== name
+ 2)
9135 /* A fake symbol. */
9138 /* FIXME: We are being paranoid here and treating symbols like
9139 L0^Bfoo as if there were non-local, on the grounds that the
9140 assembler will never generate them. But can any symbol
9141 containing an ASCII value in the range 1-31 ever be anything
9142 other than some kind of local ? */
9159 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9160 asymbol
*symbol ATTRIBUTE_UNUSED
)
9167 _bfd_elf_set_arch_mach (bfd
*abfd
,
9168 enum bfd_architecture arch
,
9169 unsigned long machine
)
9171 /* If this isn't the right architecture for this backend, and this
9172 isn't the generic backend, fail. */
9173 if (arch
!= get_elf_backend_data (abfd
)->arch
9174 && arch
!= bfd_arch_unknown
9175 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9178 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9181 /* Find the nearest line to a particular section and offset,
9182 for error reporting. */
9185 _bfd_elf_find_nearest_line (bfd
*abfd
,
9189 const char **filename_ptr
,
9190 const char **functionname_ptr
,
9191 unsigned int *line_ptr
,
9192 unsigned int *discriminator_ptr
)
9196 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9197 filename_ptr
, functionname_ptr
,
9198 line_ptr
, discriminator_ptr
,
9199 dwarf_debug_sections
,
9200 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9203 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9204 filename_ptr
, functionname_ptr
, line_ptr
))
9206 if (!*functionname_ptr
)
9207 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9208 *filename_ptr
? NULL
: filename_ptr
,
9213 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9214 &found
, filename_ptr
,
9215 functionname_ptr
, line_ptr
,
9216 &elf_tdata (abfd
)->line_info
))
9218 if (found
&& (*functionname_ptr
|| *line_ptr
))
9221 if (symbols
== NULL
)
9224 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9225 filename_ptr
, functionname_ptr
))
9232 /* Find the line for a symbol. */
9235 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9236 const char **filename_ptr
, unsigned int *line_ptr
)
9238 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9239 filename_ptr
, NULL
, line_ptr
, NULL
,
9240 dwarf_debug_sections
,
9241 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9244 /* After a call to bfd_find_nearest_line, successive calls to
9245 bfd_find_inliner_info can be used to get source information about
9246 each level of function inlining that terminated at the address
9247 passed to bfd_find_nearest_line. Currently this is only supported
9248 for DWARF2 with appropriate DWARF3 extensions. */
9251 _bfd_elf_find_inliner_info (bfd
*abfd
,
9252 const char **filename_ptr
,
9253 const char **functionname_ptr
,
9254 unsigned int *line_ptr
)
9257 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9258 functionname_ptr
, line_ptr
,
9259 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9264 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9266 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9267 int ret
= bed
->s
->sizeof_ehdr
;
9269 if (!bfd_link_relocatable (info
))
9271 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9273 if (phdr_size
== (bfd_size_type
) -1)
9275 struct elf_segment_map
*m
;
9278 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9279 phdr_size
+= bed
->s
->sizeof_phdr
;
9282 phdr_size
= get_program_header_size (abfd
, info
);
9285 elf_program_header_size (abfd
) = phdr_size
;
9293 _bfd_elf_set_section_contents (bfd
*abfd
,
9295 const void *location
,
9297 bfd_size_type count
)
9299 Elf_Internal_Shdr
*hdr
;
9302 if (! abfd
->output_has_begun
9303 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9309 hdr
= &elf_section_data (section
)->this_hdr
;
9310 if (hdr
->sh_offset
== (file_ptr
) -1)
9312 unsigned char *contents
;
9314 if (bfd_section_is_ctf (section
))
9315 /* Nothing to do with this section: the contents are generated
9319 if ((section
->flags
& SEC_ELF_COMPRESS
) == 0)
9322 (_("%pB:%pA: error: attempting to write into an unallocated compressed section"),
9324 bfd_set_error (bfd_error_invalid_operation
);
9328 if ((offset
+ count
) > hdr
->sh_size
)
9331 (_("%pB:%pA: error: attempting to write over the end of the section"),
9334 bfd_set_error (bfd_error_invalid_operation
);
9338 contents
= hdr
->contents
;
9339 if (contents
== NULL
)
9342 (_("%pB:%pA: error: attempting to write section into an empty buffer"),
9345 bfd_set_error (bfd_error_invalid_operation
);
9349 memcpy (contents
+ offset
, location
, count
);
9353 pos
= hdr
->sh_offset
+ offset
;
9354 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9355 || bfd_bwrite (location
, count
, abfd
) != count
)
9362 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9363 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9364 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9370 /* Try to convert a non-ELF reloc into an ELF one. */
9373 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9375 /* Check whether we really have an ELF howto. */
9377 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9379 bfd_reloc_code_real_type code
;
9380 reloc_howto_type
*howto
;
9382 /* Alien reloc: Try to determine its type to replace it with an
9383 equivalent ELF reloc. */
9385 if (areloc
->howto
->pc_relative
)
9387 switch (areloc
->howto
->bitsize
)
9390 code
= BFD_RELOC_8_PCREL
;
9393 code
= BFD_RELOC_12_PCREL
;
9396 code
= BFD_RELOC_16_PCREL
;
9399 code
= BFD_RELOC_24_PCREL
;
9402 code
= BFD_RELOC_32_PCREL
;
9405 code
= BFD_RELOC_64_PCREL
;
9411 howto
= bfd_reloc_type_lookup (abfd
, code
);
9413 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9415 if (howto
->pcrel_offset
)
9416 areloc
->addend
+= areloc
->address
;
9418 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9423 switch (areloc
->howto
->bitsize
)
9429 code
= BFD_RELOC_14
;
9432 code
= BFD_RELOC_16
;
9435 code
= BFD_RELOC_26
;
9438 code
= BFD_RELOC_32
;
9441 code
= BFD_RELOC_64
;
9447 howto
= bfd_reloc_type_lookup (abfd
, code
);
9451 areloc
->howto
= howto
;
9459 /* xgettext:c-format */
9460 _bfd_error_handler (_("%pB: %s unsupported"),
9461 abfd
, areloc
->howto
->name
);
9462 bfd_set_error (bfd_error_sorry
);
9467 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9469 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9471 && (bfd_get_format (abfd
) == bfd_object
9472 || bfd_get_format (abfd
) == bfd_core
))
9474 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9475 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9476 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9479 return _bfd_generic_close_and_cleanup (abfd
);
9482 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9483 in the relocation's offset. Thus we cannot allow any sort of sanity
9484 range-checking to interfere. There is nothing else to do in processing
9487 bfd_reloc_status_type
9488 _bfd_elf_rel_vtable_reloc_fn
9489 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9490 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9491 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9492 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9494 return bfd_reloc_ok
;
9497 /* Elf core file support. Much of this only works on native
9498 toolchains, since we rely on knowing the
9499 machine-dependent procfs structure in order to pick
9500 out details about the corefile. */
9502 #ifdef HAVE_SYS_PROCFS_H
9503 # include <sys/procfs.h>
9506 /* Return a PID that identifies a "thread" for threaded cores, or the
9507 PID of the main process for non-threaded cores. */
9510 elfcore_make_pid (bfd
*abfd
)
9514 pid
= elf_tdata (abfd
)->core
->lwpid
;
9516 pid
= elf_tdata (abfd
)->core
->pid
;
9521 /* If there isn't a section called NAME, make one, using
9522 data from SECT. Note, this function will generate a
9523 reference to NAME, so you shouldn't deallocate or
9527 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9531 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9534 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9538 sect2
->size
= sect
->size
;
9539 sect2
->filepos
= sect
->filepos
;
9540 sect2
->alignment_power
= sect
->alignment_power
;
9544 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9545 actually creates up to two pseudosections:
9546 - For the single-threaded case, a section named NAME, unless
9547 such a section already exists.
9548 - For the multi-threaded case, a section named "NAME/PID", where
9549 PID is elfcore_make_pid (abfd).
9550 Both pseudosections have identical contents. */
9552 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9558 char *threaded_name
;
9562 /* Build the section name. */
9564 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9565 len
= strlen (buf
) + 1;
9566 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9567 if (threaded_name
== NULL
)
9569 memcpy (threaded_name
, buf
, len
);
9571 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9576 sect
->filepos
= filepos
;
9577 sect
->alignment_power
= 2;
9579 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9583 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9586 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9592 sect
->size
= note
->descsz
- offs
;
9593 sect
->filepos
= note
->descpos
+ offs
;
9594 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9599 /* prstatus_t exists on:
9601 linux 2.[01] + glibc
9605 #if defined (HAVE_PRSTATUS_T)
9608 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9613 if (note
->descsz
== sizeof (prstatus_t
))
9617 size
= sizeof (prstat
.pr_reg
);
9618 offset
= offsetof (prstatus_t
, pr_reg
);
9619 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9621 /* Do not overwrite the core signal if it
9622 has already been set by another thread. */
9623 if (elf_tdata (abfd
)->core
->signal
== 0)
9624 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9625 if (elf_tdata (abfd
)->core
->pid
== 0)
9626 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9628 /* pr_who exists on:
9631 pr_who doesn't exist on:
9634 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9635 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9637 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9640 #if defined (HAVE_PRSTATUS32_T)
9641 else if (note
->descsz
== sizeof (prstatus32_t
))
9643 /* 64-bit host, 32-bit corefile */
9644 prstatus32_t prstat
;
9646 size
= sizeof (prstat
.pr_reg
);
9647 offset
= offsetof (prstatus32_t
, pr_reg
);
9648 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9650 /* Do not overwrite the core signal if it
9651 has already been set by another thread. */
9652 if (elf_tdata (abfd
)->core
->signal
== 0)
9653 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9654 if (elf_tdata (abfd
)->core
->pid
== 0)
9655 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9657 /* pr_who exists on:
9660 pr_who doesn't exist on:
9663 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9664 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9666 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9669 #endif /* HAVE_PRSTATUS32_T */
9672 /* Fail - we don't know how to handle any other
9673 note size (ie. data object type). */
9677 /* Make a ".reg/999" section and a ".reg" section. */
9678 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9679 size
, note
->descpos
+ offset
);
9681 #endif /* defined (HAVE_PRSTATUS_T) */
9683 /* Create a pseudosection containing the exact contents of NOTE. */
9685 elfcore_make_note_pseudosection (bfd
*abfd
,
9687 Elf_Internal_Note
*note
)
9689 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9690 note
->descsz
, note
->descpos
);
9693 /* There isn't a consistent prfpregset_t across platforms,
9694 but it doesn't matter, because we don't have to pick this
9695 data structure apart. */
9698 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9700 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9703 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9704 type of NT_PRXFPREG. Just include the whole note's contents
9708 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9710 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9713 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9714 with a note type of NT_X86_XSTATE. Just include the whole note's
9715 contents literally. */
9718 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9720 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9724 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9726 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9730 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9732 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9736 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9738 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9742 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9744 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9748 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9750 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9754 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9756 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9760 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9762 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9766 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9768 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9772 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9774 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9778 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9780 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9784 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9786 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9790 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9792 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9796 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9798 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9802 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9804 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9808 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9810 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9814 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9816 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9820 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9822 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9826 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9828 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9832 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9834 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9838 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9840 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9844 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9846 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9850 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9852 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9856 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9858 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9862 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9864 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9868 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9870 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9874 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9876 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9880 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9882 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9886 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9888 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9892 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9894 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9898 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9900 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9904 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9906 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9910 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9912 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9916 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9918 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9922 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9924 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9928 elfcore_grok_arc_v2 (bfd
*abfd
, Elf_Internal_Note
*note
)
9930 return elfcore_make_note_pseudosection (abfd
, ".reg-arc-v2", note
);
9933 /* Convert NOTE into a bfd_section called ".reg-riscv-csr". Return TRUE if
9934 successful otherwise, return FALSE. */
9937 elfcore_grok_riscv_csr (bfd
*abfd
, Elf_Internal_Note
*note
)
9939 return elfcore_make_note_pseudosection (abfd
, ".reg-riscv-csr", note
);
9942 /* Convert NOTE into a bfd_section called ".gdb-tdesc". Return TRUE if
9943 successful otherwise, return FALSE. */
9946 elfcore_grok_gdb_tdesc (bfd
*abfd
, Elf_Internal_Note
*note
)
9948 return elfcore_make_note_pseudosection (abfd
, ".gdb-tdesc", note
);
9951 #if defined (HAVE_PRPSINFO_T)
9952 typedef prpsinfo_t elfcore_psinfo_t
;
9953 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9954 typedef prpsinfo32_t elfcore_psinfo32_t
;
9958 #if defined (HAVE_PSINFO_T)
9959 typedef psinfo_t elfcore_psinfo_t
;
9960 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9961 typedef psinfo32_t elfcore_psinfo32_t
;
9965 /* return a malloc'ed copy of a string at START which is at
9966 most MAX bytes long, possibly without a terminating '\0'.
9967 the copy will always have a terminating '\0'. */
9970 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9973 char *end
= (char *) memchr (start
, '\0', max
);
9981 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9985 memcpy (dups
, start
, len
);
9991 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9993 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9995 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9997 elfcore_psinfo_t psinfo
;
9999 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10001 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
10002 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10004 elf_tdata (abfd
)->core
->program
10005 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10006 sizeof (psinfo
.pr_fname
));
10008 elf_tdata (abfd
)->core
->command
10009 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10010 sizeof (psinfo
.pr_psargs
));
10012 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10013 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
10015 /* 64-bit host, 32-bit corefile */
10016 elfcore_psinfo32_t psinfo
;
10018 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10020 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
10021 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10023 elf_tdata (abfd
)->core
->program
10024 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10025 sizeof (psinfo
.pr_fname
));
10027 elf_tdata (abfd
)->core
->command
10028 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10029 sizeof (psinfo
.pr_psargs
));
10035 /* Fail - we don't know how to handle any other
10036 note size (ie. data object type). */
10040 /* Note that for some reason, a spurious space is tacked
10041 onto the end of the args in some (at least one anyway)
10042 implementations, so strip it off if it exists. */
10045 char *command
= elf_tdata (abfd
)->core
->command
;
10046 int n
= strlen (command
);
10048 if (0 < n
&& command
[n
- 1] == ' ')
10049 command
[n
- 1] = '\0';
10054 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
10056 #if defined (HAVE_PSTATUS_T)
10058 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10060 if (note
->descsz
== sizeof (pstatus_t
)
10061 #if defined (HAVE_PXSTATUS_T)
10062 || note
->descsz
== sizeof (pxstatus_t
)
10068 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10070 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10072 #if defined (HAVE_PSTATUS32_T)
10073 else if (note
->descsz
== sizeof (pstatus32_t
))
10075 /* 64-bit host, 32-bit corefile */
10078 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10080 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10083 /* Could grab some more details from the "representative"
10084 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
10085 NT_LWPSTATUS note, presumably. */
10089 #endif /* defined (HAVE_PSTATUS_T) */
10091 #if defined (HAVE_LWPSTATUS_T)
10093 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10095 lwpstatus_t lwpstat
;
10101 if (note
->descsz
!= sizeof (lwpstat
)
10102 #if defined (HAVE_LWPXSTATUS_T)
10103 && note
->descsz
!= sizeof (lwpxstatus_t
)
10108 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
10110 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
10111 /* Do not overwrite the core signal if it has already been set by
10113 if (elf_tdata (abfd
)->core
->signal
== 0)
10114 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
10116 /* Make a ".reg/999" section. */
10118 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
10119 len
= strlen (buf
) + 1;
10120 name
= bfd_alloc (abfd
, len
);
10123 memcpy (name
, buf
, len
);
10125 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10129 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10130 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
10131 sect
->filepos
= note
->descpos
10132 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
10135 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10136 sect
->size
= sizeof (lwpstat
.pr_reg
);
10137 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
10140 sect
->alignment_power
= 2;
10142 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10145 /* Make a ".reg2/999" section */
10147 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
10148 len
= strlen (buf
) + 1;
10149 name
= bfd_alloc (abfd
, len
);
10152 memcpy (name
, buf
, len
);
10154 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10158 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10159 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
10160 sect
->filepos
= note
->descpos
10161 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
10164 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
10165 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
10166 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
10169 sect
->alignment_power
= 2;
10171 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
10173 #endif /* defined (HAVE_LWPSTATUS_T) */
10175 /* These constants, and the structure offsets used below, are defined by
10176 Cygwin's core_dump.h */
10177 #define NOTE_INFO_PROCESS 1
10178 #define NOTE_INFO_THREAD 2
10179 #define NOTE_INFO_MODULE 3
10180 #define NOTE_INFO_MODULE64 4
10183 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10188 unsigned int name_size
;
10191 int is_active_thread
;
10194 if (note
->descsz
< 4)
10197 if (! startswith (note
->namedata
, "win32"))
10200 type
= bfd_get_32 (abfd
, note
->descdata
);
10204 const char *type_name
;
10205 unsigned long min_size
;
10208 { "NOTE_INFO_PROCESS", 12 },
10209 { "NOTE_INFO_THREAD", 12 },
10210 { "NOTE_INFO_MODULE", 12 },
10211 { "NOTE_INFO_MODULE64", 16 },
10214 if (type
== 0 || type
> (sizeof(size_check
)/sizeof(size_check
[0])))
10217 if (note
->descsz
< size_check
[type
- 1].min_size
)
10219 _bfd_error_handler (_("%pB: warning: win32pstatus %s of size %lu bytes is too small"),
10220 abfd
, size_check
[type
- 1].type_name
, note
->descsz
);
10226 case NOTE_INFO_PROCESS
:
10227 /* FIXME: need to add ->core->command. */
10228 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10229 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10232 case NOTE_INFO_THREAD
:
10233 /* Make a ".reg/<tid>" section containing the Win32 API thread CONTEXT
10235 /* thread_info.tid */
10236 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 4));
10238 len
= strlen (buf
) + 1;
10239 name
= (char *) bfd_alloc (abfd
, len
);
10243 memcpy (name
, buf
, len
);
10245 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10249 /* sizeof (thread_info.thread_context) */
10250 sect
->size
= note
->descsz
- 12;
10251 /* offsetof (thread_info.thread_context) */
10252 sect
->filepos
= note
->descpos
+ 12;
10253 sect
->alignment_power
= 2;
10255 /* thread_info.is_active_thread */
10256 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10258 if (is_active_thread
)
10259 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10263 case NOTE_INFO_MODULE
:
10264 case NOTE_INFO_MODULE64
:
10265 /* Make a ".module/xxxxxxxx" section. */
10266 if (type
== NOTE_INFO_MODULE
)
10268 /* module_info.base_address */
10269 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10270 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10271 /* module_info.module_name_size */
10272 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10274 else /* NOTE_INFO_MODULE64 */
10276 /* module_info.base_address */
10277 base_addr
= bfd_get_64 (abfd
, note
->descdata
+ 4);
10278 sprintf (buf
, ".module/%016lx", (unsigned long) base_addr
);
10279 /* module_info.module_name_size */
10280 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10283 len
= strlen (buf
) + 1;
10284 name
= (char *) bfd_alloc (abfd
, len
);
10288 memcpy (name
, buf
, len
);
10290 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10295 if (note
->descsz
< 12 + name_size
)
10297 _bfd_error_handler (_("%pB: win32pstatus NOTE_INFO_MODULE of size %lu is too small to contain a name of size %u"),
10298 abfd
, note
->descsz
, name_size
);
10302 sect
->size
= note
->descsz
;
10303 sect
->filepos
= note
->descpos
;
10304 sect
->alignment_power
= 2;
10315 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10317 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10319 switch (note
->type
)
10325 if (bed
->elf_backend_grok_prstatus
)
10326 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10328 #if defined (HAVE_PRSTATUS_T)
10329 return elfcore_grok_prstatus (abfd
, note
);
10334 #if defined (HAVE_PSTATUS_T)
10336 return elfcore_grok_pstatus (abfd
, note
);
10339 #if defined (HAVE_LWPSTATUS_T)
10341 return elfcore_grok_lwpstatus (abfd
, note
);
10344 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10345 return elfcore_grok_prfpreg (abfd
, note
);
10347 case NT_WIN32PSTATUS
:
10348 return elfcore_grok_win32pstatus (abfd
, note
);
10350 case NT_PRXFPREG
: /* Linux SSE extension */
10351 if (note
->namesz
== 6
10352 && strcmp (note
->namedata
, "LINUX") == 0)
10353 return elfcore_grok_prxfpreg (abfd
, note
);
10357 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10358 if (note
->namesz
== 6
10359 && strcmp (note
->namedata
, "LINUX") == 0)
10360 return elfcore_grok_xstatereg (abfd
, note
);
10365 if (note
->namesz
== 6
10366 && strcmp (note
->namedata
, "LINUX") == 0)
10367 return elfcore_grok_ppc_vmx (abfd
, note
);
10372 if (note
->namesz
== 6
10373 && strcmp (note
->namedata
, "LINUX") == 0)
10374 return elfcore_grok_ppc_vsx (abfd
, note
);
10379 if (note
->namesz
== 6
10380 && strcmp (note
->namedata
, "LINUX") == 0)
10381 return elfcore_grok_ppc_tar (abfd
, note
);
10386 if (note
->namesz
== 6
10387 && strcmp (note
->namedata
, "LINUX") == 0)
10388 return elfcore_grok_ppc_ppr (abfd
, note
);
10393 if (note
->namesz
== 6
10394 && strcmp (note
->namedata
, "LINUX") == 0)
10395 return elfcore_grok_ppc_dscr (abfd
, note
);
10400 if (note
->namesz
== 6
10401 && strcmp (note
->namedata
, "LINUX") == 0)
10402 return elfcore_grok_ppc_ebb (abfd
, note
);
10407 if (note
->namesz
== 6
10408 && strcmp (note
->namedata
, "LINUX") == 0)
10409 return elfcore_grok_ppc_pmu (abfd
, note
);
10413 case NT_PPC_TM_CGPR
:
10414 if (note
->namesz
== 6
10415 && strcmp (note
->namedata
, "LINUX") == 0)
10416 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10420 case NT_PPC_TM_CFPR
:
10421 if (note
->namesz
== 6
10422 && strcmp (note
->namedata
, "LINUX") == 0)
10423 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10427 case NT_PPC_TM_CVMX
:
10428 if (note
->namesz
== 6
10429 && strcmp (note
->namedata
, "LINUX") == 0)
10430 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10434 case NT_PPC_TM_CVSX
:
10435 if (note
->namesz
== 6
10436 && strcmp (note
->namedata
, "LINUX") == 0)
10437 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10441 case NT_PPC_TM_SPR
:
10442 if (note
->namesz
== 6
10443 && strcmp (note
->namedata
, "LINUX") == 0)
10444 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10448 case NT_PPC_TM_CTAR
:
10449 if (note
->namesz
== 6
10450 && strcmp (note
->namedata
, "LINUX") == 0)
10451 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10455 case NT_PPC_TM_CPPR
:
10456 if (note
->namesz
== 6
10457 && strcmp (note
->namedata
, "LINUX") == 0)
10458 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10462 case NT_PPC_TM_CDSCR
:
10463 if (note
->namesz
== 6
10464 && strcmp (note
->namedata
, "LINUX") == 0)
10465 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10469 case NT_S390_HIGH_GPRS
:
10470 if (note
->namesz
== 6
10471 && strcmp (note
->namedata
, "LINUX") == 0)
10472 return elfcore_grok_s390_high_gprs (abfd
, note
);
10476 case NT_S390_TIMER
:
10477 if (note
->namesz
== 6
10478 && strcmp (note
->namedata
, "LINUX") == 0)
10479 return elfcore_grok_s390_timer (abfd
, note
);
10483 case NT_S390_TODCMP
:
10484 if (note
->namesz
== 6
10485 && strcmp (note
->namedata
, "LINUX") == 0)
10486 return elfcore_grok_s390_todcmp (abfd
, note
);
10490 case NT_S390_TODPREG
:
10491 if (note
->namesz
== 6
10492 && strcmp (note
->namedata
, "LINUX") == 0)
10493 return elfcore_grok_s390_todpreg (abfd
, note
);
10498 if (note
->namesz
== 6
10499 && strcmp (note
->namedata
, "LINUX") == 0)
10500 return elfcore_grok_s390_ctrs (abfd
, note
);
10504 case NT_S390_PREFIX
:
10505 if (note
->namesz
== 6
10506 && strcmp (note
->namedata
, "LINUX") == 0)
10507 return elfcore_grok_s390_prefix (abfd
, note
);
10511 case NT_S390_LAST_BREAK
:
10512 if (note
->namesz
== 6
10513 && strcmp (note
->namedata
, "LINUX") == 0)
10514 return elfcore_grok_s390_last_break (abfd
, note
);
10518 case NT_S390_SYSTEM_CALL
:
10519 if (note
->namesz
== 6
10520 && strcmp (note
->namedata
, "LINUX") == 0)
10521 return elfcore_grok_s390_system_call (abfd
, note
);
10526 if (note
->namesz
== 6
10527 && strcmp (note
->namedata
, "LINUX") == 0)
10528 return elfcore_grok_s390_tdb (abfd
, note
);
10532 case NT_S390_VXRS_LOW
:
10533 if (note
->namesz
== 6
10534 && strcmp (note
->namedata
, "LINUX") == 0)
10535 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10539 case NT_S390_VXRS_HIGH
:
10540 if (note
->namesz
== 6
10541 && strcmp (note
->namedata
, "LINUX") == 0)
10542 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10546 case NT_S390_GS_CB
:
10547 if (note
->namesz
== 6
10548 && strcmp (note
->namedata
, "LINUX") == 0)
10549 return elfcore_grok_s390_gs_cb (abfd
, note
);
10553 case NT_S390_GS_BC
:
10554 if (note
->namesz
== 6
10555 && strcmp (note
->namedata
, "LINUX") == 0)
10556 return elfcore_grok_s390_gs_bc (abfd
, note
);
10561 if (note
->namesz
== 6
10562 && strcmp (note
->namedata
, "LINUX") == 0)
10563 return elfcore_grok_arc_v2 (abfd
, note
);
10568 if (note
->namesz
== 6
10569 && strcmp (note
->namedata
, "LINUX") == 0)
10570 return elfcore_grok_arm_vfp (abfd
, note
);
10575 if (note
->namesz
== 6
10576 && strcmp (note
->namedata
, "LINUX") == 0)
10577 return elfcore_grok_aarch_tls (abfd
, note
);
10581 case NT_ARM_HW_BREAK
:
10582 if (note
->namesz
== 6
10583 && strcmp (note
->namedata
, "LINUX") == 0)
10584 return elfcore_grok_aarch_hw_break (abfd
, note
);
10588 case NT_ARM_HW_WATCH
:
10589 if (note
->namesz
== 6
10590 && strcmp (note
->namedata
, "LINUX") == 0)
10591 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10596 if (note
->namesz
== 6
10597 && strcmp (note
->namedata
, "LINUX") == 0)
10598 return elfcore_grok_aarch_sve (abfd
, note
);
10602 case NT_ARM_PAC_MASK
:
10603 if (note
->namesz
== 6
10604 && strcmp (note
->namedata
, "LINUX") == 0)
10605 return elfcore_grok_aarch_pauth (abfd
, note
);
10610 if (note
->namesz
== 4
10611 && strcmp (note
->namedata
, "GDB") == 0)
10612 return elfcore_grok_gdb_tdesc (abfd
, note
);
10617 if (note
->namesz
== 4
10618 && strcmp (note
->namedata
, "GDB") == 0)
10619 return elfcore_grok_riscv_csr (abfd
, note
);
10625 if (bed
->elf_backend_grok_psinfo
)
10626 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10628 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10629 return elfcore_grok_psinfo (abfd
, note
);
10635 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10638 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10642 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10649 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10651 struct bfd_build_id
* build_id
;
10653 if (note
->descsz
== 0)
10656 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10657 if (build_id
== NULL
)
10660 build_id
->size
= note
->descsz
;
10661 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10662 abfd
->build_id
= build_id
;
10668 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10670 switch (note
->type
)
10675 case NT_GNU_PROPERTY_TYPE_0
:
10676 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10678 case NT_GNU_BUILD_ID
:
10679 return elfobj_grok_gnu_build_id (abfd
, note
);
10684 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10686 struct sdt_note
*cur
=
10687 (struct sdt_note
*) bfd_alloc (abfd
,
10688 sizeof (struct sdt_note
) + note
->descsz
);
10690 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10691 cur
->size
= (bfd_size_type
) note
->descsz
;
10692 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10694 elf_tdata (abfd
)->sdt_note_head
= cur
;
10700 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10702 switch (note
->type
)
10705 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10713 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10717 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10720 if (note
->descsz
< 108)
10725 if (note
->descsz
< 120)
10733 /* Check for version 1 in pr_version. */
10734 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10739 /* Skip over pr_psinfosz. */
10740 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10744 offset
+= 4; /* Padding before pr_psinfosz. */
10748 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10749 elf_tdata (abfd
)->core
->program
10750 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10753 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10754 elf_tdata (abfd
)->core
->command
10755 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10758 /* Padding before pr_pid. */
10761 /* The pr_pid field was added in version "1a". */
10762 if (note
->descsz
< offset
+ 4)
10765 elf_tdata (abfd
)->core
->pid
10766 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10772 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10778 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10779 Also compute minimum size of this note. */
10780 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10784 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10788 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10789 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10796 if (note
->descsz
< min_size
)
10799 /* Check for version 1 in pr_version. */
10800 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10803 /* Extract size of pr_reg from pr_gregsetsz. */
10804 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10805 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10807 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10812 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10816 /* Skip over pr_osreldate. */
10819 /* Read signal from pr_cursig. */
10820 if (elf_tdata (abfd
)->core
->signal
== 0)
10821 elf_tdata (abfd
)->core
->signal
10822 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10825 /* Read TID from pr_pid. */
10826 elf_tdata (abfd
)->core
->lwpid
10827 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10830 /* Padding before pr_reg. */
10831 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10834 /* Make sure that there is enough data remaining in the note. */
10835 if ((note
->descsz
- offset
) < size
)
10838 /* Make a ".reg/999" section and a ".reg" section. */
10839 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10840 size
, note
->descpos
+ offset
);
10844 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10846 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10848 switch (note
->type
)
10851 if (bed
->elf_backend_grok_freebsd_prstatus
)
10852 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10854 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10857 return elfcore_grok_prfpreg (abfd
, note
);
10860 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10862 case NT_FREEBSD_THRMISC
:
10863 if (note
->namesz
== 8)
10864 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10868 case NT_FREEBSD_PROCSTAT_PROC
:
10869 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10872 case NT_FREEBSD_PROCSTAT_FILES
:
10873 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10876 case NT_FREEBSD_PROCSTAT_VMMAP
:
10877 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10880 case NT_FREEBSD_PROCSTAT_AUXV
:
10881 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10883 case NT_X86_XSTATE
:
10884 if (note
->namesz
== 8)
10885 return elfcore_grok_xstatereg (abfd
, note
);
10889 case NT_FREEBSD_PTLWPINFO
:
10890 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10894 return elfcore_grok_arm_vfp (abfd
, note
);
10902 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10906 cp
= strchr (note
->namedata
, '@');
10909 *lwpidp
= atoi(cp
+ 1);
10916 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10918 if (note
->descsz
<= 0x7c + 31)
10921 /* Signal number at offset 0x08. */
10922 elf_tdata (abfd
)->core
->signal
10923 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10925 /* Process ID at offset 0x50. */
10926 elf_tdata (abfd
)->core
->pid
10927 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10929 /* Command name at 0x7c (max 32 bytes, including nul). */
10930 elf_tdata (abfd
)->core
->command
10931 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10933 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10938 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10942 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10943 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10945 switch (note
->type
)
10947 case NT_NETBSDCORE_PROCINFO
:
10948 /* NetBSD-specific core "procinfo". Note that we expect to
10949 find this note before any of the others, which is fine,
10950 since the kernel writes this note out first when it
10951 creates a core file. */
10952 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10953 case NT_NETBSDCORE_AUXV
:
10954 /* NetBSD-specific Elf Auxiliary Vector data. */
10955 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10956 case NT_NETBSDCORE_LWPSTATUS
:
10957 return elfcore_make_note_pseudosection (abfd
,
10958 ".note.netbsdcore.lwpstatus",
10964 /* As of March 2020 there are no other machine-independent notes
10965 defined for NetBSD core files. If the note type is less
10966 than the start of the machine-dependent note types, we don't
10969 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10973 switch (bfd_get_arch (abfd
))
10975 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10976 PT_GETFPREGS == mach+2. */
10978 case bfd_arch_aarch64
:
10979 case bfd_arch_alpha
:
10980 case bfd_arch_sparc
:
10981 switch (note
->type
)
10983 case NT_NETBSDCORE_FIRSTMACH
+0:
10984 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10986 case NT_NETBSDCORE_FIRSTMACH
+2:
10987 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10993 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10994 There's also old PT___GETREGS40 == mach + 1 for old reg
10995 structure which lacks GBR. */
10998 switch (note
->type
)
11000 case NT_NETBSDCORE_FIRSTMACH
+3:
11001 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11003 case NT_NETBSDCORE_FIRSTMACH
+5:
11004 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11010 /* On all other arch's, PT_GETREGS == mach+1 and
11011 PT_GETFPREGS == mach+3. */
11014 switch (note
->type
)
11016 case NT_NETBSDCORE_FIRSTMACH
+1:
11017 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11019 case NT_NETBSDCORE_FIRSTMACH
+3:
11020 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11030 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
11032 if (note
->descsz
<= 0x48 + 31)
11035 /* Signal number at offset 0x08. */
11036 elf_tdata (abfd
)->core
->signal
11037 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
11039 /* Process ID at offset 0x20. */
11040 elf_tdata (abfd
)->core
->pid
11041 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
11043 /* Command name at 0x48 (max 32 bytes, including nul). */
11044 elf_tdata (abfd
)->core
->command
11045 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
11051 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11053 if (note
->type
== NT_OPENBSD_PROCINFO
)
11054 return elfcore_grok_openbsd_procinfo (abfd
, note
);
11056 if (note
->type
== NT_OPENBSD_REGS
)
11057 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11059 if (note
->type
== NT_OPENBSD_FPREGS
)
11060 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11062 if (note
->type
== NT_OPENBSD_XFPREGS
)
11063 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
11065 if (note
->type
== NT_OPENBSD_AUXV
)
11066 return elfcore_make_auxv_note_section (abfd
, note
, 0);
11068 if (note
->type
== NT_OPENBSD_WCOOKIE
)
11070 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
11075 sect
->size
= note
->descsz
;
11076 sect
->filepos
= note
->descpos
;
11077 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
11086 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
11088 void *ddata
= note
->descdata
;
11095 if (note
->descsz
< 16)
11098 /* nto_procfs_status 'pid' field is at offset 0. */
11099 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
11101 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
11102 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
11104 /* nto_procfs_status 'flags' field is at offset 8. */
11105 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
11107 /* nto_procfs_status 'what' field is at offset 14. */
11108 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
11110 elf_tdata (abfd
)->core
->signal
= sig
;
11111 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11114 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
11115 do not come from signals so we make sure we set the current
11116 thread just in case. */
11117 if (flags
& 0x00000080)
11118 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11120 /* Make a ".qnx_core_status/%d" section. */
11121 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
11123 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11126 strcpy (name
, buf
);
11128 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11132 sect
->size
= note
->descsz
;
11133 sect
->filepos
= note
->descpos
;
11134 sect
->alignment_power
= 2;
11136 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
11140 elfcore_grok_nto_regs (bfd
*abfd
,
11141 Elf_Internal_Note
*note
,
11149 /* Make a "(base)/%d" section. */
11150 sprintf (buf
, "%s/%ld", base
, tid
);
11152 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11155 strcpy (name
, buf
);
11157 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11161 sect
->size
= note
->descsz
;
11162 sect
->filepos
= note
->descpos
;
11163 sect
->alignment_power
= 2;
11165 /* This is the current thread. */
11166 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
11167 return elfcore_maybe_make_sect (abfd
, base
, sect
);
11172 #define BFD_QNT_CORE_INFO 7
11173 #define BFD_QNT_CORE_STATUS 8
11174 #define BFD_QNT_CORE_GREG 9
11175 #define BFD_QNT_CORE_FPREG 10
11178 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11180 /* Every GREG section has a STATUS section before it. Store the
11181 tid from the previous call to pass down to the next gregs
11183 static long tid
= 1;
11185 switch (note
->type
)
11187 case BFD_QNT_CORE_INFO
:
11188 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
11189 case BFD_QNT_CORE_STATUS
:
11190 return elfcore_grok_nto_status (abfd
, note
, &tid
);
11191 case BFD_QNT_CORE_GREG
:
11192 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
11193 case BFD_QNT_CORE_FPREG
:
11194 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
11201 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11207 /* Use note name as section name. */
11208 len
= note
->namesz
;
11209 name
= (char *) bfd_alloc (abfd
, len
);
11212 memcpy (name
, note
->namedata
, len
);
11213 name
[len
- 1] = '\0';
11215 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11219 sect
->size
= note
->descsz
;
11220 sect
->filepos
= note
->descpos
;
11221 sect
->alignment_power
= 1;
11226 /* Function: elfcore_write_note
11229 buffer to hold note, and current size of buffer
11233 size of data for note
11235 Writes note to end of buffer. ELF64 notes are written exactly as
11236 for ELF32, despite the current (as of 2006) ELF gabi specifying
11237 that they ought to have 8-byte namesz and descsz field, and have
11238 8-byte alignment. Other writers, eg. Linux kernel, do the same.
11241 Pointer to realloc'd buffer, *BUFSIZ updated. */
11244 elfcore_write_note (bfd
*abfd
,
11252 Elf_External_Note
*xnp
;
11259 namesz
= strlen (name
) + 1;
11261 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
11263 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
11266 dest
= buf
+ *bufsiz
;
11267 *bufsiz
+= newspace
;
11268 xnp
= (Elf_External_Note
*) dest
;
11269 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
11270 H_PUT_32 (abfd
, size
, xnp
->descsz
);
11271 H_PUT_32 (abfd
, type
, xnp
->type
);
11275 memcpy (dest
, name
, namesz
);
11283 memcpy (dest
, input
, size
);
11293 /* gcc-8 warns (*) on all the strncpy calls in this function about
11294 possible string truncation. The "truncation" is not a bug. We
11295 have an external representation of structs with fields that are not
11296 necessarily NULL terminated and corresponding internal
11297 representation fields that are one larger so that they can always
11298 be NULL terminated.
11299 gcc versions between 4.2 and 4.6 do not allow pragma control of
11300 diagnostics inside functions, giving a hard error if you try to use
11301 the finer control available with later versions.
11302 gcc prior to 4.2 warns about diagnostic push and pop.
11303 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11304 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11305 (*) Depending on your system header files! */
11306 #if GCC_VERSION >= 8000
11307 # pragma GCC diagnostic push
11308 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11311 elfcore_write_prpsinfo (bfd
*abfd
,
11315 const char *psargs
)
11317 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11319 if (bed
->elf_backend_write_core_note
!= NULL
)
11322 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11323 NT_PRPSINFO
, fname
, psargs
);
11328 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11329 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11330 if (bed
->s
->elfclass
== ELFCLASS32
)
11332 # if defined (HAVE_PSINFO32_T)
11334 int note_type
= NT_PSINFO
;
11337 int note_type
= NT_PRPSINFO
;
11340 memset (&data
, 0, sizeof (data
));
11341 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11342 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11343 return elfcore_write_note (abfd
, buf
, bufsiz
,
11344 "CORE", note_type
, &data
, sizeof (data
));
11349 # if defined (HAVE_PSINFO_T)
11351 int note_type
= NT_PSINFO
;
11354 int note_type
= NT_PRPSINFO
;
11357 memset (&data
, 0, sizeof (data
));
11358 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11359 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11360 return elfcore_write_note (abfd
, buf
, bufsiz
,
11361 "CORE", note_type
, &data
, sizeof (data
));
11363 #endif /* PSINFO_T or PRPSINFO_T */
11368 #if GCC_VERSION >= 8000
11369 # pragma GCC diagnostic pop
11373 elfcore_write_linux_prpsinfo32
11374 (bfd
*abfd
, char *buf
, int *bufsiz
,
11375 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11377 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11379 struct elf_external_linux_prpsinfo32_ugid16 data
;
11381 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11382 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11383 &data
, sizeof (data
));
11387 struct elf_external_linux_prpsinfo32_ugid32 data
;
11389 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11390 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11391 &data
, sizeof (data
));
11396 elfcore_write_linux_prpsinfo64
11397 (bfd
*abfd
, char *buf
, int *bufsiz
,
11398 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11400 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11402 struct elf_external_linux_prpsinfo64_ugid16 data
;
11404 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11405 return elfcore_write_note (abfd
, buf
, bufsiz
,
11406 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11410 struct elf_external_linux_prpsinfo64_ugid32 data
;
11412 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11413 return elfcore_write_note (abfd
, buf
, bufsiz
,
11414 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11419 elfcore_write_prstatus (bfd
*abfd
,
11426 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11428 if (bed
->elf_backend_write_core_note
!= NULL
)
11431 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11433 pid
, cursig
, gregs
);
11438 #if defined (HAVE_PRSTATUS_T)
11439 #if defined (HAVE_PRSTATUS32_T)
11440 if (bed
->s
->elfclass
== ELFCLASS32
)
11442 prstatus32_t prstat
;
11444 memset (&prstat
, 0, sizeof (prstat
));
11445 prstat
.pr_pid
= pid
;
11446 prstat
.pr_cursig
= cursig
;
11447 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11448 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11449 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11456 memset (&prstat
, 0, sizeof (prstat
));
11457 prstat
.pr_pid
= pid
;
11458 prstat
.pr_cursig
= cursig
;
11459 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11460 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11461 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11463 #endif /* HAVE_PRSTATUS_T */
11469 #if defined (HAVE_LWPSTATUS_T)
11471 elfcore_write_lwpstatus (bfd
*abfd
,
11478 lwpstatus_t lwpstat
;
11479 const char *note_name
= "CORE";
11481 memset (&lwpstat
, 0, sizeof (lwpstat
));
11482 lwpstat
.pr_lwpid
= pid
>> 16;
11483 lwpstat
.pr_cursig
= cursig
;
11484 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11485 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11486 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11487 #if !defined(gregs)
11488 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11489 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11491 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11492 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11495 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11496 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11498 #endif /* HAVE_LWPSTATUS_T */
11500 #if defined (HAVE_PSTATUS_T)
11502 elfcore_write_pstatus (bfd
*abfd
,
11506 int cursig ATTRIBUTE_UNUSED
,
11507 const void *gregs ATTRIBUTE_UNUSED
)
11509 const char *note_name
= "CORE";
11510 #if defined (HAVE_PSTATUS32_T)
11511 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11513 if (bed
->s
->elfclass
== ELFCLASS32
)
11517 memset (&pstat
, 0, sizeof (pstat
));
11518 pstat
.pr_pid
= pid
& 0xffff;
11519 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11520 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11528 memset (&pstat
, 0, sizeof (pstat
));
11529 pstat
.pr_pid
= pid
& 0xffff;
11530 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11531 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11535 #endif /* HAVE_PSTATUS_T */
11538 elfcore_write_prfpreg (bfd
*abfd
,
11541 const void *fpregs
,
11544 const char *note_name
= "CORE";
11545 return elfcore_write_note (abfd
, buf
, bufsiz
,
11546 note_name
, NT_FPREGSET
, fpregs
, size
);
11550 elfcore_write_prxfpreg (bfd
*abfd
,
11553 const void *xfpregs
,
11556 char *note_name
= "LINUX";
11557 return elfcore_write_note (abfd
, buf
, bufsiz
,
11558 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11562 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11563 const void *xfpregs
, int size
)
11566 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11567 note_name
= "FreeBSD";
11569 note_name
= "LINUX";
11570 return elfcore_write_note (abfd
, buf
, bufsiz
,
11571 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11575 elfcore_write_ppc_vmx (bfd
*abfd
,
11578 const void *ppc_vmx
,
11581 char *note_name
= "LINUX";
11582 return elfcore_write_note (abfd
, buf
, bufsiz
,
11583 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11587 elfcore_write_ppc_vsx (bfd
*abfd
,
11590 const void *ppc_vsx
,
11593 char *note_name
= "LINUX";
11594 return elfcore_write_note (abfd
, buf
, bufsiz
,
11595 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11599 elfcore_write_ppc_tar (bfd
*abfd
,
11602 const void *ppc_tar
,
11605 char *note_name
= "LINUX";
11606 return elfcore_write_note (abfd
, buf
, bufsiz
,
11607 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11611 elfcore_write_ppc_ppr (bfd
*abfd
,
11614 const void *ppc_ppr
,
11617 char *note_name
= "LINUX";
11618 return elfcore_write_note (abfd
, buf
, bufsiz
,
11619 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11623 elfcore_write_ppc_dscr (bfd
*abfd
,
11626 const void *ppc_dscr
,
11629 char *note_name
= "LINUX";
11630 return elfcore_write_note (abfd
, buf
, bufsiz
,
11631 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11635 elfcore_write_ppc_ebb (bfd
*abfd
,
11638 const void *ppc_ebb
,
11641 char *note_name
= "LINUX";
11642 return elfcore_write_note (abfd
, buf
, bufsiz
,
11643 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11647 elfcore_write_ppc_pmu (bfd
*abfd
,
11650 const void *ppc_pmu
,
11653 char *note_name
= "LINUX";
11654 return elfcore_write_note (abfd
, buf
, bufsiz
,
11655 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11659 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11662 const void *ppc_tm_cgpr
,
11665 char *note_name
= "LINUX";
11666 return elfcore_write_note (abfd
, buf
, bufsiz
,
11667 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11671 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11674 const void *ppc_tm_cfpr
,
11677 char *note_name
= "LINUX";
11678 return elfcore_write_note (abfd
, buf
, bufsiz
,
11679 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11683 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11686 const void *ppc_tm_cvmx
,
11689 char *note_name
= "LINUX";
11690 return elfcore_write_note (abfd
, buf
, bufsiz
,
11691 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11695 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11698 const void *ppc_tm_cvsx
,
11701 char *note_name
= "LINUX";
11702 return elfcore_write_note (abfd
, buf
, bufsiz
,
11703 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11707 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11710 const void *ppc_tm_spr
,
11713 char *note_name
= "LINUX";
11714 return elfcore_write_note (abfd
, buf
, bufsiz
,
11715 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11719 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11722 const void *ppc_tm_ctar
,
11725 char *note_name
= "LINUX";
11726 return elfcore_write_note (abfd
, buf
, bufsiz
,
11727 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11731 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11734 const void *ppc_tm_cppr
,
11737 char *note_name
= "LINUX";
11738 return elfcore_write_note (abfd
, buf
, bufsiz
,
11739 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11743 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11746 const void *ppc_tm_cdscr
,
11749 char *note_name
= "LINUX";
11750 return elfcore_write_note (abfd
, buf
, bufsiz
,
11751 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11755 elfcore_write_s390_high_gprs (bfd
*abfd
,
11758 const void *s390_high_gprs
,
11761 char *note_name
= "LINUX";
11762 return elfcore_write_note (abfd
, buf
, bufsiz
,
11763 note_name
, NT_S390_HIGH_GPRS
,
11764 s390_high_gprs
, size
);
11768 elfcore_write_s390_timer (bfd
*abfd
,
11771 const void *s390_timer
,
11774 char *note_name
= "LINUX";
11775 return elfcore_write_note (abfd
, buf
, bufsiz
,
11776 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11780 elfcore_write_s390_todcmp (bfd
*abfd
,
11783 const void *s390_todcmp
,
11786 char *note_name
= "LINUX";
11787 return elfcore_write_note (abfd
, buf
, bufsiz
,
11788 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11792 elfcore_write_s390_todpreg (bfd
*abfd
,
11795 const void *s390_todpreg
,
11798 char *note_name
= "LINUX";
11799 return elfcore_write_note (abfd
, buf
, bufsiz
,
11800 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11804 elfcore_write_s390_ctrs (bfd
*abfd
,
11807 const void *s390_ctrs
,
11810 char *note_name
= "LINUX";
11811 return elfcore_write_note (abfd
, buf
, bufsiz
,
11812 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11816 elfcore_write_s390_prefix (bfd
*abfd
,
11819 const void *s390_prefix
,
11822 char *note_name
= "LINUX";
11823 return elfcore_write_note (abfd
, buf
, bufsiz
,
11824 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11828 elfcore_write_s390_last_break (bfd
*abfd
,
11831 const void *s390_last_break
,
11834 char *note_name
= "LINUX";
11835 return elfcore_write_note (abfd
, buf
, bufsiz
,
11836 note_name
, NT_S390_LAST_BREAK
,
11837 s390_last_break
, size
);
11841 elfcore_write_s390_system_call (bfd
*abfd
,
11844 const void *s390_system_call
,
11847 char *note_name
= "LINUX";
11848 return elfcore_write_note (abfd
, buf
, bufsiz
,
11849 note_name
, NT_S390_SYSTEM_CALL
,
11850 s390_system_call
, size
);
11854 elfcore_write_s390_tdb (bfd
*abfd
,
11857 const void *s390_tdb
,
11860 char *note_name
= "LINUX";
11861 return elfcore_write_note (abfd
, buf
, bufsiz
,
11862 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11866 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11869 const void *s390_vxrs_low
,
11872 char *note_name
= "LINUX";
11873 return elfcore_write_note (abfd
, buf
, bufsiz
,
11874 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11878 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11881 const void *s390_vxrs_high
,
11884 char *note_name
= "LINUX";
11885 return elfcore_write_note (abfd
, buf
, bufsiz
,
11886 note_name
, NT_S390_VXRS_HIGH
,
11887 s390_vxrs_high
, size
);
11891 elfcore_write_s390_gs_cb (bfd
*abfd
,
11894 const void *s390_gs_cb
,
11897 char *note_name
= "LINUX";
11898 return elfcore_write_note (abfd
, buf
, bufsiz
,
11899 note_name
, NT_S390_GS_CB
,
11904 elfcore_write_s390_gs_bc (bfd
*abfd
,
11907 const void *s390_gs_bc
,
11910 char *note_name
= "LINUX";
11911 return elfcore_write_note (abfd
, buf
, bufsiz
,
11912 note_name
, NT_S390_GS_BC
,
11917 elfcore_write_arm_vfp (bfd
*abfd
,
11920 const void *arm_vfp
,
11923 char *note_name
= "LINUX";
11924 return elfcore_write_note (abfd
, buf
, bufsiz
,
11925 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11929 elfcore_write_aarch_tls (bfd
*abfd
,
11932 const void *aarch_tls
,
11935 char *note_name
= "LINUX";
11936 return elfcore_write_note (abfd
, buf
, bufsiz
,
11937 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11941 elfcore_write_aarch_hw_break (bfd
*abfd
,
11944 const void *aarch_hw_break
,
11947 char *note_name
= "LINUX";
11948 return elfcore_write_note (abfd
, buf
, bufsiz
,
11949 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11953 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11956 const void *aarch_hw_watch
,
11959 char *note_name
= "LINUX";
11960 return elfcore_write_note (abfd
, buf
, bufsiz
,
11961 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11965 elfcore_write_aarch_sve (bfd
*abfd
,
11968 const void *aarch_sve
,
11971 char *note_name
= "LINUX";
11972 return elfcore_write_note (abfd
, buf
, bufsiz
,
11973 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11977 elfcore_write_aarch_pauth (bfd
*abfd
,
11980 const void *aarch_pauth
,
11983 char *note_name
= "LINUX";
11984 return elfcore_write_note (abfd
, buf
, bufsiz
,
11985 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11989 elfcore_write_arc_v2 (bfd
*abfd
,
11992 const void *arc_v2
,
11995 char *note_name
= "LINUX";
11996 return elfcore_write_note (abfd
, buf
, bufsiz
,
11997 note_name
, NT_ARC_V2
, arc_v2
, size
);
12000 /* Write the buffer of csr values in CSRS (length SIZE) into the note
12001 buffer BUF and update *BUFSIZ. ABFD is the bfd the note is being
12002 written into. Return a pointer to the new start of the note buffer, to
12003 replace BUF which may no longer be valid. */
12006 elfcore_write_riscv_csr (bfd
*abfd
,
12012 const char *note_name
= "GDB";
12013 return elfcore_write_note (abfd
, buf
, bufsiz
,
12014 note_name
, NT_RISCV_CSR
, csrs
, size
);
12017 /* Write the target description (a string) pointed to by TDESC, length
12018 SIZE, into the note buffer BUF, and update *BUFSIZ. ABFD is the bfd the
12019 note is being written into. Return a pointer to the new start of the
12020 note buffer, to replace BUF which may no longer be valid. */
12023 elfcore_write_gdb_tdesc (bfd
*abfd
,
12029 const char *note_name
= "GDB";
12030 return elfcore_write_note (abfd
, buf
, bufsiz
,
12031 note_name
, NT_GDB_TDESC
, tdesc
, size
);
12035 elfcore_write_register_note (bfd
*abfd
,
12038 const char *section
,
12042 if (strcmp (section
, ".reg2") == 0)
12043 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
12044 if (strcmp (section
, ".reg-xfp") == 0)
12045 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
12046 if (strcmp (section
, ".reg-xstate") == 0)
12047 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
12048 if (strcmp (section
, ".reg-ppc-vmx") == 0)
12049 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
12050 if (strcmp (section
, ".reg-ppc-vsx") == 0)
12051 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
12052 if (strcmp (section
, ".reg-ppc-tar") == 0)
12053 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
12054 if (strcmp (section
, ".reg-ppc-ppr") == 0)
12055 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
12056 if (strcmp (section
, ".reg-ppc-dscr") == 0)
12057 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
12058 if (strcmp (section
, ".reg-ppc-ebb") == 0)
12059 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
12060 if (strcmp (section
, ".reg-ppc-pmu") == 0)
12061 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
12062 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
12063 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
12064 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
12065 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
12066 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
12067 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
12068 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
12069 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
12070 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
12071 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
12072 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
12073 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
12074 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
12075 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
12076 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
12077 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
12078 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
12079 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
12080 if (strcmp (section
, ".reg-s390-timer") == 0)
12081 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
12082 if (strcmp (section
, ".reg-s390-todcmp") == 0)
12083 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
12084 if (strcmp (section
, ".reg-s390-todpreg") == 0)
12085 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
12086 if (strcmp (section
, ".reg-s390-ctrs") == 0)
12087 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
12088 if (strcmp (section
, ".reg-s390-prefix") == 0)
12089 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
12090 if (strcmp (section
, ".reg-s390-last-break") == 0)
12091 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
12092 if (strcmp (section
, ".reg-s390-system-call") == 0)
12093 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
12094 if (strcmp (section
, ".reg-s390-tdb") == 0)
12095 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
12096 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
12097 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
12098 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
12099 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
12100 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
12101 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
12102 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
12103 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
12104 if (strcmp (section
, ".reg-arm-vfp") == 0)
12105 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
12106 if (strcmp (section
, ".reg-aarch-tls") == 0)
12107 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
12108 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
12109 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
12110 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
12111 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
12112 if (strcmp (section
, ".reg-aarch-sve") == 0)
12113 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
12114 if (strcmp (section
, ".reg-aarch-pauth") == 0)
12115 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
12116 if (strcmp (section
, ".reg-arc-v2") == 0)
12117 return elfcore_write_arc_v2 (abfd
, buf
, bufsiz
, data
, size
);
12118 if (strcmp (section
, ".gdb-tdesc") == 0)
12119 return elfcore_write_gdb_tdesc (abfd
, buf
, bufsiz
, data
, size
);
12120 if (strcmp (section
, ".reg-riscv-csr") == 0)
12121 return elfcore_write_riscv_csr (abfd
, buf
, bufsiz
, data
, size
);
12126 elfcore_write_file_note (bfd
*obfd
, char *note_data
, int *note_size
,
12127 const void *buf
, int bufsiz
)
12129 return elfcore_write_note (obfd
, note_data
, note_size
,
12130 "CORE", NT_FILE
, buf
, bufsiz
);
12134 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
12139 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
12140 gABI specifies that PT_NOTE alignment should be aligned to 4
12141 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
12142 align is less than 4, we use 4 byte alignment. */
12145 if (align
!= 4 && align
!= 8)
12149 while (p
< buf
+ size
)
12151 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
12152 Elf_Internal_Note in
;
12154 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
12157 in
.type
= H_GET_32 (abfd
, xnp
->type
);
12159 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
12160 in
.namedata
= xnp
->name
;
12161 if (in
.namesz
> buf
- in
.namedata
+ size
)
12164 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
12165 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
12166 in
.descpos
= offset
+ (in
.descdata
- buf
);
12168 && (in
.descdata
>= buf
+ size
12169 || in
.descsz
> buf
- in
.descdata
+ size
))
12172 switch (bfd_get_format (abfd
))
12179 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
12182 const char * string
;
12184 bool (*func
) (bfd
*, Elf_Internal_Note
*);
12188 GROKER_ELEMENT ("", elfcore_grok_note
),
12189 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
12190 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
12191 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
12192 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
12193 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
12194 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
12196 #undef GROKER_ELEMENT
12199 for (i
= ARRAY_SIZE (grokers
); i
--;)
12201 if (in
.namesz
>= grokers
[i
].len
12202 && strncmp (in
.namedata
, grokers
[i
].string
,
12203 grokers
[i
].len
) == 0)
12205 if (! grokers
[i
].func (abfd
, & in
))
12214 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
12216 if (! elfobj_grok_gnu_note (abfd
, &in
))
12219 else if (in
.namesz
== sizeof "stapsdt"
12220 && strcmp (in
.namedata
, "stapsdt") == 0)
12222 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
12228 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
12235 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
12240 if (size
== 0 || (size
+ 1) == 0)
12243 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
12246 buf
= (char *) _bfd_malloc_and_read (abfd
, size
+ 1, size
);
12250 /* PR 17512: file: ec08f814
12251 0-termintate the buffer so that string searches will not overflow. */
12254 if (!elf_parse_notes (abfd
, buf
, size
, offset
, align
))
12264 /* Providing external access to the ELF program header table. */
12266 /* Return an upper bound on the number of bytes required to store a
12267 copy of ABFD's program header table entries. Return -1 if an error
12268 occurs; bfd_get_error will return an appropriate code. */
12271 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
12273 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12275 bfd_set_error (bfd_error_wrong_format
);
12279 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
12282 /* Copy ABFD's program header table entries to *PHDRS. The entries
12283 will be stored as an array of Elf_Internal_Phdr structures, as
12284 defined in include/elf/internal.h. To find out how large the
12285 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
12287 Return the number of program header table entries read, or -1 if an
12288 error occurs; bfd_get_error will return an appropriate code. */
12291 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
12295 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12297 bfd_set_error (bfd_error_wrong_format
);
12301 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
12302 if (num_phdrs
!= 0)
12303 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
12304 num_phdrs
* sizeof (Elf_Internal_Phdr
));
12309 enum elf_reloc_type_class
12310 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12311 const asection
*rel_sec ATTRIBUTE_UNUSED
,
12312 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
12314 return reloc_class_normal
;
12317 /* For RELA architectures, return the relocation value for a
12318 relocation against a local symbol. */
12321 _bfd_elf_rela_local_sym (bfd
*abfd
,
12322 Elf_Internal_Sym
*sym
,
12324 Elf_Internal_Rela
*rel
)
12326 asection
*sec
= *psec
;
12327 bfd_vma relocation
;
12329 relocation
= (sec
->output_section
->vma
12330 + sec
->output_offset
12332 if ((sec
->flags
& SEC_MERGE
)
12333 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
12334 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12337 _bfd_merged_section_offset (abfd
, psec
,
12338 elf_section_data (sec
)->sec_info
,
12339 sym
->st_value
+ rel
->r_addend
);
12342 /* If we have changed the section, and our original section is
12343 marked with SEC_EXCLUDE, it means that the original
12344 SEC_MERGE section has been completely subsumed in some
12345 other SEC_MERGE section. In this case, we need to leave
12346 some info around for --emit-relocs. */
12347 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12348 sec
->kept_section
= *psec
;
12351 rel
->r_addend
-= relocation
;
12352 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12358 _bfd_elf_rel_local_sym (bfd
*abfd
,
12359 Elf_Internal_Sym
*sym
,
12363 asection
*sec
= *psec
;
12365 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12366 return sym
->st_value
+ addend
;
12368 return _bfd_merged_section_offset (abfd
, psec
,
12369 elf_section_data (sec
)->sec_info
,
12370 sym
->st_value
+ addend
);
12373 /* Adjust an address within a section. Given OFFSET within SEC, return
12374 the new offset within the section, based upon changes made to the
12375 section. Returns -1 if the offset is now invalid.
12376 The offset (in abnd out) is in target sized bytes, however big a
12380 _bfd_elf_section_offset (bfd
*abfd
,
12381 struct bfd_link_info
*info
,
12385 switch (sec
->sec_info_type
)
12387 case SEC_INFO_TYPE_STABS
:
12388 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12390 case SEC_INFO_TYPE_EH_FRAME
:
12391 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12394 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12396 /* Reverse the offset. */
12397 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12398 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12400 /* address_size and sec->size are in octets. Convert
12401 to bytes before subtracting the original offset. */
12402 offset
= ((sec
->size
- address_size
)
12403 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12409 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12410 reconstruct an ELF file by reading the segments out of remote memory
12411 based on the ELF file header at EHDR_VMA and the ELF program headers it
12412 points to. If not null, *LOADBASEP is filled in with the difference
12413 between the VMAs from which the segments were read, and the VMAs the
12414 file headers (and hence BFD's idea of each section's VMA) put them at.
12416 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12417 remote memory at target address VMA into the local buffer at MYADDR; it
12418 should return zero on success or an `errno' code on failure. TEMPL must
12419 be a BFD for an ELF target with the word size and byte order found in
12420 the remote memory. */
12423 bfd_elf_bfd_from_remote_memory
12426 bfd_size_type size
,
12427 bfd_vma
*loadbasep
,
12428 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12430 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12431 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12435 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12436 long symcount ATTRIBUTE_UNUSED
,
12437 asymbol
**syms ATTRIBUTE_UNUSED
,
12442 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12445 const char *relplt_name
;
12446 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
12450 Elf_Internal_Shdr
*hdr
;
12456 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12459 if (dynsymcount
<= 0)
12462 if (!bed
->plt_sym_val
)
12465 relplt_name
= bed
->relplt_name
;
12466 if (relplt_name
== NULL
)
12467 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12468 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12469 if (relplt
== NULL
)
12472 hdr
= &elf_section_data (relplt
)->this_hdr
;
12473 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12474 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12477 plt
= bfd_get_section_by_name (abfd
, ".plt");
12481 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12482 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, true))
12485 count
= relplt
->size
/ hdr
->sh_entsize
;
12486 size
= count
* sizeof (asymbol
);
12487 p
= relplt
->relocation
;
12488 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12490 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12491 if (p
->addend
!= 0)
12494 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12496 size
+= sizeof ("+0x") - 1 + 8;
12501 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12505 names
= (char *) (s
+ count
);
12506 p
= relplt
->relocation
;
12508 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12513 addr
= bed
->plt_sym_val (i
, plt
, p
);
12514 if (addr
== (bfd_vma
) -1)
12517 *s
= **p
->sym_ptr_ptr
;
12518 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12519 we are defining a symbol, ensure one of them is set. */
12520 if ((s
->flags
& BSF_LOCAL
) == 0)
12521 s
->flags
|= BSF_GLOBAL
;
12522 s
->flags
|= BSF_SYNTHETIC
;
12524 s
->value
= addr
- plt
->vma
;
12527 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12528 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12530 if (p
->addend
!= 0)
12534 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12535 names
+= sizeof ("+0x") - 1;
12536 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12537 for (a
= buf
; *a
== '0'; ++a
)
12540 memcpy (names
, a
, len
);
12543 memcpy (names
, "@plt", sizeof ("@plt"));
12544 names
+= sizeof ("@plt");
12551 /* It is only used by x86-64 so far.
12552 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12553 but current usage would allow all of _bfd_std_section to be zero. */
12554 static const asymbol lcomm_sym
12555 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12556 asection _bfd_elf_large_com_section
12557 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12558 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12561 _bfd_elf_final_write_processing (bfd
*abfd
)
12563 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12565 i_ehdrp
= elf_elfheader (abfd
);
12567 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12568 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12570 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12571 SHF_GNU_MBIND or SHF_GNU_RETAIN sections or symbols of STT_GNU_IFUNC type
12572 or STB_GNU_UNIQUE binding. */
12573 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12575 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12576 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12577 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12578 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12580 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12581 _bfd_error_handler (_("GNU_MBIND section is supported only by GNU "
12582 "and FreeBSD targets"));
12583 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12584 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is supported "
12585 "only by GNU and FreeBSD targets"));
12586 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12587 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is supported "
12588 "only by GNU and FreeBSD targets"));
12589 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_retain
)
12590 _bfd_error_handler (_("GNU_RETAIN section is supported "
12591 "only by GNU and FreeBSD targets"));
12592 bfd_set_error (bfd_error_sorry
);
12600 /* Return TRUE for ELF symbol types that represent functions.
12601 This is the default version of this function, which is sufficient for
12602 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12605 _bfd_elf_is_function_type (unsigned int type
)
12607 return (type
== STT_FUNC
12608 || type
== STT_GNU_IFUNC
);
12611 /* If the ELF symbol SYM might be a function in SEC, return the
12612 function size and set *CODE_OFF to the function's entry point,
12613 otherwise return zero. */
12616 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12619 bfd_size_type size
;
12621 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12622 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12623 || sym
->section
!= sec
)
12626 *code_off
= sym
->value
;
12628 if (!(sym
->flags
& BSF_SYNTHETIC
))
12629 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
12635 /* Set to non-zero to enable some debug messages. */
12636 #define DEBUG_SECONDARY_RELOCS 0
12638 /* An internal-to-the-bfd-library only section type
12639 used to indicate a cached secondary reloc section. */
12640 #define SHT_SECONDARY_RELOC (SHT_LOOS + SHT_RELA)
12642 /* Create a BFD section to hold a secondary reloc section. */
12645 _bfd_elf_init_secondary_reloc_section (bfd
* abfd
,
12646 Elf_Internal_Shdr
*hdr
,
12648 unsigned int shindex
)
12650 /* We only support RELA secondary relocs. */
12651 if (hdr
->sh_type
!= SHT_RELA
)
12654 #if DEBUG_SECONDARY_RELOCS
12655 fprintf (stderr
, "secondary reloc section %s encountered\n", name
);
12657 hdr
->sh_type
= SHT_SECONDARY_RELOC
;
12658 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
12661 /* Read in any secondary relocs associated with SEC. */
12664 _bfd_elf_slurp_secondary_reloc_section (bfd
* abfd
,
12666 asymbol
** symbols
,
12669 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12671 bool result
= true;
12672 bfd_vma (*r_sym
) (bfd_vma
);
12674 #if BFD_DEFAULT_TARGET_SIZE > 32
12675 if (bfd_arch_bits_per_address (abfd
) != 32)
12676 r_sym
= elf64_r_sym
;
12679 r_sym
= elf32_r_sym
;
12681 /* Discover if there are any secondary reloc sections
12682 associated with SEC. */
12683 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12685 Elf_Internal_Shdr
* hdr
= & elf_section_data (relsec
)->this_hdr
;
12687 if (hdr
->sh_type
== SHT_SECONDARY_RELOC
12688 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
12689 && (hdr
->sh_entsize
== ebd
->s
->sizeof_rel
12690 || hdr
->sh_entsize
== ebd
->s
->sizeof_rela
))
12692 bfd_byte
* native_relocs
;
12693 bfd_byte
* native_reloc
;
12694 arelent
* internal_relocs
;
12695 arelent
* internal_reloc
;
12697 unsigned int entsize
;
12698 unsigned int symcount
;
12699 unsigned int reloc_count
;
12702 if (ebd
->elf_info_to_howto
== NULL
)
12705 #if DEBUG_SECONDARY_RELOCS
12706 fprintf (stderr
, "read secondary relocs for %s from %s\n",
12707 sec
->name
, relsec
->name
);
12709 entsize
= hdr
->sh_entsize
;
12711 native_relocs
= bfd_malloc (hdr
->sh_size
);
12712 if (native_relocs
== NULL
)
12718 reloc_count
= NUM_SHDR_ENTRIES (hdr
);
12719 if (_bfd_mul_overflow (reloc_count
, sizeof (arelent
), & amt
))
12721 free (native_relocs
);
12722 bfd_set_error (bfd_error_file_too_big
);
12727 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
12728 if (internal_relocs
== NULL
)
12730 free (native_relocs
);
12735 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
12736 || (bfd_bread (native_relocs
, hdr
->sh_size
, abfd
)
12739 free (native_relocs
);
12740 /* The internal_relocs will be freed when
12741 the memory for the bfd is released. */
12747 symcount
= bfd_get_dynamic_symcount (abfd
);
12749 symcount
= bfd_get_symcount (abfd
);
12751 for (i
= 0, internal_reloc
= internal_relocs
,
12752 native_reloc
= native_relocs
;
12754 i
++, internal_reloc
++, native_reloc
+= entsize
)
12757 Elf_Internal_Rela rela
;
12759 if (entsize
== ebd
->s
->sizeof_rel
)
12760 ebd
->s
->swap_reloc_in (abfd
, native_reloc
, & rela
);
12761 else /* entsize == ebd->s->sizeof_rela */
12762 ebd
->s
->swap_reloca_in (abfd
, native_reloc
, & rela
);
12764 /* The address of an ELF reloc is section relative for an object
12765 file, and absolute for an executable file or shared library.
12766 The address of a normal BFD reloc is always section relative,
12767 and the address of a dynamic reloc is absolute.. */
12768 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
12769 internal_reloc
->address
= rela
.r_offset
;
12771 internal_reloc
->address
= rela
.r_offset
- sec
->vma
;
12773 if (r_sym (rela
.r_info
) == STN_UNDEF
)
12775 /* FIXME: This and the error case below mean that we
12776 have a symbol on relocs that is not elf_symbol_type. */
12777 internal_reloc
->sym_ptr_ptr
=
12778 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12780 else if (r_sym (rela
.r_info
) > symcount
)
12783 /* xgettext:c-format */
12784 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
12785 abfd
, sec
, i
, (long) r_sym (rela
.r_info
));
12786 bfd_set_error (bfd_error_bad_value
);
12787 internal_reloc
->sym_ptr_ptr
=
12788 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12795 ps
= symbols
+ r_sym (rela
.r_info
) - 1;
12796 internal_reloc
->sym_ptr_ptr
= ps
;
12797 /* Make sure that this symbol is not removed by strip. */
12798 (*ps
)->flags
|= BSF_KEEP
;
12801 internal_reloc
->addend
= rela
.r_addend
;
12803 res
= ebd
->elf_info_to_howto (abfd
, internal_reloc
, & rela
);
12804 if (! res
|| internal_reloc
->howto
== NULL
)
12806 #if DEBUG_SECONDARY_RELOCS
12807 fprintf (stderr
, "there is no howto associated with reloc %lx\n",
12814 free (native_relocs
);
12815 /* Store the internal relocs. */
12816 elf_section_data (relsec
)->sec_info
= internal_relocs
;
12823 /* Set the ELF section header fields of an output secondary reloc section. */
12826 _bfd_elf_copy_special_section_fields (const bfd
* ibfd ATTRIBUTE_UNUSED
,
12827 bfd
* obfd ATTRIBUTE_UNUSED
,
12828 const Elf_Internal_Shdr
* isection
,
12829 Elf_Internal_Shdr
* osection
)
12833 struct bfd_elf_section_data
* esd
;
12835 if (isection
== NULL
)
12838 if (isection
->sh_type
!= SHT_SECONDARY_RELOC
)
12841 isec
= isection
->bfd_section
;
12845 osec
= osection
->bfd_section
;
12849 esd
= elf_section_data (osec
);
12850 BFD_ASSERT (esd
->sec_info
== NULL
);
12851 esd
->sec_info
= elf_section_data (isec
)->sec_info
;
12852 osection
->sh_type
= SHT_RELA
;
12853 osection
->sh_link
= elf_onesymtab (obfd
);
12854 if (osection
->sh_link
== 0)
12856 /* There is no symbol table - we are hosed... */
12858 /* xgettext:c-format */
12859 (_("%pB(%pA): link section cannot be set because the output file does not have a symbol table"),
12861 bfd_set_error (bfd_error_bad_value
);
12865 /* Find the output section that corresponds to the isection's sh_info link. */
12866 if (isection
->sh_info
== 0
12867 || isection
->sh_info
>= elf_numsections (ibfd
))
12870 /* xgettext:c-format */
12871 (_("%pB(%pA): info section index is invalid"),
12873 bfd_set_error (bfd_error_bad_value
);
12877 isection
= elf_elfsections (ibfd
)[isection
->sh_info
];
12879 if (isection
== NULL
12880 || isection
->bfd_section
== NULL
12881 || isection
->bfd_section
->output_section
== NULL
)
12884 /* xgettext:c-format */
12885 (_("%pB(%pA): info section index cannot be set because the section is not in the output"),
12887 bfd_set_error (bfd_error_bad_value
);
12891 esd
= elf_section_data (isection
->bfd_section
->output_section
);
12892 BFD_ASSERT (esd
!= NULL
);
12893 osection
->sh_info
= esd
->this_idx
;
12894 esd
->has_secondary_relocs
= true;
12895 #if DEBUG_SECONDARY_RELOCS
12896 fprintf (stderr
, "update header of %s, sh_link = %u, sh_info = %u\n",
12897 osec
->name
, osection
->sh_link
, osection
->sh_info
);
12898 fprintf (stderr
, "mark section %s as having secondary relocs\n",
12899 bfd_section_name (isection
->bfd_section
->output_section
));
12905 /* Write out a secondary reloc section.
12907 FIXME: Currently this function can result in a serious performance penalty
12908 for files with secondary relocs and lots of sections. The proper way to
12909 fix this is for _bfd_elf_copy_special_section_fields() to chain secondary
12910 relocs together and then to have this function just walk that chain. */
12913 _bfd_elf_write_secondary_reloc_section (bfd
*abfd
, asection
*sec
)
12915 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12916 bfd_vma addr_offset
;
12918 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
12919 bool result
= true;
12924 #if BFD_DEFAULT_TARGET_SIZE > 32
12925 if (bfd_arch_bits_per_address (abfd
) != 32)
12926 r_info
= elf64_r_info
;
12929 r_info
= elf32_r_info
;
12931 /* The address of an ELF reloc is section relative for an object
12932 file, and absolute for an executable file or shared library.
12933 The address of a BFD reloc is always section relative. */
12935 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
12936 addr_offset
= sec
->vma
;
12938 /* Discover if there are any secondary reloc sections
12939 associated with SEC. */
12940 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12942 const struct bfd_elf_section_data
* const esd
= elf_section_data (relsec
);
12943 Elf_Internal_Shdr
* const hdr
= (Elf_Internal_Shdr
*) & esd
->this_hdr
;
12945 if (hdr
->sh_type
== SHT_RELA
12946 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
)
12948 asymbol
* last_sym
;
12950 unsigned int reloc_count
;
12952 unsigned int entsize
;
12953 arelent
* src_irel
;
12954 bfd_byte
* dst_rela
;
12956 if (hdr
->contents
!= NULL
)
12959 /* xgettext:c-format */
12960 (_("%pB(%pA): error: secondary reloc section processed twice"),
12962 bfd_set_error (bfd_error_bad_value
);
12967 entsize
= hdr
->sh_entsize
;
12971 /* xgettext:c-format */
12972 (_("%pB(%pA): error: secondary reloc section has zero sized entries"),
12974 bfd_set_error (bfd_error_bad_value
);
12978 else if (entsize
!= ebd
->s
->sizeof_rel
12979 && entsize
!= ebd
->s
->sizeof_rela
)
12982 /* xgettext:c-format */
12983 (_("%pB(%pA): error: secondary reloc section has non-standard sized entries"),
12985 bfd_set_error (bfd_error_bad_value
);
12990 reloc_count
= hdr
->sh_size
/ entsize
;
12991 if (reloc_count
<= 0)
12994 /* xgettext:c-format */
12995 (_("%pB(%pA): error: secondary reloc section is empty!"),
12997 bfd_set_error (bfd_error_bad_value
);
13002 hdr
->contents
= bfd_alloc (abfd
, hdr
->sh_size
);
13003 if (hdr
->contents
== NULL
)
13006 #if DEBUG_SECONDARY_RELOCS
13007 fprintf (stderr
, "write %u secondary relocs for %s from %s\n",
13008 reloc_count
, sec
->name
, relsec
->name
);
13012 dst_rela
= hdr
->contents
;
13013 src_irel
= (arelent
*) esd
->sec_info
;
13014 if (src_irel
== NULL
)
13017 /* xgettext:c-format */
13018 (_("%pB(%pA): error: internal relocs missing for secondary reloc section"),
13020 bfd_set_error (bfd_error_bad_value
);
13025 for (idx
= 0; idx
< reloc_count
; idx
++, dst_rela
+= entsize
)
13027 Elf_Internal_Rela src_rela
;
13032 ptr
= src_irel
+ idx
;
13036 /* xgettext:c-format */
13037 (_("%pB(%pA): error: reloc table entry %u is empty"),
13038 abfd
, relsec
, idx
);
13039 bfd_set_error (bfd_error_bad_value
);
13044 if (ptr
->sym_ptr_ptr
== NULL
)
13046 /* FIXME: Is this an error ? */
13051 sym
= *ptr
->sym_ptr_ptr
;
13053 if (sym
== last_sym
)
13057 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, & sym
);
13061 /* xgettext:c-format */
13062 (_("%pB(%pA): error: secondary reloc %u references a missing symbol"),
13063 abfd
, relsec
, idx
);
13064 bfd_set_error (bfd_error_bad_value
);
13073 if (sym
->the_bfd
!= NULL
13074 && sym
->the_bfd
->xvec
!= abfd
->xvec
13075 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
13078 /* xgettext:c-format */
13079 (_("%pB(%pA): error: secondary reloc %u references a deleted symbol"),
13080 abfd
, relsec
, idx
);
13081 bfd_set_error (bfd_error_bad_value
);
13087 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
13088 if (ptr
->howto
== NULL
)
13091 /* xgettext:c-format */
13092 (_("%pB(%pA): error: secondary reloc %u is of an unknown type"),
13093 abfd
, relsec
, idx
);
13094 bfd_set_error (bfd_error_bad_value
);
13096 src_rela
.r_info
= r_info (0, 0);
13099 src_rela
.r_info
= r_info (n
, ptr
->howto
->type
);
13100 src_rela
.r_addend
= ptr
->addend
;
13102 if (entsize
== ebd
->s
->sizeof_rel
)
13103 ebd
->s
->swap_reloc_out (abfd
, &src_rela
, dst_rela
);
13104 else /* entsize == ebd->s->sizeof_rela */
13105 ebd
->s
->swap_reloca_out (abfd
, &src_rela
, dst_rela
);