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
6313 static elf_section_list
*
6314 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6316 for (;list
!= NULL
; list
= list
->next
)
6322 /* Work out the file positions of all the sections. This is called by
6323 _bfd_elf_compute_section_file_positions. All the section sizes and
6324 VMAs must be known before this is called.
6326 Reloc sections come in two flavours: Those processed specially as
6327 "side-channel" data attached to a section to which they apply, and those that
6328 bfd doesn't process as relocations. The latter sort are stored in a normal
6329 bfd section by bfd_section_from_shdr. We don't consider the former sort
6330 here, unless they form part of the loadable image. Reloc sections not
6331 assigned here (and compressed debugging sections and CTF sections which
6332 nothing else in the file can rely upon) will be handled later by
6333 assign_file_positions_for_relocs.
6335 We also don't set the positions of the .symtab and .strtab here. */
6338 assign_file_positions_except_relocs (bfd
*abfd
,
6339 struct bfd_link_info
*link_info
)
6341 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6342 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6343 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6346 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6347 && bfd_get_format (abfd
) != bfd_core
)
6349 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6350 unsigned int num_sec
= elf_numsections (abfd
);
6351 Elf_Internal_Shdr
**hdrpp
;
6355 /* Start after the ELF header. */
6356 off
= i_ehdrp
->e_ehsize
;
6358 /* We are not creating an executable, which means that we are
6359 not creating a program header, and that the actual order of
6360 the sections in the file is unimportant. */
6361 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6363 Elf_Internal_Shdr
*hdr
;
6366 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6367 && hdr
->bfd_section
== NULL
)
6368 /* Do not assign offsets for these sections yet: we don't know
6370 || (hdr
->bfd_section
!= NULL
6371 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6372 || (bfd_section_is_ctf (hdr
->bfd_section
)
6373 && abfd
->is_linker_output
)))
6374 || i
== elf_onesymtab (abfd
)
6375 || (elf_symtab_shndx_list (abfd
) != NULL
6376 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6377 || i
== elf_strtab_sec (abfd
)
6378 || i
== elf_shstrtab_sec (abfd
))
6380 hdr
->sh_offset
= -1;
6383 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
6386 elf_next_file_pos (abfd
) = off
;
6387 elf_program_header_size (abfd
) = 0;
6391 /* Assign file positions for the loaded sections based on the
6392 assignment of sections to segments. */
6393 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6396 /* And for non-load sections. */
6397 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6401 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6404 /* Write out the program headers. */
6405 alloc
= i_ehdrp
->e_phnum
;
6408 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6409 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6417 _bfd_elf_init_file_header (bfd
*abfd
,
6418 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6420 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6421 struct elf_strtab_hash
*shstrtab
;
6422 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6424 i_ehdrp
= elf_elfheader (abfd
);
6426 shstrtab
= _bfd_elf_strtab_init ();
6427 if (shstrtab
== NULL
)
6430 elf_shstrtab (abfd
) = shstrtab
;
6432 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6433 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6434 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6435 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6437 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6438 i_ehdrp
->e_ident
[EI_DATA
] =
6439 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6440 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6442 if ((abfd
->flags
& DYNAMIC
) != 0)
6443 i_ehdrp
->e_type
= ET_DYN
;
6444 else if ((abfd
->flags
& EXEC_P
) != 0)
6445 i_ehdrp
->e_type
= ET_EXEC
;
6446 else if (bfd_get_format (abfd
) == bfd_core
)
6447 i_ehdrp
->e_type
= ET_CORE
;
6449 i_ehdrp
->e_type
= ET_REL
;
6451 switch (bfd_get_arch (abfd
))
6453 case bfd_arch_unknown
:
6454 i_ehdrp
->e_machine
= EM_NONE
;
6457 /* There used to be a long list of cases here, each one setting
6458 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6459 in the corresponding bfd definition. To avoid duplication,
6460 the switch was removed. Machines that need special handling
6461 can generally do it in elf_backend_final_write_processing(),
6462 unless they need the information earlier than the final write.
6463 Such need can generally be supplied by replacing the tests for
6464 e_machine with the conditions used to determine it. */
6466 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6469 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6470 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6472 /* No program header, for now. */
6473 i_ehdrp
->e_phoff
= 0;
6474 i_ehdrp
->e_phentsize
= 0;
6475 i_ehdrp
->e_phnum
= 0;
6477 /* Each bfd section is section header entry. */
6478 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6479 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6481 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6482 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", false);
6483 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6484 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", false);
6485 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6486 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", false);
6487 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6488 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6489 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6495 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6497 FIXME: We used to have code here to sort the PT_LOAD segments into
6498 ascending order, as per the ELF spec. But this breaks some programs,
6499 including the Linux kernel. But really either the spec should be
6500 changed or the programs updated. */
6503 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6505 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6507 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6508 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6509 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6510 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6511 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6513 /* Find the lowest p_vaddr in PT_LOAD segments. */
6514 bfd_vma p_vaddr
= (bfd_vma
) -1;
6515 for (; segment
< end_segment
; segment
++)
6516 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6517 p_vaddr
= segment
->p_vaddr
;
6519 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6520 segments is non-zero. */
6522 i_ehdrp
->e_type
= ET_EXEC
;
6527 /* Assign file positions for all the reloc sections which are not part
6528 of the loadable file image, and the file position of section headers. */
6531 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6534 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6535 Elf_Internal_Shdr
*shdrp
;
6536 Elf_Internal_Ehdr
*i_ehdrp
;
6537 const struct elf_backend_data
*bed
;
6539 off
= elf_next_file_pos (abfd
);
6541 shdrpp
= elf_elfsections (abfd
);
6542 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6543 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6546 if (shdrp
->sh_offset
== -1)
6548 asection
*sec
= shdrp
->bfd_section
;
6549 bool is_rel
= (shdrp
->sh_type
== SHT_REL
6550 || shdrp
->sh_type
== SHT_RELA
);
6551 bool is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6554 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6556 if (!is_rel
&& !is_ctf
)
6558 const char *name
= sec
->name
;
6559 struct bfd_elf_section_data
*d
;
6561 /* Compress DWARF debug sections. */
6562 if (!bfd_compress_section (abfd
, sec
,
6566 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6567 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6569 /* If section is compressed with zlib-gnu, convert
6570 section name from .debug_* to .zdebug_*. */
6572 = convert_debug_to_zdebug (abfd
, name
);
6573 if (new_name
== NULL
)
6577 /* Add section name to section name section. */
6578 if (shdrp
->sh_name
!= (unsigned int) -1)
6581 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6583 d
= elf_section_data (sec
);
6585 /* Add reloc section name to section name section. */
6587 && !_bfd_elf_set_reloc_sh_name (abfd
,
6592 && !_bfd_elf_set_reloc_sh_name (abfd
,
6597 /* Update section size and contents. */
6598 shdrp
->sh_size
= sec
->size
;
6599 shdrp
->contents
= sec
->contents
;
6600 shdrp
->bfd_section
->contents
= NULL
;
6604 /* Update section size and contents. */
6605 shdrp
->sh_size
= sec
->size
;
6606 shdrp
->contents
= sec
->contents
;
6609 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6616 /* Place section name section after DWARF debug sections have been
6618 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6619 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6620 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6621 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
6623 /* Place the section headers. */
6624 i_ehdrp
= elf_elfheader (abfd
);
6625 bed
= get_elf_backend_data (abfd
);
6626 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6627 i_ehdrp
->e_shoff
= off
;
6628 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6629 elf_next_file_pos (abfd
) = off
;
6635 _bfd_elf_write_object_contents (bfd
*abfd
)
6637 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6638 Elf_Internal_Shdr
**i_shdrp
;
6640 unsigned int count
, num_sec
;
6641 struct elf_obj_tdata
*t
;
6643 if (! abfd
->output_has_begun
6644 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6646 /* Do not rewrite ELF data when the BFD has been opened for update.
6647 abfd->output_has_begun was set to TRUE on opening, so creation of new
6648 sections, and modification of existing section sizes was restricted.
6649 This means the ELF header, program headers and section headers can't have
6651 If the contents of any sections has been modified, then those changes have
6652 already been written to the BFD. */
6653 else if (abfd
->direction
== both_direction
)
6655 BFD_ASSERT (abfd
->output_has_begun
);
6659 i_shdrp
= elf_elfsections (abfd
);
6662 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6666 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6669 /* After writing the headers, we need to write the sections too... */
6670 num_sec
= elf_numsections (abfd
);
6671 for (count
= 1; count
< num_sec
; count
++)
6673 i_shdrp
[count
]->sh_name
6674 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6675 i_shdrp
[count
]->sh_name
);
6676 if (bed
->elf_backend_section_processing
)
6677 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6679 if (i_shdrp
[count
]->contents
)
6681 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6683 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6684 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6689 /* Write out the section header names. */
6690 t
= elf_tdata (abfd
);
6691 if (elf_shstrtab (abfd
) != NULL
6692 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6693 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6696 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6699 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6702 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6703 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6704 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6710 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6712 /* Hopefully this can be done just like an object file. */
6713 return _bfd_elf_write_object_contents (abfd
);
6716 /* Given a section, search the header to find them. */
6719 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6721 const struct elf_backend_data
*bed
;
6722 unsigned int sec_index
;
6724 if (elf_section_data (asect
) != NULL
6725 && elf_section_data (asect
)->this_idx
!= 0)
6726 return elf_section_data (asect
)->this_idx
;
6728 if (bfd_is_abs_section (asect
))
6729 sec_index
= SHN_ABS
;
6730 else if (bfd_is_com_section (asect
))
6731 sec_index
= SHN_COMMON
;
6732 else if (bfd_is_und_section (asect
))
6733 sec_index
= SHN_UNDEF
;
6735 sec_index
= SHN_BAD
;
6737 bed
= get_elf_backend_data (abfd
);
6738 if (bed
->elf_backend_section_from_bfd_section
)
6740 int retval
= sec_index
;
6742 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6746 if (sec_index
== SHN_BAD
)
6747 bfd_set_error (bfd_error_nonrepresentable_section
);
6752 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6756 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6758 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6760 flagword flags
= asym_ptr
->flags
;
6762 /* When gas creates relocations against local labels, it creates its
6763 own symbol for the section, but does put the symbol into the
6764 symbol chain, so udata is 0. When the linker is generating
6765 relocatable output, this section symbol may be for one of the
6766 input sections rather than the output section. */
6767 if (asym_ptr
->udata
.i
== 0
6768 && (flags
& BSF_SECTION_SYM
)
6769 && asym_ptr
->section
)
6774 sec
= asym_ptr
->section
;
6775 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6776 sec
= sec
->output_section
;
6777 if (sec
->owner
== abfd
6778 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6779 && elf_section_syms (abfd
)[indx
] != NULL
)
6780 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6783 idx
= asym_ptr
->udata
.i
;
6787 /* This case can occur when using --strip-symbol on a symbol
6788 which is used in a relocation entry. */
6790 /* xgettext:c-format */
6791 (_("%pB: symbol `%s' required but not present"),
6792 abfd
, bfd_asymbol_name (asym_ptr
));
6793 bfd_set_error (bfd_error_no_symbols
);
6800 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6801 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6809 /* Rewrite program header information. */
6812 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
, bfd_vma maxpagesize
)
6814 Elf_Internal_Ehdr
*iehdr
;
6815 struct elf_segment_map
*map
;
6816 struct elf_segment_map
*map_first
;
6817 struct elf_segment_map
**pointer_to_map
;
6818 Elf_Internal_Phdr
*segment
;
6821 unsigned int num_segments
;
6822 bool phdr_included
= false;
6824 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6825 unsigned int phdr_adjust_num
= 0;
6826 const struct elf_backend_data
*bed
;
6827 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
6829 bed
= get_elf_backend_data (ibfd
);
6830 iehdr
= elf_elfheader (ibfd
);
6833 pointer_to_map
= &map_first
;
6835 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6837 /* Returns the end address of the segment + 1. */
6838 #define SEGMENT_END(segment, start) \
6839 (start + (segment->p_memsz > segment->p_filesz \
6840 ? segment->p_memsz : segment->p_filesz))
6842 #define SECTION_SIZE(section, segment) \
6843 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6844 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6845 ? section->size : 0)
6847 /* Returns TRUE if the given section is contained within
6848 the given segment. VMA addresses are compared. */
6849 #define IS_CONTAINED_BY_VMA(section, segment, opb) \
6850 (section->vma * (opb) >= segment->p_vaddr \
6851 && (section->vma * (opb) + SECTION_SIZE (section, segment) \
6852 <= (SEGMENT_END (segment, segment->p_vaddr))))
6854 /* Returns TRUE if the given section is contained within
6855 the given segment. LMA addresses are compared. */
6856 #define IS_CONTAINED_BY_LMA(section, segment, base, opb) \
6857 (section->lma * (opb) >= base \
6858 && (section->lma + SECTION_SIZE (section, segment) / (opb) >= section->lma) \
6859 && (section->lma * (opb) + SECTION_SIZE (section, segment) \
6860 <= SEGMENT_END (segment, base)))
6862 /* Handle PT_NOTE segment. */
6863 #define IS_NOTE(p, s) \
6864 (p->p_type == PT_NOTE \
6865 && elf_section_type (s) == SHT_NOTE \
6866 && (bfd_vma) s->filepos >= p->p_offset \
6867 && ((bfd_vma) s->filepos + s->size \
6868 <= p->p_offset + p->p_filesz))
6870 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6872 #define IS_COREFILE_NOTE(p, s) \
6874 && bfd_get_format (ibfd) == bfd_core \
6878 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6879 linker, which generates a PT_INTERP section with p_vaddr and
6880 p_memsz set to 0. */
6881 #define IS_SOLARIS_PT_INTERP(p, s) \
6883 && p->p_paddr == 0 \
6884 && p->p_memsz == 0 \
6885 && p->p_filesz > 0 \
6886 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6888 && (bfd_vma) s->filepos >= p->p_offset \
6889 && ((bfd_vma) s->filepos + s->size \
6890 <= p->p_offset + p->p_filesz))
6892 /* Decide if the given section should be included in the given segment.
6893 A section will be included if:
6894 1. It is within the address space of the segment -- we use the LMA
6895 if that is set for the segment and the VMA otherwise,
6896 2. It is an allocated section or a NOTE section in a PT_NOTE
6898 3. There is an output section associated with it,
6899 4. The section has not already been allocated to a previous segment.
6900 5. PT_GNU_STACK segments do not include any sections.
6901 6. PT_TLS segment includes only SHF_TLS sections.
6902 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6903 8. PT_DYNAMIC should not contain empty sections at the beginning
6904 (with the possible exception of .dynamic). */
6905 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed, opb) \
6906 ((((segment->p_paddr \
6907 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr, opb) \
6908 : IS_CONTAINED_BY_VMA (section, segment, opb)) \
6909 && (section->flags & SEC_ALLOC) != 0) \
6910 || IS_NOTE (segment, section)) \
6911 && segment->p_type != PT_GNU_STACK \
6912 && (segment->p_type != PT_TLS \
6913 || (section->flags & SEC_THREAD_LOCAL)) \
6914 && (segment->p_type == PT_LOAD \
6915 || segment->p_type == PT_TLS \
6916 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6917 && (segment->p_type != PT_DYNAMIC \
6918 || SECTION_SIZE (section, segment) > 0 \
6919 || (segment->p_paddr \
6920 ? segment->p_paddr != section->lma * (opb) \
6921 : segment->p_vaddr != section->vma * (opb)) \
6922 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6923 && (segment->p_type != PT_LOAD || !section->segment_mark))
6925 /* If the output section of a section in the input segment is NULL,
6926 it is removed from the corresponding output segment. */
6927 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed, opb) \
6928 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed, opb) \
6929 && section->output_section != NULL)
6931 /* Returns TRUE iff seg1 starts after the end of seg2. */
6932 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6933 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6935 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6936 their VMA address ranges and their LMA address ranges overlap.
6937 It is possible to have overlapping VMA ranges without overlapping LMA
6938 ranges. RedBoot images for example can have both .data and .bss mapped
6939 to the same VMA range, but with the .data section mapped to a different
6941 #define SEGMENT_OVERLAPS(seg1, seg2) \
6942 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6943 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6944 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6945 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6947 /* Initialise the segment mark field. */
6948 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6949 section
->segment_mark
= false;
6951 /* The Solaris linker creates program headers in which all the
6952 p_paddr fields are zero. When we try to objcopy or strip such a
6953 file, we get confused. Check for this case, and if we find it
6954 don't set the p_paddr_valid fields. */
6955 p_paddr_valid
= false;
6956 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6959 if (segment
->p_paddr
!= 0)
6961 p_paddr_valid
= true;
6965 /* Scan through the segments specified in the program header
6966 of the input BFD. For this first scan we look for overlaps
6967 in the loadable segments. These can be created by weird
6968 parameters to objcopy. Also, fix some solaris weirdness. */
6969 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6974 Elf_Internal_Phdr
*segment2
;
6976 if (segment
->p_type
== PT_INTERP
)
6977 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6978 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6980 /* Mininal change so that the normal section to segment
6981 assignment code will work. */
6982 segment
->p_vaddr
= section
->vma
* opb
;
6986 if (segment
->p_type
!= PT_LOAD
)
6988 /* Remove PT_GNU_RELRO segment. */
6989 if (segment
->p_type
== PT_GNU_RELRO
)
6990 segment
->p_type
= PT_NULL
;
6994 /* Determine if this segment overlaps any previous segments. */
6995 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6997 bfd_signed_vma extra_length
;
6999 if (segment2
->p_type
!= PT_LOAD
7000 || !SEGMENT_OVERLAPS (segment
, segment2
))
7003 /* Merge the two segments together. */
7004 if (segment2
->p_vaddr
< segment
->p_vaddr
)
7006 /* Extend SEGMENT2 to include SEGMENT and then delete
7008 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
7009 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
7011 if (extra_length
> 0)
7013 segment2
->p_memsz
+= extra_length
;
7014 segment2
->p_filesz
+= extra_length
;
7017 segment
->p_type
= PT_NULL
;
7019 /* Since we have deleted P we must restart the outer loop. */
7021 segment
= elf_tdata (ibfd
)->phdr
;
7026 /* Extend SEGMENT to include SEGMENT2 and then delete
7028 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7029 - SEGMENT_END (segment
, segment
->p_vaddr
));
7031 if (extra_length
> 0)
7033 segment
->p_memsz
+= extra_length
;
7034 segment
->p_filesz
+= extra_length
;
7037 segment2
->p_type
= PT_NULL
;
7042 /* The second scan attempts to assign sections to segments. */
7043 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7047 unsigned int section_count
;
7048 asection
**sections
;
7049 asection
*output_section
;
7051 asection
*matching_lma
;
7052 asection
*suggested_lma
;
7055 asection
*first_section
;
7057 if (segment
->p_type
== PT_NULL
)
7060 first_section
= NULL
;
7061 /* Compute how many sections might be placed into this segment. */
7062 for (section
= ibfd
->sections
, section_count
= 0;
7064 section
= section
->next
)
7066 /* Find the first section in the input segment, which may be
7067 removed from the corresponding output segment. */
7068 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
, opb
))
7070 if (first_section
== NULL
)
7071 first_section
= section
;
7072 if (section
->output_section
!= NULL
)
7077 /* Allocate a segment map big enough to contain
7078 all of the sections we have selected. */
7079 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7080 amt
+= section_count
* sizeof (asection
*);
7081 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7085 /* Initialise the fields of the segment map. Default to
7086 using the physical address of the segment in the input BFD. */
7088 map
->p_type
= segment
->p_type
;
7089 map
->p_flags
= segment
->p_flags
;
7090 map
->p_flags_valid
= 1;
7092 if (map
->p_type
== PT_LOAD
7093 && (ibfd
->flags
& D_PAGED
) != 0
7095 && segment
->p_align
> 1)
7097 map
->p_align
= segment
->p_align
;
7098 if (segment
->p_align
> maxpagesize
)
7099 map
->p_align
= maxpagesize
;
7100 map
->p_align_valid
= 1;
7103 /* If the first section in the input segment is removed, there is
7104 no need to preserve segment physical address in the corresponding
7106 if (!first_section
|| first_section
->output_section
!= NULL
)
7108 map
->p_paddr
= segment
->p_paddr
;
7109 map
->p_paddr_valid
= p_paddr_valid
;
7112 /* Determine if this segment contains the ELF file header
7113 and if it contains the program headers themselves. */
7114 map
->includes_filehdr
= (segment
->p_offset
== 0
7115 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7116 map
->includes_phdrs
= 0;
7118 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7120 map
->includes_phdrs
=
7121 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7122 && (segment
->p_offset
+ segment
->p_filesz
7123 >= ((bfd_vma
) iehdr
->e_phoff
7124 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7126 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7127 phdr_included
= true;
7130 if (section_count
== 0)
7132 /* Special segments, such as the PT_PHDR segment, may contain
7133 no sections, but ordinary, loadable segments should contain
7134 something. They are allowed by the ELF spec however, so only
7135 a warning is produced.
7136 There is however the valid use case of embedded systems which
7137 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7138 flash memory with zeros. No warning is shown for that case. */
7139 if (segment
->p_type
== PT_LOAD
7140 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7141 /* xgettext:c-format */
7143 (_("%pB: warning: empty loadable segment detected"
7144 " at vaddr=%#" PRIx64
", is this intentional?"),
7145 ibfd
, (uint64_t) segment
->p_vaddr
);
7147 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7149 *pointer_to_map
= map
;
7150 pointer_to_map
= &map
->next
;
7155 /* Now scan the sections in the input BFD again and attempt
7156 to add their corresponding output sections to the segment map.
7157 The problem here is how to handle an output section which has
7158 been moved (ie had its LMA changed). There are four possibilities:
7160 1. None of the sections have been moved.
7161 In this case we can continue to use the segment LMA from the
7164 2. All of the sections have been moved by the same amount.
7165 In this case we can change the segment's LMA to match the LMA
7166 of the first section.
7168 3. Some of the sections have been moved, others have not.
7169 In this case those sections which have not been moved can be
7170 placed in the current segment which will have to have its size,
7171 and possibly its LMA changed, and a new segment or segments will
7172 have to be created to contain the other sections.
7174 4. The sections have been moved, but not by the same amount.
7175 In this case we can change the segment's LMA to match the LMA
7176 of the first section and we will have to create a new segment
7177 or segments to contain the other sections.
7179 In order to save time, we allocate an array to hold the section
7180 pointers that we are interested in. As these sections get assigned
7181 to a segment, they are removed from this array. */
7183 amt
= section_count
* sizeof (asection
*);
7184 sections
= (asection
**) bfd_malloc (amt
);
7185 if (sections
== NULL
)
7188 /* Step One: Scan for segment vs section LMA conflicts.
7189 Also add the sections to the section array allocated above.
7190 Also add the sections to the current segment. In the common
7191 case, where the sections have not been moved, this means that
7192 we have completely filled the segment, and there is nothing
7195 matching_lma
= NULL
;
7196 suggested_lma
= NULL
;
7198 for (section
= first_section
, j
= 0;
7200 section
= section
->next
)
7202 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
, opb
))
7204 output_section
= section
->output_section
;
7206 sections
[j
++] = section
;
7208 /* The Solaris native linker always sets p_paddr to 0.
7209 We try to catch that case here, and set it to the
7210 correct value. Note - some backends require that
7211 p_paddr be left as zero. */
7213 && segment
->p_vaddr
!= 0
7214 && !bed
->want_p_paddr_set_to_zero
7216 && output_section
->lma
!= 0
7217 && (align_power (segment
->p_vaddr
7218 + (map
->includes_filehdr
7219 ? iehdr
->e_ehsize
: 0)
7220 + (map
->includes_phdrs
7221 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7223 output_section
->alignment_power
* opb
)
7224 == (output_section
->vma
* opb
)))
7225 map
->p_paddr
= segment
->p_vaddr
;
7227 /* Match up the physical address of the segment with the
7228 LMA address of the output section. */
7229 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7231 || IS_COREFILE_NOTE (segment
, section
)
7232 || (bed
->want_p_paddr_set_to_zero
7233 && IS_CONTAINED_BY_VMA (output_section
, segment
, opb
)))
7235 if (matching_lma
== NULL
7236 || output_section
->lma
< matching_lma
->lma
)
7237 matching_lma
= output_section
;
7239 /* We assume that if the section fits within the segment
7240 then it does not overlap any other section within that
7242 map
->sections
[isec
++] = output_section
;
7244 else if (suggested_lma
== NULL
)
7245 suggested_lma
= output_section
;
7247 if (j
== section_count
)
7252 BFD_ASSERT (j
== section_count
);
7254 /* Step Two: Adjust the physical address of the current segment,
7256 if (isec
== section_count
)
7258 /* All of the sections fitted within the segment as currently
7259 specified. This is the default case. Add the segment to
7260 the list of built segments and carry on to process the next
7261 program header in the input BFD. */
7262 map
->count
= section_count
;
7263 *pointer_to_map
= map
;
7264 pointer_to_map
= &map
->next
;
7267 && !bed
->want_p_paddr_set_to_zero
)
7269 bfd_vma hdr_size
= 0;
7270 if (map
->includes_filehdr
)
7271 hdr_size
= iehdr
->e_ehsize
;
7272 if (map
->includes_phdrs
)
7273 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7275 /* Account for padding before the first section in the
7277 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7278 - matching_lma
->lma
);
7286 /* Change the current segment's physical address to match
7287 the LMA of the first section that fitted, or if no
7288 section fitted, the first section. */
7289 if (matching_lma
== NULL
)
7290 matching_lma
= suggested_lma
;
7292 map
->p_paddr
= matching_lma
->lma
* opb
;
7294 /* Offset the segment physical address from the lma
7295 to allow for space taken up by elf headers. */
7296 if (map
->includes_phdrs
)
7298 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7300 /* iehdr->e_phnum is just an estimate of the number
7301 of program headers that we will need. Make a note
7302 here of the number we used and the segment we chose
7303 to hold these headers, so that we can adjust the
7304 offset when we know the correct value. */
7305 phdr_adjust_num
= iehdr
->e_phnum
;
7306 phdr_adjust_seg
= map
;
7309 if (map
->includes_filehdr
)
7311 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7312 map
->p_paddr
-= iehdr
->e_ehsize
;
7313 /* We've subtracted off the size of headers from the
7314 first section lma, but there may have been some
7315 alignment padding before that section too. Try to
7316 account for that by adjusting the segment lma down to
7317 the same alignment. */
7318 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7319 align
= segment
->p_align
;
7320 map
->p_paddr
&= -(align
* opb
);
7324 /* Step Three: Loop over the sections again, this time assigning
7325 those that fit to the current segment and removing them from the
7326 sections array; but making sure not to leave large gaps. Once all
7327 possible sections have been assigned to the current segment it is
7328 added to the list of built segments and if sections still remain
7329 to be assigned, a new segment is constructed before repeating
7335 suggested_lma
= NULL
;
7337 /* Fill the current segment with sections that fit. */
7338 for (j
= 0; j
< section_count
; j
++)
7340 section
= sections
[j
];
7342 if (section
== NULL
)
7345 output_section
= section
->output_section
;
7347 BFD_ASSERT (output_section
!= NULL
);
7349 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7351 || IS_COREFILE_NOTE (segment
, section
))
7353 if (map
->count
== 0)
7355 /* If the first section in a segment does not start at
7356 the beginning of the segment, then something is
7358 if (align_power (map
->p_paddr
7359 + (map
->includes_filehdr
7360 ? iehdr
->e_ehsize
: 0)
7361 + (map
->includes_phdrs
7362 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7364 output_section
->alignment_power
* opb
)
7365 != output_section
->lma
* opb
)
7372 prev_sec
= map
->sections
[map
->count
- 1];
7374 /* If the gap between the end of the previous section
7375 and the start of this section is more than
7376 maxpagesize then we need to start a new segment. */
7377 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7379 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7380 || (prev_sec
->lma
+ prev_sec
->size
7381 > output_section
->lma
))
7383 if (suggested_lma
== NULL
)
7384 suggested_lma
= output_section
;
7390 map
->sections
[map
->count
++] = output_section
;
7393 if (segment
->p_type
== PT_LOAD
)
7394 section
->segment_mark
= true;
7396 else if (suggested_lma
== NULL
)
7397 suggested_lma
= output_section
;
7400 /* PR 23932. A corrupt input file may contain sections that cannot
7401 be assigned to any segment - because for example they have a
7402 negative size - or segments that do not contain any sections.
7403 But there are also valid reasons why a segment can be empty.
7404 So allow a count of zero. */
7406 /* Add the current segment to the list of built segments. */
7407 *pointer_to_map
= map
;
7408 pointer_to_map
= &map
->next
;
7410 if (isec
< section_count
)
7412 /* We still have not allocated all of the sections to
7413 segments. Create a new segment here, initialise it
7414 and carry on looping. */
7415 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7416 amt
+= section_count
* sizeof (asection
*);
7417 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7424 /* Initialise the fields of the segment map. Set the physical
7425 physical address to the LMA of the first section that has
7426 not yet been assigned. */
7428 map
->p_type
= segment
->p_type
;
7429 map
->p_flags
= segment
->p_flags
;
7430 map
->p_flags_valid
= 1;
7431 map
->p_paddr
= suggested_lma
->lma
* opb
;
7432 map
->p_paddr_valid
= p_paddr_valid
;
7433 map
->includes_filehdr
= 0;
7434 map
->includes_phdrs
= 0;
7439 bfd_set_error (bfd_error_sorry
);
7443 while (isec
< section_count
);
7448 elf_seg_map (obfd
) = map_first
;
7450 /* If we had to estimate the number of program headers that were
7451 going to be needed, then check our estimate now and adjust
7452 the offset if necessary. */
7453 if (phdr_adjust_seg
!= NULL
)
7457 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7460 if (count
> phdr_adjust_num
)
7461 phdr_adjust_seg
->p_paddr
7462 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7464 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7465 if (map
->p_type
== PT_PHDR
)
7468 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7469 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7476 #undef IS_CONTAINED_BY_VMA
7477 #undef IS_CONTAINED_BY_LMA
7479 #undef IS_COREFILE_NOTE
7480 #undef IS_SOLARIS_PT_INTERP
7481 #undef IS_SECTION_IN_INPUT_SEGMENT
7482 #undef INCLUDE_SECTION_IN_SEGMENT
7483 #undef SEGMENT_AFTER_SEGMENT
7484 #undef SEGMENT_OVERLAPS
7488 /* Copy ELF program header information. */
7491 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7493 Elf_Internal_Ehdr
*iehdr
;
7494 struct elf_segment_map
*map
;
7495 struct elf_segment_map
*map_first
;
7496 struct elf_segment_map
**pointer_to_map
;
7497 Elf_Internal_Phdr
*segment
;
7499 unsigned int num_segments
;
7500 bool phdr_included
= false;
7502 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
7504 iehdr
= elf_elfheader (ibfd
);
7507 pointer_to_map
= &map_first
;
7509 /* If all the segment p_paddr fields are zero, don't set
7510 map->p_paddr_valid. */
7511 p_paddr_valid
= false;
7512 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7513 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7516 if (segment
->p_paddr
!= 0)
7518 p_paddr_valid
= true;
7522 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7527 unsigned int section_count
;
7529 Elf_Internal_Shdr
*this_hdr
;
7530 asection
*first_section
= NULL
;
7531 asection
*lowest_section
;
7533 /* Compute how many sections are in this segment. */
7534 for (section
= ibfd
->sections
, section_count
= 0;
7536 section
= section
->next
)
7538 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7539 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7541 if (first_section
== NULL
)
7542 first_section
= section
;
7547 /* Allocate a segment map big enough to contain
7548 all of the sections we have selected. */
7549 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7550 amt
+= section_count
* sizeof (asection
*);
7551 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7555 /* Initialize the fields of the output segment map with the
7558 map
->p_type
= segment
->p_type
;
7559 map
->p_flags
= segment
->p_flags
;
7560 map
->p_flags_valid
= 1;
7561 map
->p_paddr
= segment
->p_paddr
;
7562 map
->p_paddr_valid
= p_paddr_valid
;
7563 map
->p_align
= segment
->p_align
;
7564 map
->p_align_valid
= 1;
7565 map
->p_vaddr_offset
= 0;
7567 if (map
->p_type
== PT_GNU_RELRO
7568 || map
->p_type
== PT_GNU_STACK
)
7570 /* The PT_GNU_RELRO segment may contain the first a few
7571 bytes in the .got.plt section even if the whole .got.plt
7572 section isn't in the PT_GNU_RELRO segment. We won't
7573 change the size of the PT_GNU_RELRO segment.
7574 Similarly, PT_GNU_STACK size is significant on uclinux
7576 map
->p_size
= segment
->p_memsz
;
7577 map
->p_size_valid
= 1;
7580 /* Determine if this segment contains the ELF file header
7581 and if it contains the program headers themselves. */
7582 map
->includes_filehdr
= (segment
->p_offset
== 0
7583 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7585 map
->includes_phdrs
= 0;
7586 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7588 map
->includes_phdrs
=
7589 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7590 && (segment
->p_offset
+ segment
->p_filesz
7591 >= ((bfd_vma
) iehdr
->e_phoff
7592 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7594 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7595 phdr_included
= true;
7598 lowest_section
= NULL
;
7599 if (section_count
!= 0)
7601 unsigned int isec
= 0;
7603 for (section
= first_section
;
7605 section
= section
->next
)
7607 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7608 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7610 map
->sections
[isec
++] = section
->output_section
;
7611 if ((section
->flags
& SEC_ALLOC
) != 0)
7615 if (lowest_section
== NULL
7616 || section
->lma
< lowest_section
->lma
)
7617 lowest_section
= section
;
7619 /* Section lmas are set up from PT_LOAD header
7620 p_paddr in _bfd_elf_make_section_from_shdr.
7621 If this header has a p_paddr that disagrees
7622 with the section lma, flag the p_paddr as
7624 if ((section
->flags
& SEC_LOAD
) != 0)
7625 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7627 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7628 if (section
->lma
* opb
- segment
->p_paddr
!= seg_off
)
7629 map
->p_paddr_valid
= false;
7631 if (isec
== section_count
)
7637 if (section_count
== 0)
7638 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7639 else if (map
->p_paddr_valid
)
7641 /* Account for padding before the first section in the segment. */
7642 bfd_vma hdr_size
= 0;
7643 if (map
->includes_filehdr
)
7644 hdr_size
= iehdr
->e_ehsize
;
7645 if (map
->includes_phdrs
)
7646 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7648 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7649 - (lowest_section
? lowest_section
->lma
: 0));
7652 map
->count
= section_count
;
7653 *pointer_to_map
= map
;
7654 pointer_to_map
= &map
->next
;
7657 elf_seg_map (obfd
) = map_first
;
7661 /* Copy private BFD data. This copies or rewrites ELF program header
7665 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7667 bfd_vma maxpagesize
;
7669 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7670 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7673 if (elf_tdata (ibfd
)->phdr
== NULL
)
7676 if (ibfd
->xvec
== obfd
->xvec
)
7678 /* Check to see if any sections in the input BFD
7679 covered by ELF program header have changed. */
7680 Elf_Internal_Phdr
*segment
;
7681 asection
*section
, *osec
;
7682 unsigned int i
, num_segments
;
7683 Elf_Internal_Shdr
*this_hdr
;
7684 const struct elf_backend_data
*bed
;
7686 bed
= get_elf_backend_data (ibfd
);
7688 /* Regenerate the segment map if p_paddr is set to 0. */
7689 if (bed
->want_p_paddr_set_to_zero
)
7692 /* Initialize the segment mark field. */
7693 for (section
= obfd
->sections
; section
!= NULL
;
7694 section
= section
->next
)
7695 section
->segment_mark
= false;
7697 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7698 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7702 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7703 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7704 which severly confuses things, so always regenerate the segment
7705 map in this case. */
7706 if (segment
->p_paddr
== 0
7707 && segment
->p_memsz
== 0
7708 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7711 for (section
= ibfd
->sections
;
7712 section
!= NULL
; section
= section
->next
)
7714 /* We mark the output section so that we know it comes
7715 from the input BFD. */
7716 osec
= section
->output_section
;
7718 osec
->segment_mark
= true;
7720 /* Check if this section is covered by the segment. */
7721 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7722 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7724 /* FIXME: Check if its output section is changed or
7725 removed. What else do we need to check? */
7727 || section
->flags
!= osec
->flags
7728 || section
->lma
!= osec
->lma
7729 || section
->vma
!= osec
->vma
7730 || section
->size
!= osec
->size
7731 || section
->rawsize
!= osec
->rawsize
7732 || section
->alignment_power
!= osec
->alignment_power
)
7738 /* Check to see if any output section do not come from the
7740 for (section
= obfd
->sections
; section
!= NULL
;
7741 section
= section
->next
)
7743 if (!section
->segment_mark
)
7746 section
->segment_mark
= false;
7749 return copy_elf_program_header (ibfd
, obfd
);
7754 if (ibfd
->xvec
== obfd
->xvec
)
7756 /* When rewriting program header, set the output maxpagesize to
7757 the maximum alignment of input PT_LOAD segments. */
7758 Elf_Internal_Phdr
*segment
;
7760 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7762 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7765 if (segment
->p_type
== PT_LOAD
7766 && maxpagesize
< segment
->p_align
)
7768 /* PR 17512: file: f17299af. */
7769 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7770 /* xgettext:c-format */
7771 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7772 PRIx64
" is too large"),
7773 ibfd
, (uint64_t) segment
->p_align
);
7775 maxpagesize
= segment
->p_align
;
7778 if (maxpagesize
== 0)
7779 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
7781 return rewrite_elf_program_header (ibfd
, obfd
, maxpagesize
);
7784 /* Initialize private output section information from input section. */
7787 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7791 struct bfd_link_info
*link_info
)
7794 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7795 bool final_link
= (link_info
!= NULL
7796 && !bfd_link_relocatable (link_info
));
7798 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7799 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7802 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7804 /* If this is a known ABI section, ELF section type and flags may
7805 have been set up when OSEC was created. For normal sections we
7806 allow the user to override the type and flags other than
7807 SHF_MASKOS and SHF_MASKPROC. */
7808 if (elf_section_type (osec
) == SHT_PROGBITS
7809 || elf_section_type (osec
) == SHT_NOTE
7810 || elf_section_type (osec
) == SHT_NOBITS
)
7811 elf_section_type (osec
) = SHT_NULL
;
7812 /* For objcopy and relocatable link, copy the ELF section type from
7813 the input file if the BFD section flags are the same. (If they
7814 are different the user may be doing something like
7815 "objcopy --set-section-flags .text=alloc,data".) For a final
7816 link allow some flags that the linker clears to differ. */
7817 if (elf_section_type (osec
) == SHT_NULL
7818 && (osec
->flags
== isec
->flags
7820 && ((osec
->flags
^ isec
->flags
)
7821 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7822 elf_section_type (osec
) = elf_section_type (isec
);
7824 /* FIXME: Is this correct for all OS/PROC specific flags? */
7825 elf_section_flags (osec
) = (elf_section_flags (isec
)
7826 & (SHF_MASKOS
| SHF_MASKPROC
));
7828 /* Copy sh_info from input for mbind section. */
7829 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7830 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7831 elf_section_data (osec
)->this_hdr
.sh_info
7832 = elf_section_data (isec
)->this_hdr
.sh_info
;
7834 /* Set things up for objcopy and relocatable link. The output
7835 SHT_GROUP section will have its elf_next_in_group pointing back
7836 to the input group members. Ignore linker created group section.
7837 See elfNN_ia64_object_p in elfxx-ia64.c. */
7838 if ((link_info
== NULL
7839 || !link_info
->resolve_section_groups
)
7840 && (elf_sec_group (isec
) == NULL
7841 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7843 if (elf_section_flags (isec
) & SHF_GROUP
)
7844 elf_section_flags (osec
) |= SHF_GROUP
;
7845 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7846 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7849 /* If not decompress, preserve SHF_COMPRESSED. */
7850 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7851 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7854 ihdr
= &elf_section_data (isec
)->this_hdr
;
7856 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7857 don't use the output section of the linked-to section since it
7858 may be NULL at this point. */
7859 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7861 ohdr
= &elf_section_data (osec
)->this_hdr
;
7862 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7863 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7866 osec
->use_rela_p
= isec
->use_rela_p
;
7871 /* Copy private section information. This copies over the entsize
7872 field, and sometimes the info field. */
7875 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7880 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7882 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7883 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7886 ihdr
= &elf_section_data (isec
)->this_hdr
;
7887 ohdr
= &elf_section_data (osec
)->this_hdr
;
7889 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7891 if (ihdr
->sh_type
== SHT_SYMTAB
7892 || ihdr
->sh_type
== SHT_DYNSYM
7893 || ihdr
->sh_type
== SHT_GNU_verneed
7894 || ihdr
->sh_type
== SHT_GNU_verdef
)
7895 ohdr
->sh_info
= ihdr
->sh_info
;
7897 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7901 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7902 necessary if we are removing either the SHT_GROUP section or any of
7903 the group member sections. DISCARDED is the value that a section's
7904 output_section has if the section will be discarded, NULL when this
7905 function is called from objcopy, bfd_abs_section_ptr when called
7909 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7913 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7914 if (elf_section_type (isec
) == SHT_GROUP
)
7916 asection
*first
= elf_next_in_group (isec
);
7917 asection
*s
= first
;
7918 bfd_size_type removed
= 0;
7922 /* If this member section is being output but the
7923 SHT_GROUP section is not, then clear the group info
7924 set up by _bfd_elf_copy_private_section_data. */
7925 if (s
->output_section
!= discarded
7926 && isec
->output_section
== discarded
)
7928 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7929 elf_group_name (s
->output_section
) = NULL
;
7933 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7934 if (s
->output_section
== discarded
7935 && isec
->output_section
!= discarded
)
7937 /* Conversely, if the member section is not being
7938 output but the SHT_GROUP section is, then adjust
7941 if (elf_sec
->rel
.hdr
!= NULL
7942 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7944 if (elf_sec
->rela
.hdr
!= NULL
7945 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7950 /* Also adjust for zero-sized relocation member
7952 if (elf_sec
->rel
.hdr
!= NULL
7953 && elf_sec
->rel
.hdr
->sh_size
== 0)
7955 if (elf_sec
->rela
.hdr
!= NULL
7956 && elf_sec
->rela
.hdr
->sh_size
== 0)
7960 s
= elf_next_in_group (s
);
7966 if (discarded
!= NULL
)
7968 /* If we've been called for ld -r, then we need to
7969 adjust the input section size. */
7970 if (isec
->rawsize
== 0)
7971 isec
->rawsize
= isec
->size
;
7972 isec
->size
= isec
->rawsize
- removed
;
7973 if (isec
->size
<= 4)
7976 isec
->flags
|= SEC_EXCLUDE
;
7981 /* Adjust the output section size when called from
7983 isec
->output_section
->size
-= removed
;
7984 if (isec
->output_section
->size
<= 4)
7986 isec
->output_section
->size
= 0;
7987 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7996 /* Copy private header information. */
7999 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
8001 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8002 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8005 /* Copy over private BFD data if it has not already been copied.
8006 This must be done here, rather than in the copy_private_bfd_data
8007 entry point, because the latter is called after the section
8008 contents have been set, which means that the program headers have
8009 already been worked out. */
8010 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
8012 if (! copy_private_bfd_data (ibfd
, obfd
))
8016 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
8019 /* Copy private symbol information. If this symbol is in a section
8020 which we did not map into a BFD section, try to map the section
8021 index correctly. We use special macro definitions for the mapped
8022 section indices; these definitions are interpreted by the
8023 swap_out_syms function. */
8025 #define MAP_ONESYMTAB (SHN_HIOS + 1)
8026 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
8027 #define MAP_STRTAB (SHN_HIOS + 3)
8028 #define MAP_SHSTRTAB (SHN_HIOS + 4)
8029 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
8032 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
8037 elf_symbol_type
*isym
, *osym
;
8039 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8040 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8043 isym
= elf_symbol_from (isymarg
);
8044 osym
= elf_symbol_from (osymarg
);
8047 && isym
->internal_elf_sym
.st_shndx
!= 0
8049 && bfd_is_abs_section (isym
->symbol
.section
))
8053 shndx
= isym
->internal_elf_sym
.st_shndx
;
8054 if (shndx
== elf_onesymtab (ibfd
))
8055 shndx
= MAP_ONESYMTAB
;
8056 else if (shndx
== elf_dynsymtab (ibfd
))
8057 shndx
= MAP_DYNSYMTAB
;
8058 else if (shndx
== elf_strtab_sec (ibfd
))
8060 else if (shndx
== elf_shstrtab_sec (ibfd
))
8061 shndx
= MAP_SHSTRTAB
;
8062 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
8063 shndx
= MAP_SYM_SHNDX
;
8064 osym
->internal_elf_sym
.st_shndx
= shndx
;
8070 /* Swap out the symbols. */
8073 swap_out_syms (bfd
*abfd
,
8074 struct elf_strtab_hash
**sttp
,
8076 struct bfd_link_info
*info
)
8078 const struct elf_backend_data
*bed
;
8079 unsigned int symcount
;
8081 struct elf_strtab_hash
*stt
;
8082 Elf_Internal_Shdr
*symtab_hdr
;
8083 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8084 Elf_Internal_Shdr
*symstrtab_hdr
;
8085 struct elf_sym_strtab
*symstrtab
;
8086 bfd_byte
*outbound_syms
;
8087 bfd_byte
*outbound_shndx
;
8088 unsigned long outbound_syms_index
;
8089 unsigned long outbound_shndx_index
;
8091 unsigned int num_locals
;
8093 bool name_local_sections
;
8095 if (!elf_map_symbols (abfd
, &num_locals
))
8098 /* Dump out the symtabs. */
8099 stt
= _bfd_elf_strtab_init ();
8103 bed
= get_elf_backend_data (abfd
);
8104 symcount
= bfd_get_symcount (abfd
);
8105 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8106 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8107 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8108 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8109 symtab_hdr
->sh_info
= num_locals
+ 1;
8110 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8112 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8113 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8115 /* Allocate buffer to swap out the .strtab section. */
8116 if (_bfd_mul_overflow (symcount
+ 1, sizeof (*symstrtab
), &amt
)
8117 || (symstrtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
)) == NULL
)
8119 bfd_set_error (bfd_error_no_memory
);
8120 _bfd_elf_strtab_free (stt
);
8124 if (_bfd_mul_overflow (symcount
+ 1, bed
->s
->sizeof_sym
, &amt
)
8125 || (outbound_syms
= (bfd_byte
*) bfd_alloc (abfd
, amt
)) == NULL
)
8128 bfd_set_error (bfd_error_no_memory
);
8131 _bfd_elf_strtab_free (stt
);
8134 symtab_hdr
->contents
= outbound_syms
;
8135 outbound_syms_index
= 0;
8137 outbound_shndx
= NULL
;
8138 outbound_shndx_index
= 0;
8140 if (elf_symtab_shndx_list (abfd
))
8142 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8143 if (symtab_shndx_hdr
->sh_name
!= 0)
8145 if (_bfd_mul_overflow (symcount
+ 1,
8146 sizeof (Elf_External_Sym_Shndx
), &amt
))
8148 outbound_shndx
= (bfd_byte
*) bfd_zalloc (abfd
, amt
);
8149 if (outbound_shndx
== NULL
)
8152 symtab_shndx_hdr
->contents
= outbound_shndx
;
8153 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8154 symtab_shndx_hdr
->sh_size
= amt
;
8155 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8156 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8158 /* FIXME: What about any other headers in the list ? */
8161 /* Now generate the data (for "contents"). */
8163 /* Fill in zeroth symbol and swap it out. */
8164 Elf_Internal_Sym sym
;
8170 sym
.st_shndx
= SHN_UNDEF
;
8171 sym
.st_target_internal
= 0;
8172 symstrtab
[0].sym
= sym
;
8173 symstrtab
[0].dest_index
= outbound_syms_index
;
8174 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8175 outbound_syms_index
++;
8176 if (outbound_shndx
!= NULL
)
8177 outbound_shndx_index
++;
8181 = (bed
->elf_backend_name_local_section_symbols
8182 && bed
->elf_backend_name_local_section_symbols (abfd
));
8184 syms
= bfd_get_outsymbols (abfd
);
8185 for (idx
= 0; idx
< symcount
;)
8187 Elf_Internal_Sym sym
;
8188 bfd_vma value
= syms
[idx
]->value
;
8189 elf_symbol_type
*type_ptr
;
8190 flagword flags
= syms
[idx
]->flags
;
8193 if (!name_local_sections
8194 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8196 /* Local section symbols have no name. */
8197 sym
.st_name
= (unsigned long) -1;
8201 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8202 to get the final offset for st_name. */
8204 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8206 if (sym
.st_name
== (unsigned long) -1)
8210 type_ptr
= elf_symbol_from (syms
[idx
]);
8212 if ((flags
& BSF_SECTION_SYM
) == 0
8213 && bfd_is_com_section (syms
[idx
]->section
))
8215 /* ELF common symbols put the alignment into the `value' field,
8216 and the size into the `size' field. This is backwards from
8217 how BFD handles it, so reverse it here. */
8218 sym
.st_size
= value
;
8219 if (type_ptr
== NULL
8220 || type_ptr
->internal_elf_sym
.st_value
== 0)
8221 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8223 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8224 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8225 (abfd
, syms
[idx
]->section
);
8229 asection
*sec
= syms
[idx
]->section
;
8232 if (sec
->output_section
)
8234 value
+= sec
->output_offset
;
8235 sec
= sec
->output_section
;
8238 /* Don't add in the section vma for relocatable output. */
8239 if (! relocatable_p
)
8241 sym
.st_value
= value
;
8242 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8244 if (bfd_is_abs_section (sec
)
8246 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8248 /* This symbol is in a real ELF section which we did
8249 not create as a BFD section. Undo the mapping done
8250 by copy_private_symbol_data. */
8251 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8255 shndx
= elf_onesymtab (abfd
);
8258 shndx
= elf_dynsymtab (abfd
);
8261 shndx
= elf_strtab_sec (abfd
);
8264 shndx
= elf_shstrtab_sec (abfd
);
8267 if (elf_symtab_shndx_list (abfd
))
8268 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8275 if (shndx
>= SHN_LOPROC
&& shndx
<= SHN_HIOS
)
8277 if (bed
->symbol_section_index
)
8278 shndx
= bed
->symbol_section_index (abfd
, type_ptr
);
8279 /* Otherwise just leave the index alone. */
8283 if (shndx
> SHN_HIOS
&& shndx
< SHN_HIRESERVE
)
8284 _bfd_error_handler (_("%pB: \
8285 Unable to handle section index %x in ELF symbol. Using ABS instead."),
8294 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8296 if (shndx
== SHN_BAD
)
8300 /* Writing this would be a hell of a lot easier if
8301 we had some decent documentation on bfd, and
8302 knew what to expect of the library, and what to
8303 demand of applications. For example, it
8304 appears that `objcopy' might not set the
8305 section of a symbol to be a section that is
8306 actually in the output file. */
8307 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8309 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8310 if (shndx
== SHN_BAD
)
8312 /* xgettext:c-format */
8314 (_("unable to find equivalent output section"
8315 " for symbol '%s' from section '%s'"),
8316 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8318 bfd_set_error (bfd_error_invalid_operation
);
8324 sym
.st_shndx
= shndx
;
8327 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8329 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8330 type
= STT_GNU_IFUNC
;
8331 else if ((flags
& BSF_FUNCTION
) != 0)
8333 else if ((flags
& BSF_OBJECT
) != 0)
8335 else if ((flags
& BSF_RELC
) != 0)
8337 else if ((flags
& BSF_SRELC
) != 0)
8342 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8345 /* Processor-specific types. */
8346 if (type_ptr
!= NULL
8347 && bed
->elf_backend_get_symbol_type
)
8348 type
= ((*bed
->elf_backend_get_symbol_type
)
8349 (&type_ptr
->internal_elf_sym
, type
));
8351 if (flags
& BSF_SECTION_SYM
)
8353 if (flags
& BSF_GLOBAL
)
8354 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8356 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8358 else if (bfd_is_com_section (syms
[idx
]->section
))
8360 if (type
!= STT_TLS
)
8362 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8363 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8364 ? STT_COMMON
: STT_OBJECT
);
8366 type
= ((flags
& BSF_ELF_COMMON
) != 0
8367 ? STT_COMMON
: STT_OBJECT
);
8369 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8371 else if (bfd_is_und_section (syms
[idx
]->section
))
8372 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8376 else if (flags
& BSF_FILE
)
8377 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8380 int bind
= STB_LOCAL
;
8382 if (flags
& BSF_LOCAL
)
8384 else if (flags
& BSF_GNU_UNIQUE
)
8385 bind
= STB_GNU_UNIQUE
;
8386 else if (flags
& BSF_WEAK
)
8388 else if (flags
& BSF_GLOBAL
)
8391 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8394 if (type_ptr
!= NULL
)
8396 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8397 sym
.st_target_internal
8398 = type_ptr
->internal_elf_sym
.st_target_internal
;
8403 sym
.st_target_internal
= 0;
8407 symstrtab
[idx
].sym
= sym
;
8408 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8409 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8411 outbound_syms_index
++;
8412 if (outbound_shndx
!= NULL
)
8413 outbound_shndx_index
++;
8416 /* Finalize the .strtab section. */
8417 _bfd_elf_strtab_finalize (stt
);
8419 /* Swap out the .strtab section. */
8420 for (idx
= 0; idx
<= symcount
; idx
++)
8422 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8423 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8424 elfsym
->sym
.st_name
= 0;
8426 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8427 elfsym
->sym
.st_name
);
8428 if (info
&& info
->callbacks
->ctf_new_symbol
)
8429 info
->callbacks
->ctf_new_symbol (elfsym
->dest_index
,
8432 /* Inform the linker of the addition of this symbol. */
8434 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8436 + (elfsym
->dest_index
8437 * bed
->s
->sizeof_sym
)),
8439 + (elfsym
->destshndx_index
8440 * sizeof (Elf_External_Sym_Shndx
))));
8445 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8446 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8447 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8448 symstrtab_hdr
->sh_addr
= 0;
8449 symstrtab_hdr
->sh_entsize
= 0;
8450 symstrtab_hdr
->sh_link
= 0;
8451 symstrtab_hdr
->sh_info
= 0;
8452 symstrtab_hdr
->sh_addralign
= 1;
8457 /* Return the number of bytes required to hold the symtab vector.
8459 Note that we base it on the count plus 1, since we will null terminate
8460 the vector allocated based on this size. However, the ELF symbol table
8461 always has a dummy entry as symbol #0, so it ends up even. */
8464 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8466 bfd_size_type symcount
;
8468 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8470 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8471 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8473 bfd_set_error (bfd_error_file_too_big
);
8476 symtab_size
= symcount
* (sizeof (asymbol
*));
8478 symtab_size
= sizeof (asymbol
*);
8479 else if (!bfd_write_p (abfd
))
8481 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8483 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8485 bfd_set_error (bfd_error_file_truncated
);
8494 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8496 bfd_size_type symcount
;
8498 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8500 if (elf_dynsymtab (abfd
) == 0)
8502 bfd_set_error (bfd_error_invalid_operation
);
8506 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8507 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8509 bfd_set_error (bfd_error_file_too_big
);
8512 symtab_size
= symcount
* (sizeof (asymbol
*));
8514 symtab_size
= sizeof (asymbol
*);
8515 else if (!bfd_write_p (abfd
))
8517 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8519 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8521 bfd_set_error (bfd_error_file_truncated
);
8530 _bfd_elf_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
8532 if (asect
->reloc_count
!= 0 && !bfd_write_p (abfd
))
8534 /* Sanity check reloc section size. */
8535 struct bfd_elf_section_data
*d
= elf_section_data (asect
);
8536 Elf_Internal_Shdr
*rel_hdr
= &d
->this_hdr
;
8537 bfd_size_type ext_rel_size
= rel_hdr
->sh_size
;
8538 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8540 if (filesize
!= 0 && ext_rel_size
> filesize
)
8542 bfd_set_error (bfd_error_file_truncated
);
8547 #if SIZEOF_LONG == SIZEOF_INT
8548 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8550 bfd_set_error (bfd_error_file_too_big
);
8554 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8557 /* Canonicalize the relocs. */
8560 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8567 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8569 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, false))
8572 tblptr
= section
->relocation
;
8573 for (i
= 0; i
< section
->reloc_count
; i
++)
8574 *relptr
++ = tblptr
++;
8578 return section
->reloc_count
;
8582 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8584 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8585 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, false);
8588 abfd
->symcount
= symcount
;
8593 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8594 asymbol
**allocation
)
8596 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8597 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, true);
8600 abfd
->dynsymcount
= symcount
;
8604 /* Return the size required for the dynamic reloc entries. Any loadable
8605 section that was actually installed in the BFD, and has type SHT_REL
8606 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8607 dynamic reloc section. */
8610 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8612 bfd_size_type count
, ext_rel_size
;
8615 if (elf_dynsymtab (abfd
) == 0)
8617 bfd_set_error (bfd_error_invalid_operation
);
8623 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8624 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8625 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8626 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8628 ext_rel_size
+= s
->size
;
8629 if (ext_rel_size
< s
->size
)
8631 bfd_set_error (bfd_error_file_truncated
);
8634 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8635 if (count
> LONG_MAX
/ sizeof (arelent
*))
8637 bfd_set_error (bfd_error_file_too_big
);
8641 if (count
> 1 && !bfd_write_p (abfd
))
8643 /* Sanity check reloc section sizes. */
8644 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8645 if (filesize
!= 0 && ext_rel_size
> filesize
)
8647 bfd_set_error (bfd_error_file_truncated
);
8651 return count
* sizeof (arelent
*);
8654 /* Canonicalize the dynamic relocation entries. Note that we return the
8655 dynamic relocations as a single block, although they are actually
8656 associated with particular sections; the interface, which was
8657 designed for SunOS style shared libraries, expects that there is only
8658 one set of dynamic relocs. Any loadable section that was actually
8659 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8660 dynamic symbol table, is considered to be a dynamic reloc section. */
8663 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8667 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
8671 if (elf_dynsymtab (abfd
) == 0)
8673 bfd_set_error (bfd_error_invalid_operation
);
8677 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8679 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8681 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8682 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8683 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8688 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
8690 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8692 for (i
= 0; i
< count
; i
++)
8703 /* Read in the version information. */
8706 _bfd_elf_slurp_version_tables (bfd
*abfd
, bool default_imported_symver
)
8708 bfd_byte
*contents
= NULL
;
8709 unsigned int freeidx
= 0;
8712 if (elf_dynverref (abfd
) != 0)
8714 Elf_Internal_Shdr
*hdr
;
8715 Elf_External_Verneed
*everneed
;
8716 Elf_Internal_Verneed
*iverneed
;
8718 bfd_byte
*contents_end
;
8720 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8722 if (hdr
->sh_info
== 0
8723 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8725 error_return_bad_verref
:
8727 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8728 bfd_set_error (bfd_error_bad_value
);
8729 error_return_verref
:
8730 elf_tdata (abfd
)->verref
= NULL
;
8731 elf_tdata (abfd
)->cverrefs
= 0;
8735 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8736 goto error_return_verref
;
8737 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8738 if (contents
== NULL
)
8739 goto error_return_verref
;
8741 if (_bfd_mul_overflow (hdr
->sh_info
, sizeof (Elf_Internal_Verneed
), &amt
))
8743 bfd_set_error (bfd_error_file_too_big
);
8744 goto error_return_verref
;
8746 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*) bfd_alloc (abfd
, amt
);
8747 if (elf_tdata (abfd
)->verref
== NULL
)
8748 goto error_return_verref
;
8750 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8751 == sizeof (Elf_External_Vernaux
));
8752 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8753 everneed
= (Elf_External_Verneed
*) contents
;
8754 iverneed
= elf_tdata (abfd
)->verref
;
8755 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8757 Elf_External_Vernaux
*evernaux
;
8758 Elf_Internal_Vernaux
*ivernaux
;
8761 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8763 iverneed
->vn_bfd
= abfd
;
8765 iverneed
->vn_filename
=
8766 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8768 if (iverneed
->vn_filename
== NULL
)
8769 goto error_return_bad_verref
;
8771 if (iverneed
->vn_cnt
== 0)
8772 iverneed
->vn_auxptr
= NULL
;
8775 if (_bfd_mul_overflow (iverneed
->vn_cnt
,
8776 sizeof (Elf_Internal_Vernaux
), &amt
))
8778 bfd_set_error (bfd_error_file_too_big
);
8779 goto error_return_verref
;
8781 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8782 bfd_alloc (abfd
, amt
);
8783 if (iverneed
->vn_auxptr
== NULL
)
8784 goto error_return_verref
;
8787 if (iverneed
->vn_aux
8788 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8789 goto error_return_bad_verref
;
8791 evernaux
= ((Elf_External_Vernaux
*)
8792 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8793 ivernaux
= iverneed
->vn_auxptr
;
8794 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8796 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8798 ivernaux
->vna_nodename
=
8799 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8800 ivernaux
->vna_name
);
8801 if (ivernaux
->vna_nodename
== NULL
)
8802 goto error_return_bad_verref
;
8804 if (ivernaux
->vna_other
> freeidx
)
8805 freeidx
= ivernaux
->vna_other
;
8807 ivernaux
->vna_nextptr
= NULL
;
8808 if (ivernaux
->vna_next
== 0)
8810 iverneed
->vn_cnt
= j
+ 1;
8813 if (j
+ 1 < iverneed
->vn_cnt
)
8814 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8816 if (ivernaux
->vna_next
8817 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8818 goto error_return_bad_verref
;
8820 evernaux
= ((Elf_External_Vernaux
*)
8821 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8824 iverneed
->vn_nextref
= NULL
;
8825 if (iverneed
->vn_next
== 0)
8827 if (i
+ 1 < hdr
->sh_info
)
8828 iverneed
->vn_nextref
= iverneed
+ 1;
8830 if (iverneed
->vn_next
8831 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8832 goto error_return_bad_verref
;
8834 everneed
= ((Elf_External_Verneed
*)
8835 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8837 elf_tdata (abfd
)->cverrefs
= i
;
8843 if (elf_dynverdef (abfd
) != 0)
8845 Elf_Internal_Shdr
*hdr
;
8846 Elf_External_Verdef
*everdef
;
8847 Elf_Internal_Verdef
*iverdef
;
8848 Elf_Internal_Verdef
*iverdefarr
;
8849 Elf_Internal_Verdef iverdefmem
;
8851 unsigned int maxidx
;
8852 bfd_byte
*contents_end_def
, *contents_end_aux
;
8854 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8856 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8858 error_return_bad_verdef
:
8860 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8861 bfd_set_error (bfd_error_bad_value
);
8862 error_return_verdef
:
8863 elf_tdata (abfd
)->verdef
= NULL
;
8864 elf_tdata (abfd
)->cverdefs
= 0;
8868 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8869 goto error_return_verdef
;
8870 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8871 if (contents
== NULL
)
8872 goto error_return_verdef
;
8874 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8875 >= sizeof (Elf_External_Verdaux
));
8876 contents_end_def
= contents
+ hdr
->sh_size
8877 - sizeof (Elf_External_Verdef
);
8878 contents_end_aux
= contents
+ hdr
->sh_size
8879 - sizeof (Elf_External_Verdaux
);
8881 /* We know the number of entries in the section but not the maximum
8882 index. Therefore we have to run through all entries and find
8884 everdef
= (Elf_External_Verdef
*) contents
;
8886 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8888 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8890 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8891 goto error_return_bad_verdef
;
8892 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8893 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8895 if (iverdefmem
.vd_next
== 0)
8898 if (iverdefmem
.vd_next
8899 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8900 goto error_return_bad_verdef
;
8902 everdef
= ((Elf_External_Verdef
*)
8903 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8906 if (default_imported_symver
)
8908 if (freeidx
> maxidx
)
8913 if (_bfd_mul_overflow (maxidx
, sizeof (Elf_Internal_Verdef
), &amt
))
8915 bfd_set_error (bfd_error_file_too_big
);
8916 goto error_return_verdef
;
8918 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
8919 if (elf_tdata (abfd
)->verdef
== NULL
)
8920 goto error_return_verdef
;
8922 elf_tdata (abfd
)->cverdefs
= maxidx
;
8924 everdef
= (Elf_External_Verdef
*) contents
;
8925 iverdefarr
= elf_tdata (abfd
)->verdef
;
8926 for (i
= 0; i
< hdr
->sh_info
; i
++)
8928 Elf_External_Verdaux
*everdaux
;
8929 Elf_Internal_Verdaux
*iverdaux
;
8932 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8934 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8935 goto error_return_bad_verdef
;
8937 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8938 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8940 iverdef
->vd_bfd
= abfd
;
8942 if (iverdef
->vd_cnt
== 0)
8943 iverdef
->vd_auxptr
= NULL
;
8946 if (_bfd_mul_overflow (iverdef
->vd_cnt
,
8947 sizeof (Elf_Internal_Verdaux
), &amt
))
8949 bfd_set_error (bfd_error_file_too_big
);
8950 goto error_return_verdef
;
8952 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8953 bfd_alloc (abfd
, amt
);
8954 if (iverdef
->vd_auxptr
== NULL
)
8955 goto error_return_verdef
;
8959 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8960 goto error_return_bad_verdef
;
8962 everdaux
= ((Elf_External_Verdaux
*)
8963 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8964 iverdaux
= iverdef
->vd_auxptr
;
8965 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8967 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8969 iverdaux
->vda_nodename
=
8970 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8971 iverdaux
->vda_name
);
8972 if (iverdaux
->vda_nodename
== NULL
)
8973 goto error_return_bad_verdef
;
8975 iverdaux
->vda_nextptr
= NULL
;
8976 if (iverdaux
->vda_next
== 0)
8978 iverdef
->vd_cnt
= j
+ 1;
8981 if (j
+ 1 < iverdef
->vd_cnt
)
8982 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8984 if (iverdaux
->vda_next
8985 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8986 goto error_return_bad_verdef
;
8988 everdaux
= ((Elf_External_Verdaux
*)
8989 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8992 iverdef
->vd_nodename
= NULL
;
8993 if (iverdef
->vd_cnt
)
8994 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8996 iverdef
->vd_nextdef
= NULL
;
8997 if (iverdef
->vd_next
== 0)
8999 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
9000 iverdef
->vd_nextdef
= iverdef
+ 1;
9002 everdef
= ((Elf_External_Verdef
*)
9003 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
9009 else if (default_imported_symver
)
9016 if (_bfd_mul_overflow (freeidx
, sizeof (Elf_Internal_Verdef
), &amt
))
9018 bfd_set_error (bfd_error_file_too_big
);
9021 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
9022 if (elf_tdata (abfd
)->verdef
== NULL
)
9025 elf_tdata (abfd
)->cverdefs
= freeidx
;
9028 /* Create a default version based on the soname. */
9029 if (default_imported_symver
)
9031 Elf_Internal_Verdef
*iverdef
;
9032 Elf_Internal_Verdaux
*iverdaux
;
9034 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
9036 iverdef
->vd_version
= VER_DEF_CURRENT
;
9037 iverdef
->vd_flags
= 0;
9038 iverdef
->vd_ndx
= freeidx
;
9039 iverdef
->vd_cnt
= 1;
9041 iverdef
->vd_bfd
= abfd
;
9043 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
9044 if (iverdef
->vd_nodename
== NULL
)
9045 goto error_return_verdef
;
9046 iverdef
->vd_nextdef
= NULL
;
9047 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
9048 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
9049 if (iverdef
->vd_auxptr
== NULL
)
9050 goto error_return_verdef
;
9052 iverdaux
= iverdef
->vd_auxptr
;
9053 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
9064 _bfd_elf_make_empty_symbol (bfd
*abfd
)
9066 elf_symbol_type
*newsym
;
9068 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
9071 newsym
->symbol
.the_bfd
= abfd
;
9072 return &newsym
->symbol
;
9076 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
9080 bfd_symbol_info (symbol
, ret
);
9083 /* Return whether a symbol name implies a local symbol. Most targets
9084 use this function for the is_local_label_name entry point, but some
9088 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
9091 /* Normal local symbols start with ``.L''. */
9092 if (name
[0] == '.' && name
[1] == 'L')
9095 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
9096 DWARF debugging symbols starting with ``..''. */
9097 if (name
[0] == '.' && name
[1] == '.')
9100 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
9101 emitting DWARF debugging output. I suspect this is actually a
9102 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
9103 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
9104 underscore to be emitted on some ELF targets). For ease of use,
9105 we treat such symbols as local. */
9106 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
9109 /* Treat assembler generated fake symbols, dollar local labels and
9110 forward-backward labels (aka local labels) as locals.
9111 These labels have the form:
9113 L0^A.* (fake symbols)
9115 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
9117 Versions which start with .L will have already been matched above,
9118 so we only need to match the rest. */
9119 if (name
[0] == 'L' && ISDIGIT (name
[1]))
9125 for (p
= name
+ 2; (c
= *p
); p
++)
9127 if (c
== 1 || c
== 2)
9129 if (c
== 1 && p
== name
+ 2)
9130 /* A fake symbol. */
9133 /* FIXME: We are being paranoid here and treating symbols like
9134 L0^Bfoo as if there were non-local, on the grounds that the
9135 assembler will never generate them. But can any symbol
9136 containing an ASCII value in the range 1-31 ever be anything
9137 other than some kind of local ? */
9154 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9155 asymbol
*symbol ATTRIBUTE_UNUSED
)
9162 _bfd_elf_set_arch_mach (bfd
*abfd
,
9163 enum bfd_architecture arch
,
9164 unsigned long machine
)
9166 /* If this isn't the right architecture for this backend, and this
9167 isn't the generic backend, fail. */
9168 if (arch
!= get_elf_backend_data (abfd
)->arch
9169 && arch
!= bfd_arch_unknown
9170 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9173 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9176 /* Find the nearest line to a particular section and offset,
9177 for error reporting. */
9180 _bfd_elf_find_nearest_line (bfd
*abfd
,
9184 const char **filename_ptr
,
9185 const char **functionname_ptr
,
9186 unsigned int *line_ptr
,
9187 unsigned int *discriminator_ptr
)
9191 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9192 filename_ptr
, functionname_ptr
,
9193 line_ptr
, discriminator_ptr
,
9194 dwarf_debug_sections
,
9195 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9198 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9199 filename_ptr
, functionname_ptr
, line_ptr
))
9201 if (!*functionname_ptr
)
9202 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9203 *filename_ptr
? NULL
: filename_ptr
,
9208 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9209 &found
, filename_ptr
,
9210 functionname_ptr
, line_ptr
,
9211 &elf_tdata (abfd
)->line_info
))
9213 if (found
&& (*functionname_ptr
|| *line_ptr
))
9216 if (symbols
== NULL
)
9219 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9220 filename_ptr
, functionname_ptr
))
9227 /* Find the line for a symbol. */
9230 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9231 const char **filename_ptr
, unsigned int *line_ptr
)
9233 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9234 filename_ptr
, NULL
, line_ptr
, NULL
,
9235 dwarf_debug_sections
,
9236 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9239 /* After a call to bfd_find_nearest_line, successive calls to
9240 bfd_find_inliner_info can be used to get source information about
9241 each level of function inlining that terminated at the address
9242 passed to bfd_find_nearest_line. Currently this is only supported
9243 for DWARF2 with appropriate DWARF3 extensions. */
9246 _bfd_elf_find_inliner_info (bfd
*abfd
,
9247 const char **filename_ptr
,
9248 const char **functionname_ptr
,
9249 unsigned int *line_ptr
)
9252 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9253 functionname_ptr
, line_ptr
,
9254 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9259 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9261 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9262 int ret
= bed
->s
->sizeof_ehdr
;
9264 if (!bfd_link_relocatable (info
))
9266 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9268 if (phdr_size
== (bfd_size_type
) -1)
9270 struct elf_segment_map
*m
;
9273 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9274 phdr_size
+= bed
->s
->sizeof_phdr
;
9277 phdr_size
= get_program_header_size (abfd
, info
);
9280 elf_program_header_size (abfd
) = phdr_size
;
9288 _bfd_elf_set_section_contents (bfd
*abfd
,
9290 const void *location
,
9292 bfd_size_type count
)
9294 Elf_Internal_Shdr
*hdr
;
9297 if (! abfd
->output_has_begun
9298 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9304 hdr
= &elf_section_data (section
)->this_hdr
;
9305 if (hdr
->sh_offset
== (file_ptr
) -1)
9307 unsigned char *contents
;
9309 if (bfd_section_is_ctf (section
))
9310 /* Nothing to do with this section: the contents are generated
9314 if ((section
->flags
& SEC_ELF_COMPRESS
) == 0)
9317 (_("%pB:%pA: error: attempting to write into an unallocated compressed section"),
9319 bfd_set_error (bfd_error_invalid_operation
);
9323 if ((offset
+ count
) > hdr
->sh_size
)
9326 (_("%pB:%pA: error: attempting to write over the end of the section"),
9329 bfd_set_error (bfd_error_invalid_operation
);
9333 contents
= hdr
->contents
;
9334 if (contents
== NULL
)
9337 (_("%pB:%pA: error: attempting to write section into an empty buffer"),
9340 bfd_set_error (bfd_error_invalid_operation
);
9344 memcpy (contents
+ offset
, location
, count
);
9348 pos
= hdr
->sh_offset
+ offset
;
9349 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9350 || bfd_bwrite (location
, count
, abfd
) != count
)
9357 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9358 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9359 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9365 /* Try to convert a non-ELF reloc into an ELF one. */
9368 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9370 /* Check whether we really have an ELF howto. */
9372 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9374 bfd_reloc_code_real_type code
;
9375 reloc_howto_type
*howto
;
9377 /* Alien reloc: Try to determine its type to replace it with an
9378 equivalent ELF reloc. */
9380 if (areloc
->howto
->pc_relative
)
9382 switch (areloc
->howto
->bitsize
)
9385 code
= BFD_RELOC_8_PCREL
;
9388 code
= BFD_RELOC_12_PCREL
;
9391 code
= BFD_RELOC_16_PCREL
;
9394 code
= BFD_RELOC_24_PCREL
;
9397 code
= BFD_RELOC_32_PCREL
;
9400 code
= BFD_RELOC_64_PCREL
;
9406 howto
= bfd_reloc_type_lookup (abfd
, code
);
9408 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9410 if (howto
->pcrel_offset
)
9411 areloc
->addend
+= areloc
->address
;
9413 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9418 switch (areloc
->howto
->bitsize
)
9424 code
= BFD_RELOC_14
;
9427 code
= BFD_RELOC_16
;
9430 code
= BFD_RELOC_26
;
9433 code
= BFD_RELOC_32
;
9436 code
= BFD_RELOC_64
;
9442 howto
= bfd_reloc_type_lookup (abfd
, code
);
9446 areloc
->howto
= howto
;
9454 /* xgettext:c-format */
9455 _bfd_error_handler (_("%pB: %s unsupported"),
9456 abfd
, areloc
->howto
->name
);
9457 bfd_set_error (bfd_error_sorry
);
9462 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9464 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9466 && (bfd_get_format (abfd
) == bfd_object
9467 || bfd_get_format (abfd
) == bfd_core
))
9469 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9470 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9471 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9474 return _bfd_generic_close_and_cleanup (abfd
);
9477 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9478 in the relocation's offset. Thus we cannot allow any sort of sanity
9479 range-checking to interfere. There is nothing else to do in processing
9482 bfd_reloc_status_type
9483 _bfd_elf_rel_vtable_reloc_fn
9484 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9485 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9486 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9487 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9489 return bfd_reloc_ok
;
9492 /* Elf core file support. Much of this only works on native
9493 toolchains, since we rely on knowing the
9494 machine-dependent procfs structure in order to pick
9495 out details about the corefile. */
9497 #ifdef HAVE_SYS_PROCFS_H
9498 # include <sys/procfs.h>
9501 /* Return a PID that identifies a "thread" for threaded cores, or the
9502 PID of the main process for non-threaded cores. */
9505 elfcore_make_pid (bfd
*abfd
)
9509 pid
= elf_tdata (abfd
)->core
->lwpid
;
9511 pid
= elf_tdata (abfd
)->core
->pid
;
9516 /* If there isn't a section called NAME, make one, using
9517 data from SECT. Note, this function will generate a
9518 reference to NAME, so you shouldn't deallocate or
9522 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9526 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9529 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9533 sect2
->size
= sect
->size
;
9534 sect2
->filepos
= sect
->filepos
;
9535 sect2
->alignment_power
= sect
->alignment_power
;
9539 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9540 actually creates up to two pseudosections:
9541 - For the single-threaded case, a section named NAME, unless
9542 such a section already exists.
9543 - For the multi-threaded case, a section named "NAME/PID", where
9544 PID is elfcore_make_pid (abfd).
9545 Both pseudosections have identical contents. */
9547 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9553 char *threaded_name
;
9557 /* Build the section name. */
9559 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9560 len
= strlen (buf
) + 1;
9561 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9562 if (threaded_name
== NULL
)
9564 memcpy (threaded_name
, buf
, len
);
9566 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9571 sect
->filepos
= filepos
;
9572 sect
->alignment_power
= 2;
9574 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9578 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9581 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9587 sect
->size
= note
->descsz
- offs
;
9588 sect
->filepos
= note
->descpos
+ offs
;
9589 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9594 /* prstatus_t exists on:
9596 linux 2.[01] + glibc
9600 #if defined (HAVE_PRSTATUS_T)
9603 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9608 if (note
->descsz
== sizeof (prstatus_t
))
9612 size
= sizeof (prstat
.pr_reg
);
9613 offset
= offsetof (prstatus_t
, pr_reg
);
9614 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9616 /* Do not overwrite the core signal if it
9617 has already been set by another thread. */
9618 if (elf_tdata (abfd
)->core
->signal
== 0)
9619 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9620 if (elf_tdata (abfd
)->core
->pid
== 0)
9621 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9623 /* pr_who exists on:
9626 pr_who doesn't exist on:
9629 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9630 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9632 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9635 #if defined (HAVE_PRSTATUS32_T)
9636 else if (note
->descsz
== sizeof (prstatus32_t
))
9638 /* 64-bit host, 32-bit corefile */
9639 prstatus32_t prstat
;
9641 size
= sizeof (prstat
.pr_reg
);
9642 offset
= offsetof (prstatus32_t
, pr_reg
);
9643 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9645 /* Do not overwrite the core signal if it
9646 has already been set by another thread. */
9647 if (elf_tdata (abfd
)->core
->signal
== 0)
9648 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9649 if (elf_tdata (abfd
)->core
->pid
== 0)
9650 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9652 /* pr_who exists on:
9655 pr_who doesn't exist on:
9658 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9659 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9661 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9664 #endif /* HAVE_PRSTATUS32_T */
9667 /* Fail - we don't know how to handle any other
9668 note size (ie. data object type). */
9672 /* Make a ".reg/999" section and a ".reg" section. */
9673 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9674 size
, note
->descpos
+ offset
);
9676 #endif /* defined (HAVE_PRSTATUS_T) */
9678 /* Create a pseudosection containing the exact contents of NOTE. */
9680 elfcore_make_note_pseudosection (bfd
*abfd
,
9682 Elf_Internal_Note
*note
)
9684 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9685 note
->descsz
, note
->descpos
);
9688 /* There isn't a consistent prfpregset_t across platforms,
9689 but it doesn't matter, because we don't have to pick this
9690 data structure apart. */
9693 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9695 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9698 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9699 type of NT_PRXFPREG. Just include the whole note's contents
9703 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9705 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9708 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9709 with a note type of NT_X86_XSTATE. Just include the whole note's
9710 contents literally. */
9713 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9715 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9719 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9721 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9725 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9727 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9731 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9733 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9737 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9739 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9743 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9745 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9749 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9751 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9755 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9757 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9761 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9763 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9767 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9769 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9773 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9775 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9779 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9781 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9785 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9787 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9791 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9793 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9797 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9799 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9803 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9805 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9809 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9811 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9815 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9817 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9821 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9823 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9827 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9829 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9833 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9835 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9839 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9841 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9845 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9847 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9851 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9853 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9857 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9859 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9863 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9865 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9869 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9871 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9875 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9877 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9881 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9883 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9887 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9889 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9893 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9895 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9899 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9901 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9905 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9907 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9911 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9913 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9917 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9919 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9923 elfcore_grok_arc_v2 (bfd
*abfd
, Elf_Internal_Note
*note
)
9925 return elfcore_make_note_pseudosection (abfd
, ".reg-arc-v2", note
);
9928 /* Convert NOTE into a bfd_section called ".reg-riscv-csr". Return TRUE if
9929 successful otherwise, return FALSE. */
9932 elfcore_grok_riscv_csr (bfd
*abfd
, Elf_Internal_Note
*note
)
9934 return elfcore_make_note_pseudosection (abfd
, ".reg-riscv-csr", note
);
9937 /* Convert NOTE into a bfd_section called ".gdb-tdesc". Return TRUE if
9938 successful otherwise, return FALSE. */
9941 elfcore_grok_gdb_tdesc (bfd
*abfd
, Elf_Internal_Note
*note
)
9943 return elfcore_make_note_pseudosection (abfd
, ".gdb-tdesc", note
);
9946 #if defined (HAVE_PRPSINFO_T)
9947 typedef prpsinfo_t elfcore_psinfo_t
;
9948 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9949 typedef prpsinfo32_t elfcore_psinfo32_t
;
9953 #if defined (HAVE_PSINFO_T)
9954 typedef psinfo_t elfcore_psinfo_t
;
9955 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9956 typedef psinfo32_t elfcore_psinfo32_t
;
9960 /* return a malloc'ed copy of a string at START which is at
9961 most MAX bytes long, possibly without a terminating '\0'.
9962 the copy will always have a terminating '\0'. */
9965 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9968 char *end
= (char *) memchr (start
, '\0', max
);
9976 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9980 memcpy (dups
, start
, len
);
9986 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9988 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9990 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9992 elfcore_psinfo_t psinfo
;
9994 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9996 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9997 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9999 elf_tdata (abfd
)->core
->program
10000 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10001 sizeof (psinfo
.pr_fname
));
10003 elf_tdata (abfd
)->core
->command
10004 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10005 sizeof (psinfo
.pr_psargs
));
10007 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10008 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
10010 /* 64-bit host, 32-bit corefile */
10011 elfcore_psinfo32_t psinfo
;
10013 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
10015 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
10016 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
10018 elf_tdata (abfd
)->core
->program
10019 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
10020 sizeof (psinfo
.pr_fname
));
10022 elf_tdata (abfd
)->core
->command
10023 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
10024 sizeof (psinfo
.pr_psargs
));
10030 /* Fail - we don't know how to handle any other
10031 note size (ie. data object type). */
10035 /* Note that for some reason, a spurious space is tacked
10036 onto the end of the args in some (at least one anyway)
10037 implementations, so strip it off if it exists. */
10040 char *command
= elf_tdata (abfd
)->core
->command
;
10041 int n
= strlen (command
);
10043 if (0 < n
&& command
[n
- 1] == ' ')
10044 command
[n
- 1] = '\0';
10049 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
10051 #if defined (HAVE_PSTATUS_T)
10053 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10055 if (note
->descsz
== sizeof (pstatus_t
)
10056 #if defined (HAVE_PXSTATUS_T)
10057 || note
->descsz
== sizeof (pxstatus_t
)
10063 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10065 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10067 #if defined (HAVE_PSTATUS32_T)
10068 else if (note
->descsz
== sizeof (pstatus32_t
))
10070 /* 64-bit host, 32-bit corefile */
10073 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10075 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10078 /* Could grab some more details from the "representative"
10079 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
10080 NT_LWPSTATUS note, presumably. */
10084 #endif /* defined (HAVE_PSTATUS_T) */
10086 #if defined (HAVE_LWPSTATUS_T)
10088 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10090 lwpstatus_t lwpstat
;
10096 if (note
->descsz
!= sizeof (lwpstat
)
10097 #if defined (HAVE_LWPXSTATUS_T)
10098 && note
->descsz
!= sizeof (lwpxstatus_t
)
10103 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
10105 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
10106 /* Do not overwrite the core signal if it has already been set by
10108 if (elf_tdata (abfd
)->core
->signal
== 0)
10109 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
10111 /* Make a ".reg/999" section. */
10113 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
10114 len
= strlen (buf
) + 1;
10115 name
= bfd_alloc (abfd
, len
);
10118 memcpy (name
, buf
, len
);
10120 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10124 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10125 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
10126 sect
->filepos
= note
->descpos
10127 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
10130 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10131 sect
->size
= sizeof (lwpstat
.pr_reg
);
10132 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
10135 sect
->alignment_power
= 2;
10137 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10140 /* Make a ".reg2/999" section */
10142 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
10143 len
= strlen (buf
) + 1;
10144 name
= bfd_alloc (abfd
, len
);
10147 memcpy (name
, buf
, len
);
10149 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10153 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10154 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
10155 sect
->filepos
= note
->descpos
10156 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
10159 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
10160 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
10161 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
10164 sect
->alignment_power
= 2;
10166 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
10168 #endif /* defined (HAVE_LWPSTATUS_T) */
10170 /* These constants, and the structure offsets used below, are defined by
10171 Cygwin's core_dump.h */
10172 #define NOTE_INFO_PROCESS 1
10173 #define NOTE_INFO_THREAD 2
10174 #define NOTE_INFO_MODULE 3
10175 #define NOTE_INFO_MODULE64 4
10178 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10183 unsigned int name_size
;
10186 int is_active_thread
;
10189 if (note
->descsz
< 4)
10192 if (! startswith (note
->namedata
, "win32"))
10195 type
= bfd_get_32 (abfd
, note
->descdata
);
10199 const char *type_name
;
10200 unsigned long min_size
;
10203 { "NOTE_INFO_PROCESS", 12 },
10204 { "NOTE_INFO_THREAD", 12 },
10205 { "NOTE_INFO_MODULE", 12 },
10206 { "NOTE_INFO_MODULE64", 16 },
10209 if (type
== 0 || type
> (sizeof(size_check
)/sizeof(size_check
[0])))
10212 if (note
->descsz
< size_check
[type
- 1].min_size
)
10214 _bfd_error_handler (_("%pB: warning: win32pstatus %s of size %lu bytes is too small"),
10215 abfd
, size_check
[type
- 1].type_name
, note
->descsz
);
10221 case NOTE_INFO_PROCESS
:
10222 /* FIXME: need to add ->core->command. */
10223 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10224 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10227 case NOTE_INFO_THREAD
:
10228 /* Make a ".reg/<tid>" section containing the Win32 API thread CONTEXT
10230 /* thread_info.tid */
10231 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 4));
10233 len
= strlen (buf
) + 1;
10234 name
= (char *) bfd_alloc (abfd
, len
);
10238 memcpy (name
, buf
, len
);
10240 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10244 /* sizeof (thread_info.thread_context) */
10245 sect
->size
= note
->descsz
- 12;
10246 /* offsetof (thread_info.thread_context) */
10247 sect
->filepos
= note
->descpos
+ 12;
10248 sect
->alignment_power
= 2;
10250 /* thread_info.is_active_thread */
10251 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10253 if (is_active_thread
)
10254 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10258 case NOTE_INFO_MODULE
:
10259 case NOTE_INFO_MODULE64
:
10260 /* Make a ".module/xxxxxxxx" section. */
10261 if (type
== NOTE_INFO_MODULE
)
10263 /* module_info.base_address */
10264 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10265 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10266 /* module_info.module_name_size */
10267 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10269 else /* NOTE_INFO_MODULE64 */
10271 /* module_info.base_address */
10272 base_addr
= bfd_get_64 (abfd
, note
->descdata
+ 4);
10273 sprintf (buf
, ".module/%016lx", (unsigned long) base_addr
);
10274 /* module_info.module_name_size */
10275 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10278 len
= strlen (buf
) + 1;
10279 name
= (char *) bfd_alloc (abfd
, len
);
10283 memcpy (name
, buf
, len
);
10285 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10290 if (note
->descsz
< 12 + name_size
)
10292 _bfd_error_handler (_("%pB: win32pstatus NOTE_INFO_MODULE of size %lu is too small to contain a name of size %u"),
10293 abfd
, note
->descsz
, name_size
);
10297 sect
->size
= note
->descsz
;
10298 sect
->filepos
= note
->descpos
;
10299 sect
->alignment_power
= 2;
10310 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10312 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10314 switch (note
->type
)
10320 if (bed
->elf_backend_grok_prstatus
)
10321 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10323 #if defined (HAVE_PRSTATUS_T)
10324 return elfcore_grok_prstatus (abfd
, note
);
10329 #if defined (HAVE_PSTATUS_T)
10331 return elfcore_grok_pstatus (abfd
, note
);
10334 #if defined (HAVE_LWPSTATUS_T)
10336 return elfcore_grok_lwpstatus (abfd
, note
);
10339 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10340 return elfcore_grok_prfpreg (abfd
, note
);
10342 case NT_WIN32PSTATUS
:
10343 return elfcore_grok_win32pstatus (abfd
, note
);
10345 case NT_PRXFPREG
: /* Linux SSE extension */
10346 if (note
->namesz
== 6
10347 && strcmp (note
->namedata
, "LINUX") == 0)
10348 return elfcore_grok_prxfpreg (abfd
, note
);
10352 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10353 if (note
->namesz
== 6
10354 && strcmp (note
->namedata
, "LINUX") == 0)
10355 return elfcore_grok_xstatereg (abfd
, note
);
10360 if (note
->namesz
== 6
10361 && strcmp (note
->namedata
, "LINUX") == 0)
10362 return elfcore_grok_ppc_vmx (abfd
, note
);
10367 if (note
->namesz
== 6
10368 && strcmp (note
->namedata
, "LINUX") == 0)
10369 return elfcore_grok_ppc_vsx (abfd
, note
);
10374 if (note
->namesz
== 6
10375 && strcmp (note
->namedata
, "LINUX") == 0)
10376 return elfcore_grok_ppc_tar (abfd
, note
);
10381 if (note
->namesz
== 6
10382 && strcmp (note
->namedata
, "LINUX") == 0)
10383 return elfcore_grok_ppc_ppr (abfd
, note
);
10388 if (note
->namesz
== 6
10389 && strcmp (note
->namedata
, "LINUX") == 0)
10390 return elfcore_grok_ppc_dscr (abfd
, note
);
10395 if (note
->namesz
== 6
10396 && strcmp (note
->namedata
, "LINUX") == 0)
10397 return elfcore_grok_ppc_ebb (abfd
, note
);
10402 if (note
->namesz
== 6
10403 && strcmp (note
->namedata
, "LINUX") == 0)
10404 return elfcore_grok_ppc_pmu (abfd
, note
);
10408 case NT_PPC_TM_CGPR
:
10409 if (note
->namesz
== 6
10410 && strcmp (note
->namedata
, "LINUX") == 0)
10411 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10415 case NT_PPC_TM_CFPR
:
10416 if (note
->namesz
== 6
10417 && strcmp (note
->namedata
, "LINUX") == 0)
10418 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10422 case NT_PPC_TM_CVMX
:
10423 if (note
->namesz
== 6
10424 && strcmp (note
->namedata
, "LINUX") == 0)
10425 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10429 case NT_PPC_TM_CVSX
:
10430 if (note
->namesz
== 6
10431 && strcmp (note
->namedata
, "LINUX") == 0)
10432 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10436 case NT_PPC_TM_SPR
:
10437 if (note
->namesz
== 6
10438 && strcmp (note
->namedata
, "LINUX") == 0)
10439 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10443 case NT_PPC_TM_CTAR
:
10444 if (note
->namesz
== 6
10445 && strcmp (note
->namedata
, "LINUX") == 0)
10446 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10450 case NT_PPC_TM_CPPR
:
10451 if (note
->namesz
== 6
10452 && strcmp (note
->namedata
, "LINUX") == 0)
10453 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10457 case NT_PPC_TM_CDSCR
:
10458 if (note
->namesz
== 6
10459 && strcmp (note
->namedata
, "LINUX") == 0)
10460 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10464 case NT_S390_HIGH_GPRS
:
10465 if (note
->namesz
== 6
10466 && strcmp (note
->namedata
, "LINUX") == 0)
10467 return elfcore_grok_s390_high_gprs (abfd
, note
);
10471 case NT_S390_TIMER
:
10472 if (note
->namesz
== 6
10473 && strcmp (note
->namedata
, "LINUX") == 0)
10474 return elfcore_grok_s390_timer (abfd
, note
);
10478 case NT_S390_TODCMP
:
10479 if (note
->namesz
== 6
10480 && strcmp (note
->namedata
, "LINUX") == 0)
10481 return elfcore_grok_s390_todcmp (abfd
, note
);
10485 case NT_S390_TODPREG
:
10486 if (note
->namesz
== 6
10487 && strcmp (note
->namedata
, "LINUX") == 0)
10488 return elfcore_grok_s390_todpreg (abfd
, note
);
10493 if (note
->namesz
== 6
10494 && strcmp (note
->namedata
, "LINUX") == 0)
10495 return elfcore_grok_s390_ctrs (abfd
, note
);
10499 case NT_S390_PREFIX
:
10500 if (note
->namesz
== 6
10501 && strcmp (note
->namedata
, "LINUX") == 0)
10502 return elfcore_grok_s390_prefix (abfd
, note
);
10506 case NT_S390_LAST_BREAK
:
10507 if (note
->namesz
== 6
10508 && strcmp (note
->namedata
, "LINUX") == 0)
10509 return elfcore_grok_s390_last_break (abfd
, note
);
10513 case NT_S390_SYSTEM_CALL
:
10514 if (note
->namesz
== 6
10515 && strcmp (note
->namedata
, "LINUX") == 0)
10516 return elfcore_grok_s390_system_call (abfd
, note
);
10521 if (note
->namesz
== 6
10522 && strcmp (note
->namedata
, "LINUX") == 0)
10523 return elfcore_grok_s390_tdb (abfd
, note
);
10527 case NT_S390_VXRS_LOW
:
10528 if (note
->namesz
== 6
10529 && strcmp (note
->namedata
, "LINUX") == 0)
10530 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10534 case NT_S390_VXRS_HIGH
:
10535 if (note
->namesz
== 6
10536 && strcmp (note
->namedata
, "LINUX") == 0)
10537 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10541 case NT_S390_GS_CB
:
10542 if (note
->namesz
== 6
10543 && strcmp (note
->namedata
, "LINUX") == 0)
10544 return elfcore_grok_s390_gs_cb (abfd
, note
);
10548 case NT_S390_GS_BC
:
10549 if (note
->namesz
== 6
10550 && strcmp (note
->namedata
, "LINUX") == 0)
10551 return elfcore_grok_s390_gs_bc (abfd
, note
);
10556 if (note
->namesz
== 6
10557 && strcmp (note
->namedata
, "LINUX") == 0)
10558 return elfcore_grok_arc_v2 (abfd
, note
);
10563 if (note
->namesz
== 6
10564 && strcmp (note
->namedata
, "LINUX") == 0)
10565 return elfcore_grok_arm_vfp (abfd
, note
);
10570 if (note
->namesz
== 6
10571 && strcmp (note
->namedata
, "LINUX") == 0)
10572 return elfcore_grok_aarch_tls (abfd
, note
);
10576 case NT_ARM_HW_BREAK
:
10577 if (note
->namesz
== 6
10578 && strcmp (note
->namedata
, "LINUX") == 0)
10579 return elfcore_grok_aarch_hw_break (abfd
, note
);
10583 case NT_ARM_HW_WATCH
:
10584 if (note
->namesz
== 6
10585 && strcmp (note
->namedata
, "LINUX") == 0)
10586 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10591 if (note
->namesz
== 6
10592 && strcmp (note
->namedata
, "LINUX") == 0)
10593 return elfcore_grok_aarch_sve (abfd
, note
);
10597 case NT_ARM_PAC_MASK
:
10598 if (note
->namesz
== 6
10599 && strcmp (note
->namedata
, "LINUX") == 0)
10600 return elfcore_grok_aarch_pauth (abfd
, note
);
10605 if (note
->namesz
== 4
10606 && strcmp (note
->namedata
, "GDB") == 0)
10607 return elfcore_grok_gdb_tdesc (abfd
, note
);
10612 if (note
->namesz
== 4
10613 && strcmp (note
->namedata
, "GDB") == 0)
10614 return elfcore_grok_riscv_csr (abfd
, note
);
10620 if (bed
->elf_backend_grok_psinfo
)
10621 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10623 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10624 return elfcore_grok_psinfo (abfd
, note
);
10630 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10633 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10637 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10644 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10646 struct bfd_build_id
* build_id
;
10648 if (note
->descsz
== 0)
10651 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10652 if (build_id
== NULL
)
10655 build_id
->size
= note
->descsz
;
10656 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10657 abfd
->build_id
= build_id
;
10663 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10665 switch (note
->type
)
10670 case NT_GNU_PROPERTY_TYPE_0
:
10671 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10673 case NT_GNU_BUILD_ID
:
10674 return elfobj_grok_gnu_build_id (abfd
, note
);
10679 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10681 struct sdt_note
*cur
=
10682 (struct sdt_note
*) bfd_alloc (abfd
,
10683 sizeof (struct sdt_note
) + note
->descsz
);
10685 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10686 cur
->size
= (bfd_size_type
) note
->descsz
;
10687 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10689 elf_tdata (abfd
)->sdt_note_head
= cur
;
10695 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10697 switch (note
->type
)
10700 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10708 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10712 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10715 if (note
->descsz
< 108)
10720 if (note
->descsz
< 120)
10728 /* Check for version 1 in pr_version. */
10729 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10734 /* Skip over pr_psinfosz. */
10735 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10739 offset
+= 4; /* Padding before pr_psinfosz. */
10743 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10744 elf_tdata (abfd
)->core
->program
10745 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10748 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10749 elf_tdata (abfd
)->core
->command
10750 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10753 /* Padding before pr_pid. */
10756 /* The pr_pid field was added in version "1a". */
10757 if (note
->descsz
< offset
+ 4)
10760 elf_tdata (abfd
)->core
->pid
10761 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10767 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10773 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10774 Also compute minimum size of this note. */
10775 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10779 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10783 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10784 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10791 if (note
->descsz
< min_size
)
10794 /* Check for version 1 in pr_version. */
10795 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10798 /* Extract size of pr_reg from pr_gregsetsz. */
10799 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10800 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10802 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10807 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10811 /* Skip over pr_osreldate. */
10814 /* Read signal from pr_cursig. */
10815 if (elf_tdata (abfd
)->core
->signal
== 0)
10816 elf_tdata (abfd
)->core
->signal
10817 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10820 /* Read TID from pr_pid. */
10821 elf_tdata (abfd
)->core
->lwpid
10822 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10825 /* Padding before pr_reg. */
10826 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10829 /* Make sure that there is enough data remaining in the note. */
10830 if ((note
->descsz
- offset
) < size
)
10833 /* Make a ".reg/999" section and a ".reg" section. */
10834 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10835 size
, note
->descpos
+ offset
);
10839 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10841 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10843 switch (note
->type
)
10846 if (bed
->elf_backend_grok_freebsd_prstatus
)
10847 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10849 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10852 return elfcore_grok_prfpreg (abfd
, note
);
10855 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10857 case NT_FREEBSD_THRMISC
:
10858 if (note
->namesz
== 8)
10859 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10863 case NT_FREEBSD_PROCSTAT_PROC
:
10864 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10867 case NT_FREEBSD_PROCSTAT_FILES
:
10868 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10871 case NT_FREEBSD_PROCSTAT_VMMAP
:
10872 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10875 case NT_FREEBSD_PROCSTAT_AUXV
:
10876 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10878 case NT_X86_XSTATE
:
10879 if (note
->namesz
== 8)
10880 return elfcore_grok_xstatereg (abfd
, note
);
10884 case NT_FREEBSD_PTLWPINFO
:
10885 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10889 return elfcore_grok_arm_vfp (abfd
, note
);
10897 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10901 cp
= strchr (note
->namedata
, '@');
10904 *lwpidp
= atoi(cp
+ 1);
10911 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10913 if (note
->descsz
<= 0x7c + 31)
10916 /* Signal number at offset 0x08. */
10917 elf_tdata (abfd
)->core
->signal
10918 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10920 /* Process ID at offset 0x50. */
10921 elf_tdata (abfd
)->core
->pid
10922 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10924 /* Command name at 0x7c (max 32 bytes, including nul). */
10925 elf_tdata (abfd
)->core
->command
10926 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10928 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10933 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10937 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10938 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10940 switch (note
->type
)
10942 case NT_NETBSDCORE_PROCINFO
:
10943 /* NetBSD-specific core "procinfo". Note that we expect to
10944 find this note before any of the others, which is fine,
10945 since the kernel writes this note out first when it
10946 creates a core file. */
10947 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10948 case NT_NETBSDCORE_AUXV
:
10949 /* NetBSD-specific Elf Auxiliary Vector data. */
10950 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10951 case NT_NETBSDCORE_LWPSTATUS
:
10952 return elfcore_make_note_pseudosection (abfd
,
10953 ".note.netbsdcore.lwpstatus",
10959 /* As of March 2020 there are no other machine-independent notes
10960 defined for NetBSD core files. If the note type is less
10961 than the start of the machine-dependent note types, we don't
10964 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10968 switch (bfd_get_arch (abfd
))
10970 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10971 PT_GETFPREGS == mach+2. */
10973 case bfd_arch_aarch64
:
10974 case bfd_arch_alpha
:
10975 case bfd_arch_sparc
:
10976 switch (note
->type
)
10978 case NT_NETBSDCORE_FIRSTMACH
+0:
10979 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10981 case NT_NETBSDCORE_FIRSTMACH
+2:
10982 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10988 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10989 There's also old PT___GETREGS40 == mach + 1 for old reg
10990 structure which lacks GBR. */
10993 switch (note
->type
)
10995 case NT_NETBSDCORE_FIRSTMACH
+3:
10996 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10998 case NT_NETBSDCORE_FIRSTMACH
+5:
10999 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11005 /* On all other arch's, PT_GETREGS == mach+1 and
11006 PT_GETFPREGS == mach+3. */
11009 switch (note
->type
)
11011 case NT_NETBSDCORE_FIRSTMACH
+1:
11012 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11014 case NT_NETBSDCORE_FIRSTMACH
+3:
11015 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11025 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
11027 if (note
->descsz
<= 0x48 + 31)
11030 /* Signal number at offset 0x08. */
11031 elf_tdata (abfd
)->core
->signal
11032 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
11034 /* Process ID at offset 0x20. */
11035 elf_tdata (abfd
)->core
->pid
11036 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
11038 /* Command name at 0x48 (max 32 bytes, including nul). */
11039 elf_tdata (abfd
)->core
->command
11040 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
11046 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11048 if (note
->type
== NT_OPENBSD_PROCINFO
)
11049 return elfcore_grok_openbsd_procinfo (abfd
, note
);
11051 if (note
->type
== NT_OPENBSD_REGS
)
11052 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11054 if (note
->type
== NT_OPENBSD_FPREGS
)
11055 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11057 if (note
->type
== NT_OPENBSD_XFPREGS
)
11058 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
11060 if (note
->type
== NT_OPENBSD_AUXV
)
11061 return elfcore_make_auxv_note_section (abfd
, note
, 0);
11063 if (note
->type
== NT_OPENBSD_WCOOKIE
)
11065 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
11070 sect
->size
= note
->descsz
;
11071 sect
->filepos
= note
->descpos
;
11072 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
11081 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
11083 void *ddata
= note
->descdata
;
11090 if (note
->descsz
< 16)
11093 /* nto_procfs_status 'pid' field is at offset 0. */
11094 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
11096 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
11097 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
11099 /* nto_procfs_status 'flags' field is at offset 8. */
11100 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
11102 /* nto_procfs_status 'what' field is at offset 14. */
11103 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
11105 elf_tdata (abfd
)->core
->signal
= sig
;
11106 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11109 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
11110 do not come from signals so we make sure we set the current
11111 thread just in case. */
11112 if (flags
& 0x00000080)
11113 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11115 /* Make a ".qnx_core_status/%d" section. */
11116 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
11118 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11121 strcpy (name
, buf
);
11123 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11127 sect
->size
= note
->descsz
;
11128 sect
->filepos
= note
->descpos
;
11129 sect
->alignment_power
= 2;
11131 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
11135 elfcore_grok_nto_regs (bfd
*abfd
,
11136 Elf_Internal_Note
*note
,
11144 /* Make a "(base)/%d" section. */
11145 sprintf (buf
, "%s/%ld", base
, tid
);
11147 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11150 strcpy (name
, buf
);
11152 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11156 sect
->size
= note
->descsz
;
11157 sect
->filepos
= note
->descpos
;
11158 sect
->alignment_power
= 2;
11160 /* This is the current thread. */
11161 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
11162 return elfcore_maybe_make_sect (abfd
, base
, sect
);
11167 #define BFD_QNT_CORE_INFO 7
11168 #define BFD_QNT_CORE_STATUS 8
11169 #define BFD_QNT_CORE_GREG 9
11170 #define BFD_QNT_CORE_FPREG 10
11173 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11175 /* Every GREG section has a STATUS section before it. Store the
11176 tid from the previous call to pass down to the next gregs
11178 static long tid
= 1;
11180 switch (note
->type
)
11182 case BFD_QNT_CORE_INFO
:
11183 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
11184 case BFD_QNT_CORE_STATUS
:
11185 return elfcore_grok_nto_status (abfd
, note
, &tid
);
11186 case BFD_QNT_CORE_GREG
:
11187 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
11188 case BFD_QNT_CORE_FPREG
:
11189 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
11196 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11202 /* Use note name as section name. */
11203 len
= note
->namesz
;
11204 name
= (char *) bfd_alloc (abfd
, len
);
11207 memcpy (name
, note
->namedata
, len
);
11208 name
[len
- 1] = '\0';
11210 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11214 sect
->size
= note
->descsz
;
11215 sect
->filepos
= note
->descpos
;
11216 sect
->alignment_power
= 1;
11221 /* Function: elfcore_write_note
11224 buffer to hold note, and current size of buffer
11228 size of data for note
11230 Writes note to end of buffer. ELF64 notes are written exactly as
11231 for ELF32, despite the current (as of 2006) ELF gabi specifying
11232 that they ought to have 8-byte namesz and descsz field, and have
11233 8-byte alignment. Other writers, eg. Linux kernel, do the same.
11236 Pointer to realloc'd buffer, *BUFSIZ updated. */
11239 elfcore_write_note (bfd
*abfd
,
11247 Elf_External_Note
*xnp
;
11254 namesz
= strlen (name
) + 1;
11256 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
11258 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
11261 dest
= buf
+ *bufsiz
;
11262 *bufsiz
+= newspace
;
11263 xnp
= (Elf_External_Note
*) dest
;
11264 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
11265 H_PUT_32 (abfd
, size
, xnp
->descsz
);
11266 H_PUT_32 (abfd
, type
, xnp
->type
);
11270 memcpy (dest
, name
, namesz
);
11278 memcpy (dest
, input
, size
);
11288 /* gcc-8 warns (*) on all the strncpy calls in this function about
11289 possible string truncation. The "truncation" is not a bug. We
11290 have an external representation of structs with fields that are not
11291 necessarily NULL terminated and corresponding internal
11292 representation fields that are one larger so that they can always
11293 be NULL terminated.
11294 gcc versions between 4.2 and 4.6 do not allow pragma control of
11295 diagnostics inside functions, giving a hard error if you try to use
11296 the finer control available with later versions.
11297 gcc prior to 4.2 warns about diagnostic push and pop.
11298 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11299 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11300 (*) Depending on your system header files! */
11301 #if GCC_VERSION >= 8000
11302 # pragma GCC diagnostic push
11303 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11306 elfcore_write_prpsinfo (bfd
*abfd
,
11310 const char *psargs
)
11312 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11314 if (bed
->elf_backend_write_core_note
!= NULL
)
11317 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11318 NT_PRPSINFO
, fname
, psargs
);
11323 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11324 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11325 if (bed
->s
->elfclass
== ELFCLASS32
)
11327 # if defined (HAVE_PSINFO32_T)
11329 int note_type
= NT_PSINFO
;
11332 int note_type
= NT_PRPSINFO
;
11335 memset (&data
, 0, sizeof (data
));
11336 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11337 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11338 return elfcore_write_note (abfd
, buf
, bufsiz
,
11339 "CORE", note_type
, &data
, sizeof (data
));
11344 # if defined (HAVE_PSINFO_T)
11346 int note_type
= NT_PSINFO
;
11349 int note_type
= NT_PRPSINFO
;
11352 memset (&data
, 0, sizeof (data
));
11353 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11354 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11355 return elfcore_write_note (abfd
, buf
, bufsiz
,
11356 "CORE", note_type
, &data
, sizeof (data
));
11358 #endif /* PSINFO_T or PRPSINFO_T */
11363 #if GCC_VERSION >= 8000
11364 # pragma GCC diagnostic pop
11368 elfcore_write_linux_prpsinfo32
11369 (bfd
*abfd
, char *buf
, int *bufsiz
,
11370 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11372 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11374 struct elf_external_linux_prpsinfo32_ugid16 data
;
11376 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11377 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11378 &data
, sizeof (data
));
11382 struct elf_external_linux_prpsinfo32_ugid32 data
;
11384 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11385 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11386 &data
, sizeof (data
));
11391 elfcore_write_linux_prpsinfo64
11392 (bfd
*abfd
, char *buf
, int *bufsiz
,
11393 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11395 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11397 struct elf_external_linux_prpsinfo64_ugid16 data
;
11399 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11400 return elfcore_write_note (abfd
, buf
, bufsiz
,
11401 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11405 struct elf_external_linux_prpsinfo64_ugid32 data
;
11407 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11408 return elfcore_write_note (abfd
, buf
, bufsiz
,
11409 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11414 elfcore_write_prstatus (bfd
*abfd
,
11421 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11423 if (bed
->elf_backend_write_core_note
!= NULL
)
11426 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11428 pid
, cursig
, gregs
);
11433 #if defined (HAVE_PRSTATUS_T)
11434 #if defined (HAVE_PRSTATUS32_T)
11435 if (bed
->s
->elfclass
== ELFCLASS32
)
11437 prstatus32_t prstat
;
11439 memset (&prstat
, 0, sizeof (prstat
));
11440 prstat
.pr_pid
= pid
;
11441 prstat
.pr_cursig
= cursig
;
11442 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11443 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11444 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11451 memset (&prstat
, 0, sizeof (prstat
));
11452 prstat
.pr_pid
= pid
;
11453 prstat
.pr_cursig
= cursig
;
11454 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11455 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11456 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11458 #endif /* HAVE_PRSTATUS_T */
11464 #if defined (HAVE_LWPSTATUS_T)
11466 elfcore_write_lwpstatus (bfd
*abfd
,
11473 lwpstatus_t lwpstat
;
11474 const char *note_name
= "CORE";
11476 memset (&lwpstat
, 0, sizeof (lwpstat
));
11477 lwpstat
.pr_lwpid
= pid
>> 16;
11478 lwpstat
.pr_cursig
= cursig
;
11479 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11480 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11481 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11482 #if !defined(gregs)
11483 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11484 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11486 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11487 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11490 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11491 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11493 #endif /* HAVE_LWPSTATUS_T */
11495 #if defined (HAVE_PSTATUS_T)
11497 elfcore_write_pstatus (bfd
*abfd
,
11501 int cursig ATTRIBUTE_UNUSED
,
11502 const void *gregs ATTRIBUTE_UNUSED
)
11504 const char *note_name
= "CORE";
11505 #if defined (HAVE_PSTATUS32_T)
11506 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11508 if (bed
->s
->elfclass
== ELFCLASS32
)
11512 memset (&pstat
, 0, sizeof (pstat
));
11513 pstat
.pr_pid
= pid
& 0xffff;
11514 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11515 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11523 memset (&pstat
, 0, sizeof (pstat
));
11524 pstat
.pr_pid
= pid
& 0xffff;
11525 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11526 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11530 #endif /* HAVE_PSTATUS_T */
11533 elfcore_write_prfpreg (bfd
*abfd
,
11536 const void *fpregs
,
11539 const char *note_name
= "CORE";
11540 return elfcore_write_note (abfd
, buf
, bufsiz
,
11541 note_name
, NT_FPREGSET
, fpregs
, size
);
11545 elfcore_write_prxfpreg (bfd
*abfd
,
11548 const void *xfpregs
,
11551 char *note_name
= "LINUX";
11552 return elfcore_write_note (abfd
, buf
, bufsiz
,
11553 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11557 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11558 const void *xfpregs
, int size
)
11561 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11562 note_name
= "FreeBSD";
11564 note_name
= "LINUX";
11565 return elfcore_write_note (abfd
, buf
, bufsiz
,
11566 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11570 elfcore_write_ppc_vmx (bfd
*abfd
,
11573 const void *ppc_vmx
,
11576 char *note_name
= "LINUX";
11577 return elfcore_write_note (abfd
, buf
, bufsiz
,
11578 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11582 elfcore_write_ppc_vsx (bfd
*abfd
,
11585 const void *ppc_vsx
,
11588 char *note_name
= "LINUX";
11589 return elfcore_write_note (abfd
, buf
, bufsiz
,
11590 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11594 elfcore_write_ppc_tar (bfd
*abfd
,
11597 const void *ppc_tar
,
11600 char *note_name
= "LINUX";
11601 return elfcore_write_note (abfd
, buf
, bufsiz
,
11602 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11606 elfcore_write_ppc_ppr (bfd
*abfd
,
11609 const void *ppc_ppr
,
11612 char *note_name
= "LINUX";
11613 return elfcore_write_note (abfd
, buf
, bufsiz
,
11614 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11618 elfcore_write_ppc_dscr (bfd
*abfd
,
11621 const void *ppc_dscr
,
11624 char *note_name
= "LINUX";
11625 return elfcore_write_note (abfd
, buf
, bufsiz
,
11626 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11630 elfcore_write_ppc_ebb (bfd
*abfd
,
11633 const void *ppc_ebb
,
11636 char *note_name
= "LINUX";
11637 return elfcore_write_note (abfd
, buf
, bufsiz
,
11638 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11642 elfcore_write_ppc_pmu (bfd
*abfd
,
11645 const void *ppc_pmu
,
11648 char *note_name
= "LINUX";
11649 return elfcore_write_note (abfd
, buf
, bufsiz
,
11650 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11654 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11657 const void *ppc_tm_cgpr
,
11660 char *note_name
= "LINUX";
11661 return elfcore_write_note (abfd
, buf
, bufsiz
,
11662 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11666 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11669 const void *ppc_tm_cfpr
,
11672 char *note_name
= "LINUX";
11673 return elfcore_write_note (abfd
, buf
, bufsiz
,
11674 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11678 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11681 const void *ppc_tm_cvmx
,
11684 char *note_name
= "LINUX";
11685 return elfcore_write_note (abfd
, buf
, bufsiz
,
11686 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11690 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11693 const void *ppc_tm_cvsx
,
11696 char *note_name
= "LINUX";
11697 return elfcore_write_note (abfd
, buf
, bufsiz
,
11698 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11702 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11705 const void *ppc_tm_spr
,
11708 char *note_name
= "LINUX";
11709 return elfcore_write_note (abfd
, buf
, bufsiz
,
11710 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11714 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11717 const void *ppc_tm_ctar
,
11720 char *note_name
= "LINUX";
11721 return elfcore_write_note (abfd
, buf
, bufsiz
,
11722 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11726 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11729 const void *ppc_tm_cppr
,
11732 char *note_name
= "LINUX";
11733 return elfcore_write_note (abfd
, buf
, bufsiz
,
11734 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11738 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11741 const void *ppc_tm_cdscr
,
11744 char *note_name
= "LINUX";
11745 return elfcore_write_note (abfd
, buf
, bufsiz
,
11746 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11750 elfcore_write_s390_high_gprs (bfd
*abfd
,
11753 const void *s390_high_gprs
,
11756 char *note_name
= "LINUX";
11757 return elfcore_write_note (abfd
, buf
, bufsiz
,
11758 note_name
, NT_S390_HIGH_GPRS
,
11759 s390_high_gprs
, size
);
11763 elfcore_write_s390_timer (bfd
*abfd
,
11766 const void *s390_timer
,
11769 char *note_name
= "LINUX";
11770 return elfcore_write_note (abfd
, buf
, bufsiz
,
11771 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11775 elfcore_write_s390_todcmp (bfd
*abfd
,
11778 const void *s390_todcmp
,
11781 char *note_name
= "LINUX";
11782 return elfcore_write_note (abfd
, buf
, bufsiz
,
11783 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11787 elfcore_write_s390_todpreg (bfd
*abfd
,
11790 const void *s390_todpreg
,
11793 char *note_name
= "LINUX";
11794 return elfcore_write_note (abfd
, buf
, bufsiz
,
11795 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11799 elfcore_write_s390_ctrs (bfd
*abfd
,
11802 const void *s390_ctrs
,
11805 char *note_name
= "LINUX";
11806 return elfcore_write_note (abfd
, buf
, bufsiz
,
11807 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11811 elfcore_write_s390_prefix (bfd
*abfd
,
11814 const void *s390_prefix
,
11817 char *note_name
= "LINUX";
11818 return elfcore_write_note (abfd
, buf
, bufsiz
,
11819 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11823 elfcore_write_s390_last_break (bfd
*abfd
,
11826 const void *s390_last_break
,
11829 char *note_name
= "LINUX";
11830 return elfcore_write_note (abfd
, buf
, bufsiz
,
11831 note_name
, NT_S390_LAST_BREAK
,
11832 s390_last_break
, size
);
11836 elfcore_write_s390_system_call (bfd
*abfd
,
11839 const void *s390_system_call
,
11842 char *note_name
= "LINUX";
11843 return elfcore_write_note (abfd
, buf
, bufsiz
,
11844 note_name
, NT_S390_SYSTEM_CALL
,
11845 s390_system_call
, size
);
11849 elfcore_write_s390_tdb (bfd
*abfd
,
11852 const void *s390_tdb
,
11855 char *note_name
= "LINUX";
11856 return elfcore_write_note (abfd
, buf
, bufsiz
,
11857 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11861 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11864 const void *s390_vxrs_low
,
11867 char *note_name
= "LINUX";
11868 return elfcore_write_note (abfd
, buf
, bufsiz
,
11869 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11873 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11876 const void *s390_vxrs_high
,
11879 char *note_name
= "LINUX";
11880 return elfcore_write_note (abfd
, buf
, bufsiz
,
11881 note_name
, NT_S390_VXRS_HIGH
,
11882 s390_vxrs_high
, size
);
11886 elfcore_write_s390_gs_cb (bfd
*abfd
,
11889 const void *s390_gs_cb
,
11892 char *note_name
= "LINUX";
11893 return elfcore_write_note (abfd
, buf
, bufsiz
,
11894 note_name
, NT_S390_GS_CB
,
11899 elfcore_write_s390_gs_bc (bfd
*abfd
,
11902 const void *s390_gs_bc
,
11905 char *note_name
= "LINUX";
11906 return elfcore_write_note (abfd
, buf
, bufsiz
,
11907 note_name
, NT_S390_GS_BC
,
11912 elfcore_write_arm_vfp (bfd
*abfd
,
11915 const void *arm_vfp
,
11918 char *note_name
= "LINUX";
11919 return elfcore_write_note (abfd
, buf
, bufsiz
,
11920 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11924 elfcore_write_aarch_tls (bfd
*abfd
,
11927 const void *aarch_tls
,
11930 char *note_name
= "LINUX";
11931 return elfcore_write_note (abfd
, buf
, bufsiz
,
11932 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11936 elfcore_write_aarch_hw_break (bfd
*abfd
,
11939 const void *aarch_hw_break
,
11942 char *note_name
= "LINUX";
11943 return elfcore_write_note (abfd
, buf
, bufsiz
,
11944 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11948 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11951 const void *aarch_hw_watch
,
11954 char *note_name
= "LINUX";
11955 return elfcore_write_note (abfd
, buf
, bufsiz
,
11956 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11960 elfcore_write_aarch_sve (bfd
*abfd
,
11963 const void *aarch_sve
,
11966 char *note_name
= "LINUX";
11967 return elfcore_write_note (abfd
, buf
, bufsiz
,
11968 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11972 elfcore_write_aarch_pauth (bfd
*abfd
,
11975 const void *aarch_pauth
,
11978 char *note_name
= "LINUX";
11979 return elfcore_write_note (abfd
, buf
, bufsiz
,
11980 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11984 elfcore_write_arc_v2 (bfd
*abfd
,
11987 const void *arc_v2
,
11990 char *note_name
= "LINUX";
11991 return elfcore_write_note (abfd
, buf
, bufsiz
,
11992 note_name
, NT_ARC_V2
, arc_v2
, size
);
11995 /* Write the buffer of csr values in CSRS (length SIZE) into the note
11996 buffer BUF and update *BUFSIZ. ABFD is the bfd the note is being
11997 written into. Return a pointer to the new start of the note buffer, to
11998 replace BUF which may no longer be valid. */
12001 elfcore_write_riscv_csr (bfd
*abfd
,
12007 const char *note_name
= "GDB";
12008 return elfcore_write_note (abfd
, buf
, bufsiz
,
12009 note_name
, NT_RISCV_CSR
, csrs
, size
);
12012 /* Write the target description (a string) pointed to by TDESC, length
12013 SIZE, into the note buffer BUF, and update *BUFSIZ. ABFD is the bfd the
12014 note is being written into. Return a pointer to the new start of the
12015 note buffer, to replace BUF which may no longer be valid. */
12018 elfcore_write_gdb_tdesc (bfd
*abfd
,
12024 const char *note_name
= "GDB";
12025 return elfcore_write_note (abfd
, buf
, bufsiz
,
12026 note_name
, NT_GDB_TDESC
, tdesc
, size
);
12030 elfcore_write_register_note (bfd
*abfd
,
12033 const char *section
,
12037 if (strcmp (section
, ".reg2") == 0)
12038 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
12039 if (strcmp (section
, ".reg-xfp") == 0)
12040 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
12041 if (strcmp (section
, ".reg-xstate") == 0)
12042 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
12043 if (strcmp (section
, ".reg-ppc-vmx") == 0)
12044 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
12045 if (strcmp (section
, ".reg-ppc-vsx") == 0)
12046 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
12047 if (strcmp (section
, ".reg-ppc-tar") == 0)
12048 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
12049 if (strcmp (section
, ".reg-ppc-ppr") == 0)
12050 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
12051 if (strcmp (section
, ".reg-ppc-dscr") == 0)
12052 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
12053 if (strcmp (section
, ".reg-ppc-ebb") == 0)
12054 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
12055 if (strcmp (section
, ".reg-ppc-pmu") == 0)
12056 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
12057 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
12058 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
12059 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
12060 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
12061 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
12062 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
12063 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
12064 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
12065 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
12066 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
12067 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
12068 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
12069 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
12070 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
12071 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
12072 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
12073 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
12074 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
12075 if (strcmp (section
, ".reg-s390-timer") == 0)
12076 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
12077 if (strcmp (section
, ".reg-s390-todcmp") == 0)
12078 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
12079 if (strcmp (section
, ".reg-s390-todpreg") == 0)
12080 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
12081 if (strcmp (section
, ".reg-s390-ctrs") == 0)
12082 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
12083 if (strcmp (section
, ".reg-s390-prefix") == 0)
12084 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
12085 if (strcmp (section
, ".reg-s390-last-break") == 0)
12086 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
12087 if (strcmp (section
, ".reg-s390-system-call") == 0)
12088 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
12089 if (strcmp (section
, ".reg-s390-tdb") == 0)
12090 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
12091 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
12092 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
12093 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
12094 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
12095 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
12096 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
12097 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
12098 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
12099 if (strcmp (section
, ".reg-arm-vfp") == 0)
12100 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
12101 if (strcmp (section
, ".reg-aarch-tls") == 0)
12102 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
12103 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
12104 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
12105 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
12106 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
12107 if (strcmp (section
, ".reg-aarch-sve") == 0)
12108 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
12109 if (strcmp (section
, ".reg-aarch-pauth") == 0)
12110 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
12111 if (strcmp (section
, ".reg-arc-v2") == 0)
12112 return elfcore_write_arc_v2 (abfd
, buf
, bufsiz
, data
, size
);
12113 if (strcmp (section
, ".gdb-tdesc") == 0)
12114 return elfcore_write_gdb_tdesc (abfd
, buf
, bufsiz
, data
, size
);
12115 if (strcmp (section
, ".reg-riscv-csr") == 0)
12116 return elfcore_write_riscv_csr (abfd
, buf
, bufsiz
, data
, size
);
12121 elfcore_write_file_note (bfd
*obfd
, char *note_data
, int *note_size
,
12122 const void *buf
, int bufsiz
)
12124 return elfcore_write_note (obfd
, note_data
, note_size
,
12125 "CORE", NT_FILE
, buf
, bufsiz
);
12129 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
12134 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
12135 gABI specifies that PT_NOTE alignment should be aligned to 4
12136 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
12137 align is less than 4, we use 4 byte alignment. */
12140 if (align
!= 4 && align
!= 8)
12144 while (p
< buf
+ size
)
12146 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
12147 Elf_Internal_Note in
;
12149 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
12152 in
.type
= H_GET_32 (abfd
, xnp
->type
);
12154 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
12155 in
.namedata
= xnp
->name
;
12156 if (in
.namesz
> buf
- in
.namedata
+ size
)
12159 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
12160 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
12161 in
.descpos
= offset
+ (in
.descdata
- buf
);
12163 && (in
.descdata
>= buf
+ size
12164 || in
.descsz
> buf
- in
.descdata
+ size
))
12167 switch (bfd_get_format (abfd
))
12174 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
12177 const char * string
;
12179 bool (*func
) (bfd
*, Elf_Internal_Note
*);
12183 GROKER_ELEMENT ("", elfcore_grok_note
),
12184 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
12185 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
12186 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
12187 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
12188 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
12189 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
12191 #undef GROKER_ELEMENT
12194 for (i
= ARRAY_SIZE (grokers
); i
--;)
12196 if (in
.namesz
>= grokers
[i
].len
12197 && strncmp (in
.namedata
, grokers
[i
].string
,
12198 grokers
[i
].len
) == 0)
12200 if (! grokers
[i
].func (abfd
, & in
))
12209 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
12211 if (! elfobj_grok_gnu_note (abfd
, &in
))
12214 else if (in
.namesz
== sizeof "stapsdt"
12215 && strcmp (in
.namedata
, "stapsdt") == 0)
12217 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
12223 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
12230 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
12235 if (size
== 0 || (size
+ 1) == 0)
12238 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
12241 buf
= (char *) _bfd_malloc_and_read (abfd
, size
+ 1, size
);
12245 /* PR 17512: file: ec08f814
12246 0-termintate the buffer so that string searches will not overflow. */
12249 if (!elf_parse_notes (abfd
, buf
, size
, offset
, align
))
12259 /* Providing external access to the ELF program header table. */
12261 /* Return an upper bound on the number of bytes required to store a
12262 copy of ABFD's program header table entries. Return -1 if an error
12263 occurs; bfd_get_error will return an appropriate code. */
12266 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
12268 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12270 bfd_set_error (bfd_error_wrong_format
);
12274 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
12277 /* Copy ABFD's program header table entries to *PHDRS. The entries
12278 will be stored as an array of Elf_Internal_Phdr structures, as
12279 defined in include/elf/internal.h. To find out how large the
12280 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
12282 Return the number of program header table entries read, or -1 if an
12283 error occurs; bfd_get_error will return an appropriate code. */
12286 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
12290 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12292 bfd_set_error (bfd_error_wrong_format
);
12296 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
12297 if (num_phdrs
!= 0)
12298 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
12299 num_phdrs
* sizeof (Elf_Internal_Phdr
));
12304 enum elf_reloc_type_class
12305 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12306 const asection
*rel_sec ATTRIBUTE_UNUSED
,
12307 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
12309 return reloc_class_normal
;
12312 /* For RELA architectures, return the relocation value for a
12313 relocation against a local symbol. */
12316 _bfd_elf_rela_local_sym (bfd
*abfd
,
12317 Elf_Internal_Sym
*sym
,
12319 Elf_Internal_Rela
*rel
)
12321 asection
*sec
= *psec
;
12322 bfd_vma relocation
;
12324 relocation
= (sec
->output_section
->vma
12325 + sec
->output_offset
12327 if ((sec
->flags
& SEC_MERGE
)
12328 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
12329 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12332 _bfd_merged_section_offset (abfd
, psec
,
12333 elf_section_data (sec
)->sec_info
,
12334 sym
->st_value
+ rel
->r_addend
);
12337 /* If we have changed the section, and our original section is
12338 marked with SEC_EXCLUDE, it means that the original
12339 SEC_MERGE section has been completely subsumed in some
12340 other SEC_MERGE section. In this case, we need to leave
12341 some info around for --emit-relocs. */
12342 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12343 sec
->kept_section
= *psec
;
12346 rel
->r_addend
-= relocation
;
12347 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12353 _bfd_elf_rel_local_sym (bfd
*abfd
,
12354 Elf_Internal_Sym
*sym
,
12358 asection
*sec
= *psec
;
12360 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12361 return sym
->st_value
+ addend
;
12363 return _bfd_merged_section_offset (abfd
, psec
,
12364 elf_section_data (sec
)->sec_info
,
12365 sym
->st_value
+ addend
);
12368 /* Adjust an address within a section. Given OFFSET within SEC, return
12369 the new offset within the section, based upon changes made to the
12370 section. Returns -1 if the offset is now invalid.
12371 The offset (in abnd out) is in target sized bytes, however big a
12375 _bfd_elf_section_offset (bfd
*abfd
,
12376 struct bfd_link_info
*info
,
12380 switch (sec
->sec_info_type
)
12382 case SEC_INFO_TYPE_STABS
:
12383 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12385 case SEC_INFO_TYPE_EH_FRAME
:
12386 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12389 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12391 /* Reverse the offset. */
12392 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12393 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12395 /* address_size and sec->size are in octets. Convert
12396 to bytes before subtracting the original offset. */
12397 offset
= ((sec
->size
- address_size
)
12398 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12404 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12405 reconstruct an ELF file by reading the segments out of remote memory
12406 based on the ELF file header at EHDR_VMA and the ELF program headers it
12407 points to. If not null, *LOADBASEP is filled in with the difference
12408 between the VMAs from which the segments were read, and the VMAs the
12409 file headers (and hence BFD's idea of each section's VMA) put them at.
12411 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12412 remote memory at target address VMA into the local buffer at MYADDR; it
12413 should return zero on success or an `errno' code on failure. TEMPL must
12414 be a BFD for an ELF target with the word size and byte order found in
12415 the remote memory. */
12418 bfd_elf_bfd_from_remote_memory
12421 bfd_size_type size
,
12422 bfd_vma
*loadbasep
,
12423 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12425 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12426 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12430 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12431 long symcount ATTRIBUTE_UNUSED
,
12432 asymbol
**syms ATTRIBUTE_UNUSED
,
12437 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12440 const char *relplt_name
;
12441 bool (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bool);
12445 Elf_Internal_Shdr
*hdr
;
12451 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12454 if (dynsymcount
<= 0)
12457 if (!bed
->plt_sym_val
)
12460 relplt_name
= bed
->relplt_name
;
12461 if (relplt_name
== NULL
)
12462 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12463 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12464 if (relplt
== NULL
)
12467 hdr
= &elf_section_data (relplt
)->this_hdr
;
12468 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12469 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12472 plt
= bfd_get_section_by_name (abfd
, ".plt");
12476 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12477 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, true))
12480 count
= relplt
->size
/ hdr
->sh_entsize
;
12481 size
= count
* sizeof (asymbol
);
12482 p
= relplt
->relocation
;
12483 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12485 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12486 if (p
->addend
!= 0)
12489 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12491 size
+= sizeof ("+0x") - 1 + 8;
12496 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12500 names
= (char *) (s
+ count
);
12501 p
= relplt
->relocation
;
12503 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12508 addr
= bed
->plt_sym_val (i
, plt
, p
);
12509 if (addr
== (bfd_vma
) -1)
12512 *s
= **p
->sym_ptr_ptr
;
12513 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12514 we are defining a symbol, ensure one of them is set. */
12515 if ((s
->flags
& BSF_LOCAL
) == 0)
12516 s
->flags
|= BSF_GLOBAL
;
12517 s
->flags
|= BSF_SYNTHETIC
;
12519 s
->value
= addr
- plt
->vma
;
12522 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12523 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12525 if (p
->addend
!= 0)
12529 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12530 names
+= sizeof ("+0x") - 1;
12531 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12532 for (a
= buf
; *a
== '0'; ++a
)
12535 memcpy (names
, a
, len
);
12538 memcpy (names
, "@plt", sizeof ("@plt"));
12539 names
+= sizeof ("@plt");
12546 /* It is only used by x86-64 so far.
12547 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12548 but current usage would allow all of _bfd_std_section to be zero. */
12549 static const asymbol lcomm_sym
12550 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12551 asection _bfd_elf_large_com_section
12552 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12553 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12556 _bfd_elf_final_write_processing (bfd
*abfd
)
12558 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12560 i_ehdrp
= elf_elfheader (abfd
);
12562 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12563 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12565 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12566 SHF_GNU_MBIND or SHF_GNU_RETAIN sections or symbols of STT_GNU_IFUNC type
12567 or STB_GNU_UNIQUE binding. */
12568 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12570 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12571 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12572 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12573 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12575 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12576 _bfd_error_handler (_("GNU_MBIND section is supported only by GNU "
12577 "and FreeBSD targets"));
12578 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12579 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is supported "
12580 "only by GNU and FreeBSD targets"));
12581 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12582 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is supported "
12583 "only by GNU and FreeBSD targets"));
12584 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_retain
)
12585 _bfd_error_handler (_("GNU_RETAIN section is supported "
12586 "only by GNU and FreeBSD targets"));
12587 bfd_set_error (bfd_error_sorry
);
12595 /* Return TRUE for ELF symbol types that represent functions.
12596 This is the default version of this function, which is sufficient for
12597 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12600 _bfd_elf_is_function_type (unsigned int type
)
12602 return (type
== STT_FUNC
12603 || type
== STT_GNU_IFUNC
);
12606 /* If the ELF symbol SYM might be a function in SEC, return the
12607 function size and set *CODE_OFF to the function's entry point,
12608 otherwise return zero. */
12611 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12614 bfd_size_type size
;
12616 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12617 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12618 || sym
->section
!= sec
)
12621 *code_off
= sym
->value
;
12623 if (!(sym
->flags
& BSF_SYNTHETIC
))
12624 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
12630 /* Set to non-zero to enable some debug messages. */
12631 #define DEBUG_SECONDARY_RELOCS 0
12633 /* An internal-to-the-bfd-library only section type
12634 used to indicate a cached secondary reloc section. */
12635 #define SHT_SECONDARY_RELOC (SHT_LOOS + SHT_RELA)
12637 /* Create a BFD section to hold a secondary reloc section. */
12640 _bfd_elf_init_secondary_reloc_section (bfd
* abfd
,
12641 Elf_Internal_Shdr
*hdr
,
12643 unsigned int shindex
)
12645 /* We only support RELA secondary relocs. */
12646 if (hdr
->sh_type
!= SHT_RELA
)
12649 #if DEBUG_SECONDARY_RELOCS
12650 fprintf (stderr
, "secondary reloc section %s encountered\n", name
);
12652 hdr
->sh_type
= SHT_SECONDARY_RELOC
;
12653 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
12656 /* Read in any secondary relocs associated with SEC. */
12659 _bfd_elf_slurp_secondary_reloc_section (bfd
* abfd
,
12661 asymbol
** symbols
,
12664 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12666 bool result
= true;
12667 bfd_vma (*r_sym
) (bfd_vma
);
12669 #if BFD_DEFAULT_TARGET_SIZE > 32
12670 if (bfd_arch_bits_per_address (abfd
) != 32)
12671 r_sym
= elf64_r_sym
;
12674 r_sym
= elf32_r_sym
;
12676 /* Discover if there are any secondary reloc sections
12677 associated with SEC. */
12678 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12680 Elf_Internal_Shdr
* hdr
= & elf_section_data (relsec
)->this_hdr
;
12682 if (hdr
->sh_type
== SHT_SECONDARY_RELOC
12683 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
12684 && (hdr
->sh_entsize
== ebd
->s
->sizeof_rel
12685 || hdr
->sh_entsize
== ebd
->s
->sizeof_rela
))
12687 bfd_byte
* native_relocs
;
12688 bfd_byte
* native_reloc
;
12689 arelent
* internal_relocs
;
12690 arelent
* internal_reloc
;
12692 unsigned int entsize
;
12693 unsigned int symcount
;
12694 unsigned int reloc_count
;
12697 if (ebd
->elf_info_to_howto
== NULL
)
12700 #if DEBUG_SECONDARY_RELOCS
12701 fprintf (stderr
, "read secondary relocs for %s from %s\n",
12702 sec
->name
, relsec
->name
);
12704 entsize
= hdr
->sh_entsize
;
12706 native_relocs
= bfd_malloc (hdr
->sh_size
);
12707 if (native_relocs
== NULL
)
12713 reloc_count
= NUM_SHDR_ENTRIES (hdr
);
12714 if (_bfd_mul_overflow (reloc_count
, sizeof (arelent
), & amt
))
12716 free (native_relocs
);
12717 bfd_set_error (bfd_error_file_too_big
);
12722 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
12723 if (internal_relocs
== NULL
)
12725 free (native_relocs
);
12730 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
12731 || (bfd_bread (native_relocs
, hdr
->sh_size
, abfd
)
12734 free (native_relocs
);
12735 /* The internal_relocs will be freed when
12736 the memory for the bfd is released. */
12742 symcount
= bfd_get_dynamic_symcount (abfd
);
12744 symcount
= bfd_get_symcount (abfd
);
12746 for (i
= 0, internal_reloc
= internal_relocs
,
12747 native_reloc
= native_relocs
;
12749 i
++, internal_reloc
++, native_reloc
+= entsize
)
12752 Elf_Internal_Rela rela
;
12754 if (entsize
== ebd
->s
->sizeof_rel
)
12755 ebd
->s
->swap_reloc_in (abfd
, native_reloc
, & rela
);
12756 else /* entsize == ebd->s->sizeof_rela */
12757 ebd
->s
->swap_reloca_in (abfd
, native_reloc
, & rela
);
12759 /* The address of an ELF reloc is section relative for an object
12760 file, and absolute for an executable file or shared library.
12761 The address of a normal BFD reloc is always section relative,
12762 and the address of a dynamic reloc is absolute.. */
12763 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
12764 internal_reloc
->address
= rela
.r_offset
;
12766 internal_reloc
->address
= rela
.r_offset
- sec
->vma
;
12768 if (r_sym (rela
.r_info
) == STN_UNDEF
)
12770 /* FIXME: This and the error case below mean that we
12771 have a symbol on relocs that is not elf_symbol_type. */
12772 internal_reloc
->sym_ptr_ptr
=
12773 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12775 else if (r_sym (rela
.r_info
) > symcount
)
12778 /* xgettext:c-format */
12779 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
12780 abfd
, sec
, i
, (long) r_sym (rela
.r_info
));
12781 bfd_set_error (bfd_error_bad_value
);
12782 internal_reloc
->sym_ptr_ptr
=
12783 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12790 ps
= symbols
+ r_sym (rela
.r_info
) - 1;
12791 internal_reloc
->sym_ptr_ptr
= ps
;
12792 /* Make sure that this symbol is not removed by strip. */
12793 (*ps
)->flags
|= BSF_KEEP
;
12796 internal_reloc
->addend
= rela
.r_addend
;
12798 res
= ebd
->elf_info_to_howto (abfd
, internal_reloc
, & rela
);
12799 if (! res
|| internal_reloc
->howto
== NULL
)
12801 #if DEBUG_SECONDARY_RELOCS
12802 fprintf (stderr
, "there is no howto associated with reloc %lx\n",
12809 free (native_relocs
);
12810 /* Store the internal relocs. */
12811 elf_section_data (relsec
)->sec_info
= internal_relocs
;
12818 /* Set the ELF section header fields of an output secondary reloc section. */
12821 _bfd_elf_copy_special_section_fields (const bfd
* ibfd ATTRIBUTE_UNUSED
,
12822 bfd
* obfd ATTRIBUTE_UNUSED
,
12823 const Elf_Internal_Shdr
* isection
,
12824 Elf_Internal_Shdr
* osection
)
12828 struct bfd_elf_section_data
* esd
;
12830 if (isection
== NULL
)
12833 if (isection
->sh_type
!= SHT_SECONDARY_RELOC
)
12836 isec
= isection
->bfd_section
;
12840 osec
= osection
->bfd_section
;
12844 esd
= elf_section_data (osec
);
12845 BFD_ASSERT (esd
->sec_info
== NULL
);
12846 esd
->sec_info
= elf_section_data (isec
)->sec_info
;
12847 osection
->sh_type
= SHT_RELA
;
12848 osection
->sh_link
= elf_onesymtab (obfd
);
12849 if (osection
->sh_link
== 0)
12851 /* There is no symbol table - we are hosed... */
12853 /* xgettext:c-format */
12854 (_("%pB(%pA): link section cannot be set because the output file does not have a symbol table"),
12856 bfd_set_error (bfd_error_bad_value
);
12860 /* Find the output section that corresponds to the isection's sh_info link. */
12861 if (isection
->sh_info
== 0
12862 || isection
->sh_info
>= elf_numsections (ibfd
))
12865 /* xgettext:c-format */
12866 (_("%pB(%pA): info section index is invalid"),
12868 bfd_set_error (bfd_error_bad_value
);
12872 isection
= elf_elfsections (ibfd
)[isection
->sh_info
];
12874 if (isection
== NULL
12875 || isection
->bfd_section
== NULL
12876 || isection
->bfd_section
->output_section
== NULL
)
12879 /* xgettext:c-format */
12880 (_("%pB(%pA): info section index cannot be set because the section is not in the output"),
12882 bfd_set_error (bfd_error_bad_value
);
12886 esd
= elf_section_data (isection
->bfd_section
->output_section
);
12887 BFD_ASSERT (esd
!= NULL
);
12888 osection
->sh_info
= esd
->this_idx
;
12889 esd
->has_secondary_relocs
= true;
12890 #if DEBUG_SECONDARY_RELOCS
12891 fprintf (stderr
, "update header of %s, sh_link = %u, sh_info = %u\n",
12892 osec
->name
, osection
->sh_link
, osection
->sh_info
);
12893 fprintf (stderr
, "mark section %s as having secondary relocs\n",
12894 bfd_section_name (isection
->bfd_section
->output_section
));
12900 /* Write out a secondary reloc section.
12902 FIXME: Currently this function can result in a serious performance penalty
12903 for files with secondary relocs and lots of sections. The proper way to
12904 fix this is for _bfd_elf_copy_special_section_fields() to chain secondary
12905 relocs together and then to have this function just walk that chain. */
12908 _bfd_elf_write_secondary_reloc_section (bfd
*abfd
, asection
*sec
)
12910 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12911 bfd_vma addr_offset
;
12913 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
12914 bool result
= true;
12919 #if BFD_DEFAULT_TARGET_SIZE > 32
12920 if (bfd_arch_bits_per_address (abfd
) != 32)
12921 r_info
= elf64_r_info
;
12924 r_info
= elf32_r_info
;
12926 /* The address of an ELF reloc is section relative for an object
12927 file, and absolute for an executable file or shared library.
12928 The address of a BFD reloc is always section relative. */
12930 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
12931 addr_offset
= sec
->vma
;
12933 /* Discover if there are any secondary reloc sections
12934 associated with SEC. */
12935 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12937 const struct bfd_elf_section_data
* const esd
= elf_section_data (relsec
);
12938 Elf_Internal_Shdr
* const hdr
= (Elf_Internal_Shdr
*) & esd
->this_hdr
;
12940 if (hdr
->sh_type
== SHT_RELA
12941 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
)
12943 asymbol
* last_sym
;
12945 unsigned int reloc_count
;
12947 unsigned int entsize
;
12948 arelent
* src_irel
;
12949 bfd_byte
* dst_rela
;
12951 if (hdr
->contents
!= NULL
)
12954 /* xgettext:c-format */
12955 (_("%pB(%pA): error: secondary reloc section processed twice"),
12957 bfd_set_error (bfd_error_bad_value
);
12962 entsize
= hdr
->sh_entsize
;
12966 /* xgettext:c-format */
12967 (_("%pB(%pA): error: secondary reloc section has zero sized entries"),
12969 bfd_set_error (bfd_error_bad_value
);
12973 else if (entsize
!= ebd
->s
->sizeof_rel
12974 && entsize
!= ebd
->s
->sizeof_rela
)
12977 /* xgettext:c-format */
12978 (_("%pB(%pA): error: secondary reloc section has non-standard sized entries"),
12980 bfd_set_error (bfd_error_bad_value
);
12985 reloc_count
= hdr
->sh_size
/ entsize
;
12986 if (reloc_count
<= 0)
12989 /* xgettext:c-format */
12990 (_("%pB(%pA): error: secondary reloc section is empty!"),
12992 bfd_set_error (bfd_error_bad_value
);
12997 hdr
->contents
= bfd_alloc (abfd
, hdr
->sh_size
);
12998 if (hdr
->contents
== NULL
)
13001 #if DEBUG_SECONDARY_RELOCS
13002 fprintf (stderr
, "write %u secondary relocs for %s from %s\n",
13003 reloc_count
, sec
->name
, relsec
->name
);
13007 dst_rela
= hdr
->contents
;
13008 src_irel
= (arelent
*) esd
->sec_info
;
13009 if (src_irel
== NULL
)
13012 /* xgettext:c-format */
13013 (_("%pB(%pA): error: internal relocs missing for secondary reloc section"),
13015 bfd_set_error (bfd_error_bad_value
);
13020 for (idx
= 0; idx
< reloc_count
; idx
++, dst_rela
+= entsize
)
13022 Elf_Internal_Rela src_rela
;
13027 ptr
= src_irel
+ idx
;
13031 /* xgettext:c-format */
13032 (_("%pB(%pA): error: reloc table entry %u is empty"),
13033 abfd
, relsec
, idx
);
13034 bfd_set_error (bfd_error_bad_value
);
13039 if (ptr
->sym_ptr_ptr
== NULL
)
13041 /* FIXME: Is this an error ? */
13046 sym
= *ptr
->sym_ptr_ptr
;
13048 if (sym
== last_sym
)
13052 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, & sym
);
13056 /* xgettext:c-format */
13057 (_("%pB(%pA): error: secondary reloc %u references a missing symbol"),
13058 abfd
, relsec
, idx
);
13059 bfd_set_error (bfd_error_bad_value
);
13068 if (sym
->the_bfd
!= NULL
13069 && sym
->the_bfd
->xvec
!= abfd
->xvec
13070 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
13073 /* xgettext:c-format */
13074 (_("%pB(%pA): error: secondary reloc %u references a deleted symbol"),
13075 abfd
, relsec
, idx
);
13076 bfd_set_error (bfd_error_bad_value
);
13082 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
13083 if (ptr
->howto
== NULL
)
13086 /* xgettext:c-format */
13087 (_("%pB(%pA): error: secondary reloc %u is of an unknown type"),
13088 abfd
, relsec
, idx
);
13089 bfd_set_error (bfd_error_bad_value
);
13091 src_rela
.r_info
= r_info (0, 0);
13094 src_rela
.r_info
= r_info (n
, ptr
->howto
->type
);
13095 src_rela
.r_addend
= ptr
->addend
;
13097 if (entsize
== ebd
->s
->sizeof_rel
)
13098 ebd
->s
->swap_reloc_out (abfd
, &src_rela
, dst_rela
);
13099 else /* entsize == ebd->s->sizeof_rela */
13100 ebd
->s
->swap_reloca_out (abfd
, &src_rela
, dst_rela
);