1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2020 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 BFD support for ELF formats is being worked on.
28 Currently, the best supported back ends are for sparc and i386
29 (running svr4 or Solaris 2).
31 Documentation of the internals of the support code still needs
32 to be written. The code is changing quickly enough that we
33 haven't bothered yet. */
35 /* For sparc64-cross-sparc32. */
44 #include "libiberty.h"
45 #include "safe-ctype.h"
46 #include "elf-linux-core.h"
52 static int elf_sort_sections (const void *, const void *);
53 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
54 static bfd_boolean
swap_out_syms (bfd
*, struct elf_strtab_hash
**, int,
55 struct bfd_link_info
*);
56 static bfd_boolean
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
;
842 bfd_boolean result
= TRUE
;
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 (strncmp (name
, ".debug", 6) == 0
1088 || strncmp (name
, ".gnu.linkonce.wi.", 17) == 0
1089 || strncmp (name
, ".zdebug", 7) == 0)
1090 flags
|= SEC_DEBUGGING
| SEC_ELF_OCTETS
;
1091 else if (strncmp (name
, GNU_BUILD_ATTRS_SECTION_NAME
, 21) == 0
1092 || strncmp (name
, ".note.gnu", 9) == 0)
1094 flags
|= SEC_ELF_OCTETS
;
1097 else if (strncmp (name
, ".line", 5) == 0
1098 || strncmp (name
, ".stab", 5) == 0
1099 || strcmp (name
, ".gdb_index") == 0)
1100 flags
|= SEC_DEBUGGING
;
1104 if (!bfd_set_section_vma (newsect
, hdr
->sh_addr
/ opb
)
1105 || !bfd_set_section_size (newsect
, hdr
->sh_size
)
1106 || !bfd_set_section_alignment (newsect
, bfd_log2 (hdr
->sh_addralign
)))
1109 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1110 only link a single copy of the section. This is used to support
1111 g++. g++ will emit each template expansion in its own section.
1112 The symbols will be defined as weak, so that multiple definitions
1113 are permitted. The GNU linker extension is to actually discard
1114 all but one of the sections. */
1115 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1116 && elf_next_in_group (newsect
) == NULL
)
1117 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1119 if (!bfd_set_section_flags (newsect
, flags
))
1122 bed
= get_elf_backend_data (abfd
);
1123 if (bed
->elf_backend_section_flags
)
1124 if (!bed
->elf_backend_section_flags (hdr
))
1127 /* We do not parse the PT_NOTE segments as we are interested even in the
1128 separate debug info files which may have the segments offsets corrupted.
1129 PT_NOTEs from the core files are currently not parsed using BFD. */
1130 if (hdr
->sh_type
== SHT_NOTE
)
1134 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1137 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1138 hdr
->sh_offset
, hdr
->sh_addralign
);
1142 if ((newsect
->flags
& SEC_ALLOC
) != 0)
1144 Elf_Internal_Phdr
*phdr
;
1145 unsigned int i
, nload
;
1147 /* Some ELF linkers produce binaries with all the program header
1148 p_paddr fields zero. If we have such a binary with more than
1149 one PT_LOAD header, then leave the section lma equal to vma
1150 so that we don't create sections with overlapping lma. */
1151 phdr
= elf_tdata (abfd
)->phdr
;
1152 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1153 if (phdr
->p_paddr
!= 0)
1155 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1157 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1160 phdr
= elf_tdata (abfd
)->phdr
;
1161 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1163 if (((phdr
->p_type
== PT_LOAD
1164 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1165 || phdr
->p_type
== PT_TLS
)
1166 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1168 if ((newsect
->flags
& SEC_LOAD
) == 0)
1169 newsect
->lma
= (phdr
->p_paddr
1170 + hdr
->sh_addr
- phdr
->p_vaddr
) / opb
;
1172 /* We used to use the same adjustment for SEC_LOAD
1173 sections, but that doesn't work if the segment
1174 is packed with code from multiple VMAs.
1175 Instead we calculate the section LMA based on
1176 the segment LMA. It is assumed that the
1177 segment will contain sections with contiguous
1178 LMAs, even if the VMAs are not. */
1179 newsect
->lma
= (phdr
->p_paddr
1180 + hdr
->sh_offset
- phdr
->p_offset
) / opb
;
1182 /* With contiguous segments, we can't tell from file
1183 offsets whether a section with zero size should
1184 be placed at the end of one segment or the
1185 beginning of the next. Decide based on vaddr. */
1186 if (hdr
->sh_addr
>= phdr
->p_vaddr
1187 && (hdr
->sh_addr
+ hdr
->sh_size
1188 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1194 /* Compress/decompress DWARF debug sections with names: .debug_* and
1195 .zdebug_*, after the section flags is set. */
1196 if ((newsect
->flags
& SEC_DEBUGGING
)
1197 && ((name
[1] == 'd' && name
[6] == '_')
1198 || (name
[1] == 'z' && name
[7] == '_')))
1200 enum { nothing
, compress
, decompress
} action
= nothing
;
1201 int compression_header_size
;
1202 bfd_size_type uncompressed_size
;
1203 unsigned int uncompressed_align_power
;
1204 bfd_boolean compressed
1205 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1206 &compression_header_size
,
1208 &uncompressed_align_power
);
1211 /* Compressed section. Check if we should decompress. */
1212 if ((abfd
->flags
& BFD_DECOMPRESS
))
1213 action
= decompress
;
1216 /* Compress the uncompressed section or convert from/to .zdebug*
1217 section. Check if we should compress. */
1218 if (action
== nothing
)
1220 if (newsect
->size
!= 0
1221 && (abfd
->flags
& BFD_COMPRESS
)
1222 && compression_header_size
>= 0
1223 && uncompressed_size
> 0
1225 || ((compression_header_size
> 0)
1226 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1232 if (action
== compress
)
1234 if (!bfd_init_section_compress_status (abfd
, newsect
))
1237 /* xgettext:c-format */
1238 (_("%pB: unable to initialize compress status for section %s"),
1245 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1248 /* xgettext:c-format */
1249 (_("%pB: unable to initialize decompress status for section %s"),
1255 if (abfd
->is_linker_input
)
1258 && (action
== decompress
1259 || (action
== compress
1260 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1262 /* Convert section name from .zdebug_* to .debug_* so
1263 that linker will consider this section as a debug
1265 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1266 if (new_name
== NULL
)
1268 bfd_rename_section (newsect
, new_name
);
1272 /* For objdump, don't rename the section. For objcopy, delay
1273 section rename to elf_fake_sections. */
1274 newsect
->flags
|= SEC_ELF_RENAME
;
1277 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
1279 const char *lto_section_name
= ".gnu.lto_.lto.";
1280 if (strncmp (name
, lto_section_name
, strlen (lto_section_name
)) == 0)
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. It just short circuits the reloc if producing
1306 relocatable output against an external symbol. */
1308 bfd_reloc_status_type
1309 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1310 arelent
*reloc_entry
,
1312 void *data ATTRIBUTE_UNUSED
,
1313 asection
*input_section
,
1315 char **error_message ATTRIBUTE_UNUSED
)
1317 if (output_bfd
!= NULL
1318 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1319 && (! reloc_entry
->howto
->partial_inplace
1320 || reloc_entry
->addend
== 0))
1322 reloc_entry
->address
+= input_section
->output_offset
;
1323 return bfd_reloc_ok
;
1326 return bfd_reloc_continue
;
1329 /* Returns TRUE if section A matches section B.
1330 Names, addresses and links may be different, but everything else
1331 should be the same. */
1334 section_match (const Elf_Internal_Shdr
* a
,
1335 const Elf_Internal_Shdr
* b
)
1337 if (a
->sh_type
!= b
->sh_type
1338 || ((a
->sh_flags
^ b
->sh_flags
) & ~SHF_INFO_LINK
) != 0
1339 || a
->sh_addralign
!= b
->sh_addralign
1340 || a
->sh_entsize
!= b
->sh_entsize
)
1342 if (a
->sh_type
== SHT_SYMTAB
1343 || a
->sh_type
== SHT_STRTAB
)
1345 return a
->sh_size
== b
->sh_size
;
1348 /* Find a section in OBFD that has the same characteristics
1349 as IHEADER. Return the index of this section or SHN_UNDEF if
1350 none can be found. Check's section HINT first, as this is likely
1351 to be the correct section. */
1354 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1355 const unsigned int hint
)
1357 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1360 BFD_ASSERT (iheader
!= NULL
);
1362 /* See PR 20922 for a reproducer of the NULL test. */
1363 if (hint
< elf_numsections (obfd
)
1364 && oheaders
[hint
] != NULL
1365 && section_match (oheaders
[hint
], iheader
))
1368 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1370 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1372 if (oheader
== NULL
)
1374 if (section_match (oheader
, iheader
))
1375 /* FIXME: Do we care if there is a potential for
1376 multiple matches ? */
1383 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1384 Processor specific section, based upon a matching input section.
1385 Returns TRUE upon success, FALSE otherwise. */
1388 copy_special_section_fields (const bfd
*ibfd
,
1390 const Elf_Internal_Shdr
*iheader
,
1391 Elf_Internal_Shdr
*oheader
,
1392 const unsigned int secnum
)
1394 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1395 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1396 bfd_boolean changed
= FALSE
;
1397 unsigned int sh_link
;
1399 if (oheader
->sh_type
== SHT_NOBITS
)
1401 /* This is a feature for objcopy --only-keep-debug:
1402 When a section's type is changed to NOBITS, we preserve
1403 the sh_link and sh_info fields so that they can be
1404 matched up with the original.
1406 Note: Strictly speaking these assignments are wrong.
1407 The sh_link and sh_info fields should point to the
1408 relevent sections in the output BFD, which may not be in
1409 the same location as they were in the input BFD. But
1410 the whole point of this action is to preserve the
1411 original values of the sh_link and sh_info fields, so
1412 that they can be matched up with the section headers in
1413 the original file. So strictly speaking we may be
1414 creating an invalid ELF file, but it is only for a file
1415 that just contains debug info and only for sections
1416 without any contents. */
1417 if (oheader
->sh_link
== 0)
1418 oheader
->sh_link
= iheader
->sh_link
;
1419 if (oheader
->sh_info
== 0)
1420 oheader
->sh_info
= iheader
->sh_info
;
1424 /* Allow the target a chance to decide how these fields should be set. */
1425 if (bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
,
1429 /* We have an iheader which might match oheader, and which has non-zero
1430 sh_info and/or sh_link fields. Attempt to follow those links and find
1431 the section in the output bfd which corresponds to the linked section
1432 in the input bfd. */
1433 if (iheader
->sh_link
!= SHN_UNDEF
)
1435 /* See PR 20931 for a reproducer. */
1436 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1439 /* xgettext:c-format */
1440 (_("%pB: invalid sh_link field (%d) in section number %d"),
1441 ibfd
, iheader
->sh_link
, secnum
);
1445 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1446 if (sh_link
!= SHN_UNDEF
)
1448 oheader
->sh_link
= sh_link
;
1452 /* FIXME: Should we install iheader->sh_link
1453 if we could not find a match ? */
1455 /* xgettext:c-format */
1456 (_("%pB: failed to find link section for section %d"), obfd
, secnum
);
1459 if (iheader
->sh_info
)
1461 /* The sh_info field can hold arbitrary information, but if the
1462 SHF_LINK_INFO flag is set then it should be interpreted as a
1464 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1466 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1468 if (sh_link
!= SHN_UNDEF
)
1469 oheader
->sh_flags
|= SHF_INFO_LINK
;
1472 /* No idea what it means - just copy it. */
1473 sh_link
= iheader
->sh_info
;
1475 if (sh_link
!= SHN_UNDEF
)
1477 oheader
->sh_info
= sh_link
;
1482 /* xgettext:c-format */
1483 (_("%pB: failed to find info section for section %d"), obfd
, secnum
);
1489 /* Copy the program header and other data from one object module to
1493 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1495 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1496 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1497 const struct elf_backend_data
*bed
;
1500 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1501 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1504 if (!elf_flags_init (obfd
))
1506 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1507 elf_flags_init (obfd
) = TRUE
;
1510 elf_gp (obfd
) = elf_gp (ibfd
);
1512 /* Also copy the EI_OSABI field. */
1513 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1514 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1516 /* If set, copy the EI_ABIVERSION field. */
1517 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1518 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1519 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1521 /* Copy object attributes. */
1522 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1524 if (iheaders
== NULL
|| oheaders
== NULL
)
1527 bed
= get_elf_backend_data (obfd
);
1529 /* Possibly copy other fields in the section header. */
1530 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1533 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1535 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1536 because of a special case need for generating separate debug info
1537 files. See below for more details. */
1539 || (oheader
->sh_type
!= SHT_NOBITS
1540 && oheader
->sh_type
< SHT_LOOS
))
1543 /* Ignore empty sections, and sections whose
1544 fields have already been initialised. */
1545 if (oheader
->sh_size
== 0
1546 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1549 /* Scan for the matching section in the input bfd.
1550 First we try for a direct mapping between the input and output sections. */
1551 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1553 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1555 if (iheader
== NULL
)
1558 if (oheader
->bfd_section
!= NULL
1559 && iheader
->bfd_section
!= NULL
1560 && iheader
->bfd_section
->output_section
!= NULL
1561 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1563 /* We have found a connection from the input section to the
1564 output section. Attempt to copy the header fields. If
1565 this fails then do not try any further sections - there
1566 should only be a one-to-one mapping between input and output. */
1567 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1568 j
= elf_numsections (ibfd
);
1573 if (j
< elf_numsections (ibfd
))
1576 /* That failed. So try to deduce the corresponding input section.
1577 Unfortunately we cannot compare names as the output string table
1578 is empty, so instead we check size, address and type. */
1579 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1581 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1583 if (iheader
== NULL
)
1586 /* Try matching fields in the input section's header.
1587 Since --only-keep-debug turns all non-debug sections into
1588 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1590 if ((oheader
->sh_type
== SHT_NOBITS
1591 || iheader
->sh_type
== oheader
->sh_type
)
1592 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1593 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1594 && iheader
->sh_addralign
== oheader
->sh_addralign
1595 && iheader
->sh_entsize
== oheader
->sh_entsize
1596 && iheader
->sh_size
== oheader
->sh_size
1597 && iheader
->sh_addr
== oheader
->sh_addr
1598 && (iheader
->sh_info
!= oheader
->sh_info
1599 || iheader
->sh_link
!= oheader
->sh_link
))
1601 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1606 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1608 /* Final attempt. Call the backend copy function
1609 with a NULL input section. */
1610 (void) bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
,
1619 get_segment_type (unsigned int p_type
)
1624 case PT_NULL
: pt
= "NULL"; break;
1625 case PT_LOAD
: pt
= "LOAD"; break;
1626 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1627 case PT_INTERP
: pt
= "INTERP"; break;
1628 case PT_NOTE
: pt
= "NOTE"; break;
1629 case PT_SHLIB
: pt
= "SHLIB"; break;
1630 case PT_PHDR
: pt
= "PHDR"; break;
1631 case PT_TLS
: pt
= "TLS"; break;
1632 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1633 case PT_GNU_STACK
: pt
= "STACK"; break;
1634 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1635 default: pt
= NULL
; break;
1640 /* Print out the program headers. */
1643 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1645 FILE *f
= (FILE *) farg
;
1646 Elf_Internal_Phdr
*p
;
1648 bfd_byte
*dynbuf
= NULL
;
1650 p
= elf_tdata (abfd
)->phdr
;
1655 fprintf (f
, _("\nProgram Header:\n"));
1656 c
= elf_elfheader (abfd
)->e_phnum
;
1657 for (i
= 0; i
< c
; i
++, p
++)
1659 const char *pt
= get_segment_type (p
->p_type
);
1664 sprintf (buf
, "0x%lx", p
->p_type
);
1667 fprintf (f
, "%8s off 0x", pt
);
1668 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1669 fprintf (f
, " vaddr 0x");
1670 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1671 fprintf (f
, " paddr 0x");
1672 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1673 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1674 fprintf (f
, " filesz 0x");
1675 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1676 fprintf (f
, " memsz 0x");
1677 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1678 fprintf (f
, " flags %c%c%c",
1679 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1680 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1681 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1682 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1683 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1688 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1691 unsigned int elfsec
;
1692 unsigned long shlink
;
1693 bfd_byte
*extdyn
, *extdynend
;
1695 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1697 fprintf (f
, _("\nDynamic Section:\n"));
1699 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1702 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1703 if (elfsec
== SHN_BAD
)
1705 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1707 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1708 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1711 /* PR 17512: file: 6f427532. */
1712 if (s
->size
< extdynsize
)
1714 extdynend
= extdyn
+ s
->size
;
1715 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1717 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1719 Elf_Internal_Dyn dyn
;
1720 const char *name
= "";
1722 bfd_boolean stringp
;
1723 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1725 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1727 if (dyn
.d_tag
== DT_NULL
)
1734 if (bed
->elf_backend_get_target_dtag
)
1735 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1737 if (!strcmp (name
, ""))
1739 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1744 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1745 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1746 case DT_PLTGOT
: name
= "PLTGOT"; break;
1747 case DT_HASH
: name
= "HASH"; break;
1748 case DT_STRTAB
: name
= "STRTAB"; break;
1749 case DT_SYMTAB
: name
= "SYMTAB"; break;
1750 case DT_RELA
: name
= "RELA"; break;
1751 case DT_RELASZ
: name
= "RELASZ"; break;
1752 case DT_RELAENT
: name
= "RELAENT"; break;
1753 case DT_STRSZ
: name
= "STRSZ"; break;
1754 case DT_SYMENT
: name
= "SYMENT"; break;
1755 case DT_INIT
: name
= "INIT"; break;
1756 case DT_FINI
: name
= "FINI"; break;
1757 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1758 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1759 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1760 case DT_REL
: name
= "REL"; break;
1761 case DT_RELSZ
: name
= "RELSZ"; break;
1762 case DT_RELENT
: name
= "RELENT"; break;
1763 case DT_PLTREL
: name
= "PLTREL"; break;
1764 case DT_DEBUG
: name
= "DEBUG"; break;
1765 case DT_TEXTREL
: name
= "TEXTREL"; break;
1766 case DT_JMPREL
: name
= "JMPREL"; break;
1767 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1768 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1769 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1770 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1771 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1772 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1773 case DT_FLAGS
: name
= "FLAGS"; break;
1774 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1775 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1776 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1777 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1778 case DT_MOVEENT
: name
= "MOVEENT"; break;
1779 case DT_MOVESZ
: name
= "MOVESZ"; break;
1780 case DT_FEATURE
: name
= "FEATURE"; break;
1781 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1782 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1783 case DT_SYMINENT
: name
= "SYMINENT"; break;
1784 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1785 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1786 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1787 case DT_PLTPAD
: name
= "PLTPAD"; break;
1788 case DT_MOVETAB
: name
= "MOVETAB"; break;
1789 case DT_SYMINFO
: name
= "SYMINFO"; break;
1790 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1791 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1792 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1793 case DT_VERSYM
: name
= "VERSYM"; break;
1794 case DT_VERDEF
: name
= "VERDEF"; break;
1795 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1796 case DT_VERNEED
: name
= "VERNEED"; break;
1797 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1798 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1799 case DT_USED
: name
= "USED"; break;
1800 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1801 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1804 fprintf (f
, " %-20s ", name
);
1808 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1813 unsigned int tagv
= dyn
.d_un
.d_val
;
1815 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1818 fprintf (f
, "%s", string
);
1827 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1828 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1830 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1834 if (elf_dynverdef (abfd
) != 0)
1836 Elf_Internal_Verdef
*t
;
1838 fprintf (f
, _("\nVersion definitions:\n"));
1839 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1841 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1842 t
->vd_flags
, t
->vd_hash
,
1843 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1844 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1846 Elf_Internal_Verdaux
*a
;
1849 for (a
= t
->vd_auxptr
->vda_nextptr
;
1853 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1859 if (elf_dynverref (abfd
) != 0)
1861 Elf_Internal_Verneed
*t
;
1863 fprintf (f
, _("\nVersion References:\n"));
1864 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1866 Elf_Internal_Vernaux
*a
;
1868 fprintf (f
, _(" required from %s:\n"),
1869 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1870 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1871 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1872 a
->vna_flags
, a
->vna_other
,
1873 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1884 /* Get version name. If BASE_P is TRUE, return "Base" for VER_FLG_BASE
1885 and return symbol version for symbol version itself. */
1888 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1890 bfd_boolean
*hidden
)
1892 const char *version_string
= NULL
;
1893 if (elf_dynversym (abfd
) != 0
1894 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1896 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1898 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1899 vernum
&= VERSYM_VERSION
;
1902 version_string
= "";
1903 else if (vernum
== 1
1904 && (vernum
> elf_tdata (abfd
)->cverdefs
1905 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1907 version_string
= base_p
? "Base" : "";
1908 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1910 const char *nodename
1911 = elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1912 version_string
= "";
1915 || symbol
->name
== NULL
1916 || strcmp (symbol
->name
, nodename
) != 0)
1917 version_string
= nodename
;
1921 Elf_Internal_Verneed
*t
;
1923 version_string
= _("<corrupt>");
1924 for (t
= elf_tdata (abfd
)->verref
;
1928 Elf_Internal_Vernaux
*a
;
1930 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1932 if (a
->vna_other
== vernum
)
1934 version_string
= a
->vna_nodename
;
1941 return version_string
;
1944 /* Display ELF-specific fields of a symbol. */
1947 bfd_elf_print_symbol (bfd
*abfd
,
1950 bfd_print_symbol_type how
)
1952 FILE *file
= (FILE *) filep
;
1955 case bfd_print_symbol_name
:
1956 fprintf (file
, "%s", symbol
->name
);
1958 case bfd_print_symbol_more
:
1959 fprintf (file
, "elf ");
1960 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1961 fprintf (file
, " %x", symbol
->flags
);
1963 case bfd_print_symbol_all
:
1965 const char *section_name
;
1966 const char *name
= NULL
;
1967 const struct elf_backend_data
*bed
;
1968 unsigned char st_other
;
1970 const char *version_string
;
1973 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1975 bed
= get_elf_backend_data (abfd
);
1976 if (bed
->elf_backend_print_symbol_all
)
1977 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1981 name
= symbol
->name
;
1982 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1985 fprintf (file
, " %s\t", section_name
);
1986 /* Print the "other" value for a symbol. For common symbols,
1987 we've already printed the size; now print the alignment.
1988 For other symbols, we have no specified alignment, and
1989 we've printed the address; now print the size. */
1990 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1991 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1993 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1994 bfd_fprintf_vma (abfd
, file
, val
);
1996 /* If we have version information, print it. */
1997 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
2004 fprintf (file
, " %-11s", version_string
);
2009 fprintf (file
, " (%s)", version_string
);
2010 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
2015 /* If the st_other field is not zero, print it. */
2016 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
2021 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
2022 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
2023 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
2025 /* Some other non-defined flags are also present, so print
2027 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
2030 fprintf (file
, " %s", name
);
2036 /* ELF .o/exec file reading */
2038 /* Create a new bfd section from an ELF section header. */
2041 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2043 Elf_Internal_Shdr
*hdr
;
2044 Elf_Internal_Ehdr
*ehdr
;
2045 const struct elf_backend_data
*bed
;
2047 bfd_boolean ret
= TRUE
;
2048 static bfd_boolean
* sections_being_created
= NULL
;
2049 static bfd
* sections_being_created_abfd
= NULL
;
2050 static unsigned int nesting
= 0;
2052 if (shindex
>= elf_numsections (abfd
))
2057 /* PR17512: A corrupt ELF binary might contain a recursive group of
2058 sections, with each the string indices pointing to the next in the
2059 loop. Detect this here, by refusing to load a section that we are
2060 already in the process of loading. We only trigger this test if
2061 we have nested at least three sections deep as normal ELF binaries
2062 can expect to recurse at least once.
2064 FIXME: It would be better if this array was attached to the bfd,
2065 rather than being held in a static pointer. */
2067 if (sections_being_created_abfd
!= abfd
)
2069 free (sections_being_created
);
2070 sections_being_created
= NULL
;
2072 if (sections_being_created
== NULL
)
2074 size_t amt
= elf_numsections (abfd
) * sizeof (bfd_boolean
);
2076 /* PR 26005: Do not use bfd_zalloc here as the memory might
2077 be released before the bfd has been fully scanned. */
2078 sections_being_created
= (bfd_boolean
*) bfd_zmalloc (amt
);
2079 if (sections_being_created
== NULL
)
2081 sections_being_created_abfd
= abfd
;
2083 if (sections_being_created
[shindex
])
2086 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2089 sections_being_created
[shindex
] = TRUE
;
2092 hdr
= elf_elfsections (abfd
)[shindex
];
2093 ehdr
= elf_elfheader (abfd
);
2094 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2099 bed
= get_elf_backend_data (abfd
);
2100 switch (hdr
->sh_type
)
2103 /* Inactive section. Throw it away. */
2106 case SHT_PROGBITS
: /* Normal section with contents. */
2107 case SHT_NOBITS
: /* .bss section. */
2108 case SHT_HASH
: /* .hash section. */
2109 case SHT_NOTE
: /* .note section. */
2110 case SHT_INIT_ARRAY
: /* .init_array section. */
2111 case SHT_FINI_ARRAY
: /* .fini_array section. */
2112 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2113 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2114 case SHT_GNU_HASH
: /* .gnu.hash section. */
2115 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2118 case SHT_DYNAMIC
: /* Dynamic linking information. */
2119 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2122 if (hdr
->sh_link
> elf_numsections (abfd
))
2124 /* PR 10478: Accept Solaris binaries with a sh_link
2125 field set to SHN_BEFORE or SHN_AFTER. */
2126 switch (bfd_get_arch (abfd
))
2129 case bfd_arch_sparc
:
2130 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2131 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2133 /* Otherwise fall through. */
2138 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2140 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2142 Elf_Internal_Shdr
*dynsymhdr
;
2144 /* The shared libraries distributed with hpux11 have a bogus
2145 sh_link field for the ".dynamic" section. Find the
2146 string table for the ".dynsym" section instead. */
2147 if (elf_dynsymtab (abfd
) != 0)
2149 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2150 hdr
->sh_link
= dynsymhdr
->sh_link
;
2154 unsigned int i
, num_sec
;
2156 num_sec
= elf_numsections (abfd
);
2157 for (i
= 1; i
< num_sec
; i
++)
2159 dynsymhdr
= elf_elfsections (abfd
)[i
];
2160 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2162 hdr
->sh_link
= dynsymhdr
->sh_link
;
2170 case SHT_SYMTAB
: /* A symbol table. */
2171 if (elf_onesymtab (abfd
) == shindex
)
2174 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2177 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2179 if (hdr
->sh_size
!= 0)
2181 /* Some assemblers erroneously set sh_info to one with a
2182 zero sh_size. ld sees this as a global symbol count
2183 of (unsigned) -1. Fix it here. */
2188 /* PR 18854: A binary might contain more than one symbol table.
2189 Unusual, but possible. Warn, but continue. */
2190 if (elf_onesymtab (abfd
) != 0)
2193 /* xgettext:c-format */
2194 (_("%pB: warning: multiple symbol tables detected"
2195 " - ignoring the table in section %u"),
2199 elf_onesymtab (abfd
) = shindex
;
2200 elf_symtab_hdr (abfd
) = *hdr
;
2201 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2202 abfd
->flags
|= HAS_SYMS
;
2204 /* Sometimes a shared object will map in the symbol table. If
2205 SHF_ALLOC is set, and this is a shared object, then we also
2206 treat this section as a BFD section. We can not base the
2207 decision purely on SHF_ALLOC, because that flag is sometimes
2208 set in a relocatable object file, which would confuse the
2210 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2211 && (abfd
->flags
& DYNAMIC
) != 0
2212 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2216 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2217 can't read symbols without that section loaded as well. It
2218 is most likely specified by the next section header. */
2220 elf_section_list
* entry
;
2221 unsigned int i
, num_sec
;
2223 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2224 if (entry
->hdr
.sh_link
== shindex
)
2227 num_sec
= elf_numsections (abfd
);
2228 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2230 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2232 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2233 && hdr2
->sh_link
== shindex
)
2238 for (i
= 1; i
< shindex
; i
++)
2240 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2242 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2243 && hdr2
->sh_link
== shindex
)
2248 ret
= bfd_section_from_shdr (abfd
, i
);
2249 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2253 case SHT_DYNSYM
: /* A dynamic symbol table. */
2254 if (elf_dynsymtab (abfd
) == shindex
)
2257 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2260 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2262 if (hdr
->sh_size
!= 0)
2265 /* Some linkers erroneously set sh_info to one with a
2266 zero sh_size. ld sees this as a global symbol count
2267 of (unsigned) -1. Fix it here. */
2272 /* PR 18854: A binary might contain more than one dynamic symbol table.
2273 Unusual, but possible. Warn, but continue. */
2274 if (elf_dynsymtab (abfd
) != 0)
2277 /* xgettext:c-format */
2278 (_("%pB: warning: multiple dynamic symbol tables detected"
2279 " - ignoring the table in section %u"),
2283 elf_dynsymtab (abfd
) = shindex
;
2284 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2285 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2286 abfd
->flags
|= HAS_SYMS
;
2288 /* Besides being a symbol table, we also treat this as a regular
2289 section, so that objcopy can handle it. */
2290 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2293 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2295 elf_section_list
* entry
;
2297 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2298 if (entry
->ndx
== shindex
)
2301 entry
= bfd_alloc (abfd
, sizeof (*entry
));
2304 entry
->ndx
= shindex
;
2306 entry
->next
= elf_symtab_shndx_list (abfd
);
2307 elf_symtab_shndx_list (abfd
) = entry
;
2308 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2312 case SHT_STRTAB
: /* A string table. */
2313 if (hdr
->bfd_section
!= NULL
)
2316 if (ehdr
->e_shstrndx
== shindex
)
2318 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2319 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2323 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2326 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2327 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2331 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2334 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2335 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2336 elf_elfsections (abfd
)[shindex
] = hdr
;
2337 /* We also treat this as a regular section, so that objcopy
2339 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2344 /* If the string table isn't one of the above, then treat it as a
2345 regular section. We need to scan all the headers to be sure,
2346 just in case this strtab section appeared before the above. */
2347 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2349 unsigned int i
, num_sec
;
2351 num_sec
= elf_numsections (abfd
);
2352 for (i
= 1; i
< num_sec
; i
++)
2354 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2355 if (hdr2
->sh_link
== shindex
)
2357 /* Prevent endless recursion on broken objects. */
2360 if (! bfd_section_from_shdr (abfd
, i
))
2362 if (elf_onesymtab (abfd
) == i
)
2364 if (elf_dynsymtab (abfd
) == i
)
2365 goto dynsymtab_strtab
;
2369 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2374 /* *These* do a lot of work -- but build no sections! */
2376 asection
*target_sect
;
2377 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2378 unsigned int num_sec
= elf_numsections (abfd
);
2379 struct bfd_elf_section_data
*esdt
;
2382 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2383 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2386 /* Check for a bogus link to avoid crashing. */
2387 if (hdr
->sh_link
>= num_sec
)
2390 /* xgettext:c-format */
2391 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2392 abfd
, hdr
->sh_link
, name
, shindex
);
2393 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2398 /* For some incomprehensible reason Oracle distributes
2399 libraries for Solaris in which some of the objects have
2400 bogus sh_link fields. It would be nice if we could just
2401 reject them, but, unfortunately, some people need to use
2402 them. We scan through the section headers; if we find only
2403 one suitable symbol table, we clobber the sh_link to point
2404 to it. I hope this doesn't break anything.
2406 Don't do it on executable nor shared library. */
2407 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2408 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2409 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2415 for (scan
= 1; scan
< num_sec
; scan
++)
2417 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2418 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2429 hdr
->sh_link
= found
;
2432 /* Get the symbol table. */
2433 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2434 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2435 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2438 /* If this is an alloc section in an executable or shared
2439 library, or the reloc section does not use the main symbol
2440 table we don't treat it as a reloc section. BFD can't
2441 adequately represent such a section, so at least for now,
2442 we don't try. We just present it as a normal section. We
2443 also can't use it as a reloc section if it points to the
2444 null section, an invalid section, another reloc section, or
2445 its sh_link points to the null section. */
2446 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2447 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2448 || hdr
->sh_link
== SHN_UNDEF
2449 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2450 || hdr
->sh_info
== SHN_UNDEF
2451 || hdr
->sh_info
>= num_sec
2452 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2453 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2455 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2460 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2463 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2464 if (target_sect
== NULL
)
2467 esdt
= elf_section_data (target_sect
);
2468 if (hdr
->sh_type
== SHT_RELA
)
2469 p_hdr
= &esdt
->rela
.hdr
;
2471 p_hdr
= &esdt
->rel
.hdr
;
2473 /* PR 17512: file: 0b4f81b7.
2474 Also see PR 24456, for a file which deliberately has two reloc
2478 if (!bed
->init_secondary_reloc_section (abfd
, hdr
, name
, shindex
))
2481 /* xgettext:c-format */
2482 (_("%pB: warning: secondary relocation section '%s' "
2483 "for section %pA found - ignoring"),
2484 abfd
, name
, target_sect
);
2489 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2494 elf_elfsections (abfd
)[shindex
] = hdr2
;
2495 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2496 * bed
->s
->int_rels_per_ext_rel
);
2497 target_sect
->flags
|= SEC_RELOC
;
2498 target_sect
->relocation
= NULL
;
2499 target_sect
->rel_filepos
= hdr
->sh_offset
;
2500 /* In the section to which the relocations apply, mark whether
2501 its relocations are of the REL or RELA variety. */
2502 if (hdr
->sh_size
!= 0)
2504 if (hdr
->sh_type
== SHT_RELA
)
2505 target_sect
->use_rela_p
= 1;
2507 abfd
->flags
|= HAS_RELOC
;
2511 case SHT_GNU_verdef
:
2512 elf_dynverdef (abfd
) = shindex
;
2513 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2514 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2517 case SHT_GNU_versym
:
2518 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2521 elf_dynversym (abfd
) = shindex
;
2522 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2523 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2526 case SHT_GNU_verneed
:
2527 elf_dynverref (abfd
) = shindex
;
2528 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2529 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2536 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2539 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2545 /* Possibly an attributes section. */
2546 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2547 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2549 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2551 _bfd_elf_parse_attributes (abfd
, hdr
);
2555 /* Check for any processor-specific section types. */
2556 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2559 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2561 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2562 /* FIXME: How to properly handle allocated section reserved
2563 for applications? */
2565 /* xgettext:c-format */
2566 (_("%pB: unknown type [%#x] section `%s'"),
2567 abfd
, hdr
->sh_type
, name
);
2570 /* Allow sections reserved for applications. */
2571 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2576 else if (hdr
->sh_type
>= SHT_LOPROC
2577 && hdr
->sh_type
<= SHT_HIPROC
)
2578 /* FIXME: We should handle this section. */
2580 /* xgettext:c-format */
2581 (_("%pB: unknown type [%#x] section `%s'"),
2582 abfd
, hdr
->sh_type
, name
);
2583 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2585 /* Unrecognised OS-specific sections. */
2586 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2587 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2588 required to correctly process the section and the file should
2589 be rejected with an error message. */
2591 /* xgettext:c-format */
2592 (_("%pB: unknown type [%#x] section `%s'"),
2593 abfd
, hdr
->sh_type
, name
);
2596 /* Otherwise it should be processed. */
2597 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2602 /* FIXME: We should handle this section. */
2604 /* xgettext:c-format */
2605 (_("%pB: unknown type [%#x] section `%s'"),
2606 abfd
, hdr
->sh_type
, name
);
2614 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2615 sections_being_created
[shindex
] = FALSE
;
2616 if (-- nesting
== 0)
2618 free (sections_being_created
);
2619 sections_being_created
= NULL
;
2620 sections_being_created_abfd
= NULL
;
2625 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2628 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2630 unsigned long r_symndx
)
2632 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2634 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2636 Elf_Internal_Shdr
*symtab_hdr
;
2637 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2638 Elf_External_Sym_Shndx eshndx
;
2640 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2641 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2642 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2645 if (cache
->abfd
!= abfd
)
2647 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2650 cache
->indx
[ent
] = r_symndx
;
2653 return &cache
->sym
[ent
];
2656 /* Given an ELF section number, retrieve the corresponding BFD
2660 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2662 if (sec_index
>= elf_numsections (abfd
))
2664 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2667 static const struct bfd_elf_special_section special_sections_b
[] =
2669 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2670 { NULL
, 0, 0, 0, 0 }
2673 static const struct bfd_elf_special_section special_sections_c
[] =
2675 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2676 { STRING_COMMA_LEN (".ctf"), 0, SHT_PROGBITS
, 0 },
2677 { NULL
, 0, 0, 0, 0 }
2680 static const struct bfd_elf_special_section special_sections_d
[] =
2682 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2683 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2684 /* There are more DWARF sections than these, but they needn't be added here
2685 unless you have to cope with broken compilers that don't emit section
2686 attributes or you want to help the user writing assembler. */
2687 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2688 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2689 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2690 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2691 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2692 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2693 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2694 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2695 { NULL
, 0, 0, 0, 0 }
2698 static const struct bfd_elf_special_section special_sections_f
[] =
2700 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2701 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2702 { NULL
, 0 , 0, 0, 0 }
2705 static const struct bfd_elf_special_section special_sections_g
[] =
2707 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2708 { STRING_COMMA_LEN (".gnu.linkonce.n"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2709 { STRING_COMMA_LEN (".gnu.linkonce.p"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2710 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2711 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2712 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2713 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2714 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2715 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2716 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2717 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2718 { NULL
, 0, 0, 0, 0 }
2721 static const struct bfd_elf_special_section special_sections_h
[] =
2723 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2724 { NULL
, 0, 0, 0, 0 }
2727 static const struct bfd_elf_special_section special_sections_i
[] =
2729 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2730 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2731 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2732 { NULL
, 0, 0, 0, 0 }
2735 static const struct bfd_elf_special_section special_sections_l
[] =
2737 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2738 { NULL
, 0, 0, 0, 0 }
2741 static const struct bfd_elf_special_section special_sections_n
[] =
2743 { STRING_COMMA_LEN (".noinit"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2744 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2745 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2746 { NULL
, 0, 0, 0, 0 }
2749 static const struct bfd_elf_special_section special_sections_p
[] =
2751 { STRING_COMMA_LEN (".persistent"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2752 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2753 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2754 { NULL
, 0, 0, 0, 0 }
2757 static const struct bfd_elf_special_section special_sections_r
[] =
2759 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2760 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2761 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2762 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2763 { NULL
, 0, 0, 0, 0 }
2766 static const struct bfd_elf_special_section special_sections_s
[] =
2768 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2769 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2770 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2771 /* See struct bfd_elf_special_section declaration for the semantics of
2772 this special case where .prefix_length != strlen (.prefix). */
2773 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2774 { NULL
, 0, 0, 0, 0 }
2777 static const struct bfd_elf_special_section special_sections_t
[] =
2779 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2780 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2781 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2782 { NULL
, 0, 0, 0, 0 }
2785 static const struct bfd_elf_special_section special_sections_z
[] =
2787 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2788 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2789 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2790 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2791 { NULL
, 0, 0, 0, 0 }
2794 static const struct bfd_elf_special_section
* const special_sections
[] =
2796 special_sections_b
, /* 'b' */
2797 special_sections_c
, /* 'c' */
2798 special_sections_d
, /* 'd' */
2800 special_sections_f
, /* 'f' */
2801 special_sections_g
, /* 'g' */
2802 special_sections_h
, /* 'h' */
2803 special_sections_i
, /* 'i' */
2806 special_sections_l
, /* 'l' */
2808 special_sections_n
, /* 'n' */
2810 special_sections_p
, /* 'p' */
2812 special_sections_r
, /* 'r' */
2813 special_sections_s
, /* 's' */
2814 special_sections_t
, /* 't' */
2820 special_sections_z
/* 'z' */
2823 const struct bfd_elf_special_section
*
2824 _bfd_elf_get_special_section (const char *name
,
2825 const struct bfd_elf_special_section
*spec
,
2831 len
= strlen (name
);
2833 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2836 int prefix_len
= spec
[i
].prefix_length
;
2838 if (len
< prefix_len
)
2840 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2843 suffix_len
= spec
[i
].suffix_length
;
2844 if (suffix_len
<= 0)
2846 if (name
[prefix_len
] != 0)
2848 if (suffix_len
== 0)
2850 if (name
[prefix_len
] != '.'
2851 && (suffix_len
== -2
2852 || (rela
&& spec
[i
].type
== SHT_REL
)))
2858 if (len
< prefix_len
+ suffix_len
)
2860 if (memcmp (name
+ len
- suffix_len
,
2861 spec
[i
].prefix
+ prefix_len
,
2871 const struct bfd_elf_special_section
*
2872 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2875 const struct bfd_elf_special_section
*spec
;
2876 const struct elf_backend_data
*bed
;
2878 /* See if this is one of the special sections. */
2879 if (sec
->name
== NULL
)
2882 bed
= get_elf_backend_data (abfd
);
2883 spec
= bed
->special_sections
;
2886 spec
= _bfd_elf_get_special_section (sec
->name
,
2887 bed
->special_sections
,
2893 if (sec
->name
[0] != '.')
2896 i
= sec
->name
[1] - 'b';
2897 if (i
< 0 || i
> 'z' - 'b')
2900 spec
= special_sections
[i
];
2905 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2909 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2911 struct bfd_elf_section_data
*sdata
;
2912 const struct elf_backend_data
*bed
;
2913 const struct bfd_elf_special_section
*ssect
;
2915 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2918 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2922 sec
->used_by_bfd
= sdata
;
2925 /* Indicate whether or not this section should use RELA relocations. */
2926 bed
= get_elf_backend_data (abfd
);
2927 sec
->use_rela_p
= bed
->default_use_rela_p
;
2929 /* Set up ELF section type and flags for newly created sections, if
2930 there is an ABI mandated section. */
2931 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2934 elf_section_type (sec
) = ssect
->type
;
2935 elf_section_flags (sec
) = ssect
->attr
;
2938 return _bfd_generic_new_section_hook (abfd
, sec
);
2941 /* Create a new bfd section from an ELF program header.
2943 Since program segments have no names, we generate a synthetic name
2944 of the form segment<NUM>, where NUM is generally the index in the
2945 program header table. For segments that are split (see below) we
2946 generate the names segment<NUM>a and segment<NUM>b.
2948 Note that some program segments may have a file size that is different than
2949 (less than) the memory size. All this means is that at execution the
2950 system must allocate the amount of memory specified by the memory size,
2951 but only initialize it with the first "file size" bytes read from the
2952 file. This would occur for example, with program segments consisting
2953 of combined data+bss.
2955 To handle the above situation, this routine generates TWO bfd sections
2956 for the single program segment. The first has the length specified by
2957 the file size of the segment, and the second has the length specified
2958 by the difference between the two sizes. In effect, the segment is split
2959 into its initialized and uninitialized parts.
2964 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2965 Elf_Internal_Phdr
*hdr
,
2967 const char *type_name
)
2974 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
2976 split
= ((hdr
->p_memsz
> 0)
2977 && (hdr
->p_filesz
> 0)
2978 && (hdr
->p_memsz
> hdr
->p_filesz
));
2980 if (hdr
->p_filesz
> 0)
2982 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2983 len
= strlen (namebuf
) + 1;
2984 name
= (char *) bfd_alloc (abfd
, len
);
2987 memcpy (name
, namebuf
, len
);
2988 newsect
= bfd_make_section (abfd
, name
);
2989 if (newsect
== NULL
)
2991 newsect
->vma
= hdr
->p_vaddr
/ opb
;
2992 newsect
->lma
= hdr
->p_paddr
/ opb
;
2993 newsect
->size
= hdr
->p_filesz
;
2994 newsect
->filepos
= hdr
->p_offset
;
2995 newsect
->flags
|= SEC_HAS_CONTENTS
;
2996 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2997 if (hdr
->p_type
== PT_LOAD
)
2999 newsect
->flags
|= SEC_ALLOC
;
3000 newsect
->flags
|= SEC_LOAD
;
3001 if (hdr
->p_flags
& PF_X
)
3003 /* FIXME: all we known is that it has execute PERMISSION,
3005 newsect
->flags
|= SEC_CODE
;
3008 if (!(hdr
->p_flags
& PF_W
))
3010 newsect
->flags
|= SEC_READONLY
;
3014 if (hdr
->p_memsz
> hdr
->p_filesz
)
3018 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
3019 len
= strlen (namebuf
) + 1;
3020 name
= (char *) bfd_alloc (abfd
, len
);
3023 memcpy (name
, namebuf
, len
);
3024 newsect
= bfd_make_section (abfd
, name
);
3025 if (newsect
== NULL
)
3027 newsect
->vma
= (hdr
->p_vaddr
+ hdr
->p_filesz
) / opb
;
3028 newsect
->lma
= (hdr
->p_paddr
+ hdr
->p_filesz
) / opb
;
3029 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
3030 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
3031 align
= newsect
->vma
& -newsect
->vma
;
3032 if (align
== 0 || align
> hdr
->p_align
)
3033 align
= hdr
->p_align
;
3034 newsect
->alignment_power
= bfd_log2 (align
);
3035 if (hdr
->p_type
== PT_LOAD
)
3037 newsect
->flags
|= SEC_ALLOC
;
3038 if (hdr
->p_flags
& PF_X
)
3039 newsect
->flags
|= SEC_CODE
;
3041 if (!(hdr
->p_flags
& PF_W
))
3042 newsect
->flags
|= SEC_READONLY
;
3049 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3051 /* The return value is ignored. Build-ids are considered optional. */
3052 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3053 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3059 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3061 const struct elf_backend_data
*bed
;
3063 switch (hdr
->p_type
)
3066 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3069 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3071 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3072 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3076 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3079 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3082 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3084 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3090 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3093 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3095 case PT_GNU_EH_FRAME
:
3096 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3100 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3103 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3106 /* Check for any processor-specific program segment types. */
3107 bed
= get_elf_backend_data (abfd
);
3108 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3112 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3116 _bfd_elf_single_rel_hdr (asection
*sec
)
3118 if (elf_section_data (sec
)->rel
.hdr
)
3120 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3121 return elf_section_data (sec
)->rel
.hdr
;
3124 return elf_section_data (sec
)->rela
.hdr
;
3128 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3129 Elf_Internal_Shdr
*rel_hdr
,
3130 const char *sec_name
,
3131 bfd_boolean use_rela_p
)
3133 char *name
= (char *) bfd_alloc (abfd
,
3134 sizeof ".rela" + strlen (sec_name
));
3138 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3140 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3142 if (rel_hdr
->sh_name
== (unsigned int) -1)
3148 /* Allocate and initialize a section-header for a new reloc section,
3149 containing relocations against ASECT. It is stored in RELDATA. If
3150 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3154 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3155 struct bfd_elf_section_reloc_data
*reldata
,
3156 const char *sec_name
,
3157 bfd_boolean use_rela_p
,
3158 bfd_boolean delay_st_name_p
)
3160 Elf_Internal_Shdr
*rel_hdr
;
3161 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3163 BFD_ASSERT (reldata
->hdr
== NULL
);
3164 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3165 reldata
->hdr
= rel_hdr
;
3167 if (delay_st_name_p
)
3168 rel_hdr
->sh_name
= (unsigned int) -1;
3169 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3172 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3173 rel_hdr
->sh_entsize
= (use_rela_p
3174 ? bed
->s
->sizeof_rela
3175 : bed
->s
->sizeof_rel
);
3176 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3177 rel_hdr
->sh_flags
= 0;
3178 rel_hdr
->sh_addr
= 0;
3179 rel_hdr
->sh_size
= 0;
3180 rel_hdr
->sh_offset
= 0;
3185 /* Return the default section type based on the passed in section flags. */
3188 bfd_elf_get_default_section_type (flagword flags
)
3190 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3191 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3193 return SHT_PROGBITS
;
3196 struct fake_section_arg
3198 struct bfd_link_info
*link_info
;
3202 /* Set up an ELF internal section header for a section. */
3205 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3207 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3208 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3209 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3210 Elf_Internal_Shdr
*this_hdr
;
3211 unsigned int sh_type
;
3212 const char *name
= asect
->name
;
3213 bfd_boolean delay_st_name_p
= FALSE
;
3218 /* We already failed; just get out of the bfd_map_over_sections
3223 this_hdr
= &esd
->this_hdr
;
3227 /* ld: compress DWARF debug sections with names: .debug_*. */
3228 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3229 && (asect
->flags
& SEC_DEBUGGING
)
3233 /* Set SEC_ELF_COMPRESS to indicate this section should be
3235 asect
->flags
|= SEC_ELF_COMPRESS
;
3236 /* If this section will be compressed, delay adding section
3237 name to section name section after it is compressed in
3238 _bfd_elf_assign_file_positions_for_non_load. */
3239 delay_st_name_p
= TRUE
;
3242 else if ((asect
->flags
& SEC_ELF_RENAME
))
3244 /* objcopy: rename output DWARF debug section. */
3245 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3247 /* When we decompress or compress with SHF_COMPRESSED,
3248 convert section name from .zdebug_* to .debug_* if
3252 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3253 if (new_name
== NULL
)
3261 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3263 /* PR binutils/18087: Compression does not always make a
3264 section smaller. So only rename the section when
3265 compression has actually taken place. If input section
3266 name is .zdebug_*, we should never compress it again. */
3267 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3268 if (new_name
== NULL
)
3273 BFD_ASSERT (name
[1] != 'z');
3278 if (delay_st_name_p
)
3279 this_hdr
->sh_name
= (unsigned int) -1;
3283 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3285 if (this_hdr
->sh_name
== (unsigned int) -1)
3292 /* Don't clear sh_flags. Assembler may set additional bits. */
3294 if ((asect
->flags
& SEC_ALLOC
) != 0
3295 || asect
->user_set_vma
)
3296 this_hdr
->sh_addr
= asect
->vma
* bfd_octets_per_byte (abfd
, asect
);
3298 this_hdr
->sh_addr
= 0;
3300 this_hdr
->sh_offset
= 0;
3301 this_hdr
->sh_size
= asect
->size
;
3302 this_hdr
->sh_link
= 0;
3303 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3304 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3307 /* xgettext:c-format */
3308 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3309 abfd
, asect
->alignment_power
, asect
);
3313 /* Set sh_addralign to the highest power of two given by alignment
3314 consistent with the section VMA. Linker scripts can force VMA. */
3315 mask
= ((bfd_vma
) 1 << asect
->alignment_power
) | this_hdr
->sh_addr
;
3316 this_hdr
->sh_addralign
= mask
& -mask
;
3317 /* The sh_entsize and sh_info fields may have been set already by
3318 copy_private_section_data. */
3320 this_hdr
->bfd_section
= asect
;
3321 this_hdr
->contents
= NULL
;
3323 /* If the section type is unspecified, we set it based on
3325 if ((asect
->flags
& SEC_GROUP
) != 0)
3326 sh_type
= SHT_GROUP
;
3328 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3330 if (this_hdr
->sh_type
== SHT_NULL
)
3331 this_hdr
->sh_type
= sh_type
;
3332 else if (this_hdr
->sh_type
== SHT_NOBITS
3333 && sh_type
== SHT_PROGBITS
3334 && (asect
->flags
& SEC_ALLOC
) != 0)
3336 /* Warn if we are changing a NOBITS section to PROGBITS, but
3337 allow the link to proceed. This can happen when users link
3338 non-bss input sections to bss output sections, or emit data
3339 to a bss output section via a linker script. */
3341 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3342 this_hdr
->sh_type
= sh_type
;
3345 switch (this_hdr
->sh_type
)
3356 case SHT_INIT_ARRAY
:
3357 case SHT_FINI_ARRAY
:
3358 case SHT_PREINIT_ARRAY
:
3359 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3363 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3367 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3371 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3375 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3376 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3380 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3381 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3384 case SHT_GNU_versym
:
3385 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3388 case SHT_GNU_verdef
:
3389 this_hdr
->sh_entsize
= 0;
3390 /* objcopy or strip will copy over sh_info, but may not set
3391 cverdefs. The linker will set cverdefs, but sh_info will be
3393 if (this_hdr
->sh_info
== 0)
3394 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3396 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3397 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3400 case SHT_GNU_verneed
:
3401 this_hdr
->sh_entsize
= 0;
3402 /* objcopy or strip will copy over sh_info, but may not set
3403 cverrefs. The linker will set cverrefs, but sh_info will be
3405 if (this_hdr
->sh_info
== 0)
3406 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3408 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3409 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3413 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3417 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3421 if ((asect
->flags
& SEC_ALLOC
) != 0)
3422 this_hdr
->sh_flags
|= SHF_ALLOC
;
3423 if ((asect
->flags
& SEC_READONLY
) == 0)
3424 this_hdr
->sh_flags
|= SHF_WRITE
;
3425 if ((asect
->flags
& SEC_CODE
) != 0)
3426 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3427 if ((asect
->flags
& SEC_MERGE
) != 0)
3429 this_hdr
->sh_flags
|= SHF_MERGE
;
3430 this_hdr
->sh_entsize
= asect
->entsize
;
3432 if ((asect
->flags
& SEC_STRINGS
) != 0)
3433 this_hdr
->sh_flags
|= SHF_STRINGS
;
3434 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3435 this_hdr
->sh_flags
|= SHF_GROUP
;
3436 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3438 this_hdr
->sh_flags
|= SHF_TLS
;
3439 if (asect
->size
== 0
3440 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3442 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3444 this_hdr
->sh_size
= 0;
3447 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3448 if (this_hdr
->sh_size
!= 0)
3449 this_hdr
->sh_type
= SHT_NOBITS
;
3453 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3454 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3456 /* If the section has relocs, set up a section header for the
3457 SHT_REL[A] section. If two relocation sections are required for
3458 this section, it is up to the processor-specific back-end to
3459 create the other. */
3460 if ((asect
->flags
& SEC_RELOC
) != 0)
3462 /* When doing a relocatable link, create both REL and RELA sections if
3465 /* Do the normal setup if we wouldn't create any sections here. */
3466 && esd
->rel
.count
+ esd
->rela
.count
> 0
3467 && (bfd_link_relocatable (arg
->link_info
)
3468 || arg
->link_info
->emitrelocations
))
3470 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3471 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3472 FALSE
, delay_st_name_p
))
3477 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3478 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3479 TRUE
, delay_st_name_p
))
3485 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3487 ? &esd
->rela
: &esd
->rel
),
3497 /* Check for processor-specific section types. */
3498 sh_type
= this_hdr
->sh_type
;
3499 if (bed
->elf_backend_fake_sections
3500 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3506 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3508 /* Don't change the header type from NOBITS if we are being
3509 called for objcopy --only-keep-debug. */
3510 this_hdr
->sh_type
= sh_type
;
3514 /* Fill in the contents of a SHT_GROUP section. Called from
3515 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3516 when ELF targets use the generic linker, ld. Called for ld -r
3517 from bfd_elf_final_link. */
3520 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3522 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3523 asection
*elt
, *first
;
3527 /* Ignore linker created group section. See elfNN_ia64_object_p in
3529 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3534 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3536 unsigned long symindx
= 0;
3538 /* elf_group_id will have been set up by objcopy and the
3540 if (elf_group_id (sec
) != NULL
)
3541 symindx
= elf_group_id (sec
)->udata
.i
;
3545 /* If called from the assembler, swap_out_syms will have set up
3547 PR 25699: A corrupt input file could contain bogus group info. */
3548 if (elf_section_syms (abfd
) == NULL
)
3553 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3555 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3557 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3559 /* The ELF backend linker sets sh_info to -2 when the group
3560 signature symbol is global, and thus the index can't be
3561 set until all local symbols are output. */
3563 struct bfd_elf_section_data
*sec_data
;
3564 unsigned long symndx
;
3565 unsigned long extsymoff
;
3566 struct elf_link_hash_entry
*h
;
3568 /* The point of this little dance to the first SHF_GROUP section
3569 then back to the SHT_GROUP section is that this gets us to
3570 the SHT_GROUP in the input object. */
3571 igroup
= elf_sec_group (elf_next_in_group (sec
));
3572 sec_data
= elf_section_data (igroup
);
3573 symndx
= sec_data
->this_hdr
.sh_info
;
3575 if (!elf_bad_symtab (igroup
->owner
))
3577 Elf_Internal_Shdr
*symtab_hdr
;
3579 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3580 extsymoff
= symtab_hdr
->sh_info
;
3582 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3583 while (h
->root
.type
== bfd_link_hash_indirect
3584 || h
->root
.type
== bfd_link_hash_warning
)
3585 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3587 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3590 /* The contents won't be allocated for "ld -r" or objcopy. */
3592 if (sec
->contents
== NULL
)
3595 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3597 /* Arrange for the section to be written out. */
3598 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3599 if (sec
->contents
== NULL
)
3606 loc
= sec
->contents
+ sec
->size
;
3608 /* Get the pointer to the first section in the group that gas
3609 squirreled away here. objcopy arranges for this to be set to the
3610 start of the input section group. */
3611 first
= elt
= elf_next_in_group (sec
);
3613 /* First element is a flag word. Rest of section is elf section
3614 indices for all the sections of the group. Write them backwards
3615 just to keep the group in the same order as given in .section
3616 directives, not that it matters. */
3623 s
= s
->output_section
;
3625 && !bfd_is_abs_section (s
))
3627 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3628 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3630 if (elf_sec
->rel
.hdr
!= NULL
3632 || (input_elf_sec
->rel
.hdr
!= NULL
3633 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3635 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3637 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3639 if (elf_sec
->rela
.hdr
!= NULL
3641 || (input_elf_sec
->rela
.hdr
!= NULL
3642 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3644 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3646 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3649 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3651 elt
= elf_next_in_group (elt
);
3657 BFD_ASSERT (loc
== sec
->contents
);
3659 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3662 /* Given NAME, the name of a relocation section stripped of its
3663 .rel/.rela prefix, return the section in ABFD to which the
3664 relocations apply. */
3667 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3669 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3670 section likely apply to .got.plt or .got section. */
3671 if (get_elf_backend_data (abfd
)->want_got_plt
3672 && strcmp (name
, ".plt") == 0)
3677 sec
= bfd_get_section_by_name (abfd
, name
);
3683 return bfd_get_section_by_name (abfd
, name
);
3686 /* Return the section to which RELOC_SEC applies. */
3689 elf_get_reloc_section (asection
*reloc_sec
)
3694 const struct elf_backend_data
*bed
;
3696 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3697 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3700 /* We look up the section the relocs apply to by name. */
3701 name
= reloc_sec
->name
;
3702 if (strncmp (name
, ".rel", 4) != 0)
3705 if (type
== SHT_RELA
&& *name
++ != 'a')
3708 abfd
= reloc_sec
->owner
;
3709 bed
= get_elf_backend_data (abfd
);
3710 return bed
->get_reloc_section (abfd
, name
);
3713 /* Assign all ELF section numbers. The dummy first section is handled here
3714 too. The link/info pointers for the standard section types are filled
3715 in here too, while we're at it. LINK_INFO will be 0 when arriving
3716 here for objcopy, and when using the generic ELF linker. */
3719 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3721 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3723 unsigned int section_number
;
3724 Elf_Internal_Shdr
**i_shdrp
;
3725 struct bfd_elf_section_data
*d
;
3726 bfd_boolean need_symtab
;
3731 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3733 /* SHT_GROUP sections are in relocatable files only. */
3734 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3736 size_t reloc_count
= 0;
3738 /* Put SHT_GROUP sections first. */
3739 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3741 d
= elf_section_data (sec
);
3743 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3745 if (sec
->flags
& SEC_LINKER_CREATED
)
3747 /* Remove the linker created SHT_GROUP sections. */
3748 bfd_section_list_remove (abfd
, sec
);
3749 abfd
->section_count
--;
3752 d
->this_idx
= section_number
++;
3755 /* Count relocations. */
3756 reloc_count
+= sec
->reloc_count
;
3759 /* Clear HAS_RELOC if there are no relocations. */
3760 if (reloc_count
== 0)
3761 abfd
->flags
&= ~HAS_RELOC
;
3764 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3766 d
= elf_section_data (sec
);
3768 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3769 d
->this_idx
= section_number
++;
3770 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3771 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3774 d
->rel
.idx
= section_number
++;
3775 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3776 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3783 d
->rela
.idx
= section_number
++;
3784 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3785 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3791 need_symtab
= (bfd_get_symcount (abfd
) > 0
3792 || (link_info
== NULL
3793 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3797 elf_onesymtab (abfd
) = section_number
++;
3798 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3799 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3801 elf_section_list
*entry
;
3803 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3805 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3806 entry
->ndx
= section_number
++;
3807 elf_symtab_shndx_list (abfd
) = entry
;
3809 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3810 ".symtab_shndx", FALSE
);
3811 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3814 elf_strtab_sec (abfd
) = section_number
++;
3815 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3818 elf_shstrtab_sec (abfd
) = section_number
++;
3819 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3820 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3822 if (section_number
>= SHN_LORESERVE
)
3824 /* xgettext:c-format */
3825 _bfd_error_handler (_("%pB: too many sections: %u"),
3826 abfd
, section_number
);
3830 elf_numsections (abfd
) = section_number
;
3831 elf_elfheader (abfd
)->e_shnum
= section_number
;
3833 /* Set up the list of section header pointers, in agreement with the
3835 amt
= section_number
* sizeof (Elf_Internal_Shdr
*);
3836 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc (abfd
, amt
);
3837 if (i_shdrp
== NULL
)
3840 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3841 sizeof (Elf_Internal_Shdr
));
3842 if (i_shdrp
[0] == NULL
)
3844 bfd_release (abfd
, i_shdrp
);
3848 elf_elfsections (abfd
) = i_shdrp
;
3850 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3853 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3854 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3856 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3857 BFD_ASSERT (entry
!= NULL
);
3858 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3859 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3861 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3862 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3865 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3869 d
= elf_section_data (sec
);
3871 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3872 if (d
->rel
.idx
!= 0)
3873 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3874 if (d
->rela
.idx
!= 0)
3875 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3877 /* Fill in the sh_link and sh_info fields while we're at it. */
3879 /* sh_link of a reloc section is the section index of the symbol
3880 table. sh_info is the section index of the section to which
3881 the relocation entries apply. */
3882 if (d
->rel
.idx
!= 0)
3884 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3885 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3886 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3888 if (d
->rela
.idx
!= 0)
3890 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3891 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3892 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3895 /* We need to set up sh_link for SHF_LINK_ORDER. */
3896 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3898 s
= elf_linked_to_section (sec
);
3899 /* We can now have a NULL linked section pointer.
3900 This happens when the sh_link field is 0, which is done
3901 when a linked to section is discarded but the linking
3902 section has been retained for some reason. */
3905 /* Check discarded linkonce section. */
3906 if (discarded_section (s
))
3910 /* xgettext:c-format */
3911 (_("%pB: sh_link of section `%pA' points to"
3912 " discarded section `%pA' of `%pB'"),
3913 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3914 /* Point to the kept section if it has the same
3915 size as the discarded one. */
3916 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3919 bfd_set_error (bfd_error_bad_value
);
3924 /* Handle objcopy. */
3925 else if (s
->output_section
== NULL
)
3928 /* xgettext:c-format */
3929 (_("%pB: sh_link of section `%pA' points to"
3930 " removed section `%pA' of `%pB'"),
3931 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3932 bfd_set_error (bfd_error_bad_value
);
3935 s
= s
->output_section
;
3936 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3940 switch (d
->this_hdr
.sh_type
)
3944 /* A reloc section which we are treating as a normal BFD
3945 section. sh_link is the section index of the symbol
3946 table. sh_info is the section index of the section to
3947 which the relocation entries apply. We assume that an
3948 allocated reloc section uses the dynamic symbol table.
3949 FIXME: How can we be sure? */
3950 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3952 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3954 s
= elf_get_reloc_section (sec
);
3957 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3958 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3963 /* We assume that a section named .stab*str is a stabs
3964 string section. We look for a section with the same name
3965 but without the trailing ``str'', and set its sh_link
3966 field to point to this section. */
3967 if (CONST_STRNEQ (sec
->name
, ".stab")
3968 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3973 len
= strlen (sec
->name
);
3974 alc
= (char *) bfd_malloc (len
- 2);
3977 memcpy (alc
, sec
->name
, len
- 3);
3978 alc
[len
- 3] = '\0';
3979 s
= bfd_get_section_by_name (abfd
, alc
);
3983 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3985 /* This is a .stab section. */
3986 elf_section_data (s
)->this_hdr
.sh_entsize
= 12;
3993 case SHT_GNU_verneed
:
3994 case SHT_GNU_verdef
:
3995 /* sh_link is the section header index of the string table
3996 used for the dynamic entries, or the symbol table, or the
3998 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4000 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4003 case SHT_GNU_LIBLIST
:
4004 /* sh_link is the section header index of the prelink library
4005 list used for the dynamic entries, or the symbol table, or
4006 the version strings. */
4007 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
4008 ? ".dynstr" : ".gnu.libstr");
4010 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4015 case SHT_GNU_versym
:
4016 /* sh_link is the section header index of the symbol table
4017 this hash table or version table is for. */
4018 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4020 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4024 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
4028 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
4029 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
4030 debug section name from .debug_* to .zdebug_* if needed. */
4036 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4038 /* If the backend has a special mapping, use it. */
4039 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4040 if (bed
->elf_backend_sym_is_global
)
4041 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4043 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4044 || bfd_is_und_section (bfd_asymbol_section (sym
))
4045 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4048 /* Filter global symbols of ABFD to include in the import library. All
4049 SYMCOUNT symbols of ABFD can be examined from their pointers in
4050 SYMS. Pointers of symbols to keep should be stored contiguously at
4051 the beginning of that array.
4053 Returns the number of symbols to keep. */
4056 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4057 asymbol
**syms
, long symcount
)
4059 long src_count
, dst_count
= 0;
4061 for (src_count
= 0; src_count
< symcount
; src_count
++)
4063 asymbol
*sym
= syms
[src_count
];
4064 char *name
= (char *) bfd_asymbol_name (sym
);
4065 struct bfd_link_hash_entry
*h
;
4067 if (!sym_is_global (abfd
, sym
))
4070 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
4073 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4075 if (h
->linker_def
|| h
->ldscript_def
)
4078 syms
[dst_count
++] = sym
;
4081 syms
[dst_count
] = NULL
;
4086 /* Don't output section symbols for sections that are not going to be
4087 output, that are duplicates or there is no BFD section. */
4090 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4092 elf_symbol_type
*type_ptr
;
4097 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4100 if (sym
->section
== NULL
)
4103 type_ptr
= elf_symbol_from (sym
);
4104 return ((type_ptr
!= NULL
4105 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4106 && bfd_is_abs_section (sym
->section
))
4107 || !(sym
->section
->owner
== abfd
4108 || (sym
->section
->output_section
!= NULL
4109 && sym
->section
->output_section
->owner
== abfd
4110 && sym
->section
->output_offset
== 0)
4111 || bfd_is_abs_section (sym
->section
)));
4114 /* Map symbol from it's internal number to the external number, moving
4115 all local symbols to be at the head of the list. */
4118 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4120 unsigned int symcount
= bfd_get_symcount (abfd
);
4121 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4122 asymbol
**sect_syms
;
4123 unsigned int num_locals
= 0;
4124 unsigned int num_globals
= 0;
4125 unsigned int num_locals2
= 0;
4126 unsigned int num_globals2
= 0;
4127 unsigned int max_index
= 0;
4134 fprintf (stderr
, "elf_map_symbols\n");
4138 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4140 if (max_index
< asect
->index
)
4141 max_index
= asect
->index
;
4145 amt
= max_index
* sizeof (asymbol
*);
4146 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, amt
);
4147 if (sect_syms
== NULL
)
4149 elf_section_syms (abfd
) = sect_syms
;
4150 elf_num_section_syms (abfd
) = max_index
;
4152 /* Init sect_syms entries for any section symbols we have already
4153 decided to output. */
4154 for (idx
= 0; idx
< symcount
; idx
++)
4156 asymbol
*sym
= syms
[idx
];
4158 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4160 && !ignore_section_sym (abfd
, sym
)
4161 && !bfd_is_abs_section (sym
->section
))
4163 asection
*sec
= sym
->section
;
4165 if (sec
->owner
!= abfd
)
4166 sec
= sec
->output_section
;
4168 sect_syms
[sec
->index
] = syms
[idx
];
4172 /* Classify all of the symbols. */
4173 for (idx
= 0; idx
< symcount
; idx
++)
4175 if (sym_is_global (abfd
, syms
[idx
]))
4177 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4181 /* We will be adding a section symbol for each normal BFD section. Most
4182 sections will already have a section symbol in outsymbols, but
4183 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4184 at least in that case. */
4185 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4187 if (sect_syms
[asect
->index
] == NULL
)
4189 if (!sym_is_global (abfd
, asect
->symbol
))
4196 /* Now sort the symbols so the local symbols are first. */
4197 amt
= (num_locals
+ num_globals
) * sizeof (asymbol
*);
4198 new_syms
= (asymbol
**) bfd_alloc (abfd
, amt
);
4199 if (new_syms
== NULL
)
4202 for (idx
= 0; idx
< symcount
; idx
++)
4204 asymbol
*sym
= syms
[idx
];
4207 if (sym_is_global (abfd
, sym
))
4208 i
= num_locals
+ num_globals2
++;
4209 else if (!ignore_section_sym (abfd
, sym
))
4214 sym
->udata
.i
= i
+ 1;
4216 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4218 if (sect_syms
[asect
->index
] == NULL
)
4220 asymbol
*sym
= asect
->symbol
;
4223 sect_syms
[asect
->index
] = sym
;
4224 if (!sym_is_global (abfd
, sym
))
4227 i
= num_locals
+ num_globals2
++;
4229 sym
->udata
.i
= i
+ 1;
4233 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4235 *pnum_locals
= num_locals
;
4239 /* Align to the maximum file alignment that could be required for any
4240 ELF data structure. */
4242 static inline file_ptr
4243 align_file_position (file_ptr off
, int align
)
4245 return (off
+ align
- 1) & ~(align
- 1);
4248 /* Assign a file position to a section, optionally aligning to the
4249 required section alignment. */
4252 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4256 if (align
&& i_shdrp
->sh_addralign
> 1)
4257 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4258 i_shdrp
->sh_offset
= offset
;
4259 if (i_shdrp
->bfd_section
!= NULL
)
4260 i_shdrp
->bfd_section
->filepos
= offset
;
4261 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4262 offset
+= i_shdrp
->sh_size
;
4266 /* Compute the file positions we are going to put the sections at, and
4267 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4268 is not NULL, this is being called by the ELF backend linker. */
4271 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4272 struct bfd_link_info
*link_info
)
4274 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4275 struct fake_section_arg fsargs
;
4277 struct elf_strtab_hash
*strtab
= NULL
;
4278 Elf_Internal_Shdr
*shstrtab_hdr
;
4279 bfd_boolean need_symtab
;
4281 if (abfd
->output_has_begun
)
4284 /* Do any elf backend specific processing first. */
4285 if (bed
->elf_backend_begin_write_processing
)
4286 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4288 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4291 fsargs
.failed
= FALSE
;
4292 fsargs
.link_info
= link_info
;
4293 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4297 if (!assign_section_numbers (abfd
, link_info
))
4300 /* The backend linker builds symbol table information itself. */
4301 need_symtab
= (link_info
== NULL
4302 && (bfd_get_symcount (abfd
) > 0
4303 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4307 /* Non-zero if doing a relocatable link. */
4308 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4310 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
, link_info
))
4315 if (link_info
== NULL
)
4317 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4322 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4323 /* sh_name was set in init_file_header. */
4324 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4325 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4326 shstrtab_hdr
->sh_addr
= 0;
4327 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4328 shstrtab_hdr
->sh_entsize
= 0;
4329 shstrtab_hdr
->sh_link
= 0;
4330 shstrtab_hdr
->sh_info
= 0;
4331 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4332 shstrtab_hdr
->sh_addralign
= 1;
4334 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4340 Elf_Internal_Shdr
*hdr
;
4342 off
= elf_next_file_pos (abfd
);
4344 hdr
= & elf_symtab_hdr (abfd
);
4345 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4347 if (elf_symtab_shndx_list (abfd
) != NULL
)
4349 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4350 if (hdr
->sh_size
!= 0)
4351 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4352 /* FIXME: What about other symtab_shndx sections in the list ? */
4355 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4356 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4358 elf_next_file_pos (abfd
) = off
;
4360 /* Now that we know where the .strtab section goes, write it
4362 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4363 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4365 _bfd_elf_strtab_free (strtab
);
4368 abfd
->output_has_begun
= TRUE
;
4373 /* Make an initial estimate of the size of the program header. If we
4374 get the number wrong here, we'll redo section placement. */
4376 static bfd_size_type
4377 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4381 const struct elf_backend_data
*bed
;
4383 /* Assume we will need exactly two PT_LOAD segments: one for text
4384 and one for data. */
4387 s
= bfd_get_section_by_name (abfd
, ".interp");
4388 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4390 /* If we have a loadable interpreter section, we need a
4391 PT_INTERP segment. In this case, assume we also need a
4392 PT_PHDR segment, although that may not be true for all
4397 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4399 /* We need a PT_DYNAMIC segment. */
4403 if (info
!= NULL
&& info
->relro
)
4405 /* We need a PT_GNU_RELRO segment. */
4409 if (elf_eh_frame_hdr (abfd
))
4411 /* We need a PT_GNU_EH_FRAME segment. */
4415 if (elf_stack_flags (abfd
))
4417 /* We need a PT_GNU_STACK segment. */
4421 s
= bfd_get_section_by_name (abfd
,
4422 NOTE_GNU_PROPERTY_SECTION_NAME
);
4423 if (s
!= NULL
&& s
->size
!= 0)
4425 /* We need a PT_GNU_PROPERTY segment. */
4429 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4431 if ((s
->flags
& SEC_LOAD
) != 0
4432 && elf_section_type (s
) == SHT_NOTE
)
4434 unsigned int alignment_power
;
4435 /* We need a PT_NOTE segment. */
4437 /* Try to create just one PT_NOTE segment for all adjacent
4438 loadable SHT_NOTE sections. gABI requires that within a
4439 PT_NOTE segment (and also inside of each SHT_NOTE section)
4440 each note should have the same alignment. So we check
4441 whether the sections are correctly aligned. */
4442 alignment_power
= s
->alignment_power
;
4443 while (s
->next
!= NULL
4444 && s
->next
->alignment_power
== alignment_power
4445 && (s
->next
->flags
& SEC_LOAD
) != 0
4446 && elf_section_type (s
->next
) == SHT_NOTE
)
4451 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4453 if (s
->flags
& SEC_THREAD_LOCAL
)
4455 /* We need a PT_TLS segment. */
4461 bed
= get_elf_backend_data (abfd
);
4463 if ((abfd
->flags
& D_PAGED
) != 0
4464 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4466 /* Add a PT_GNU_MBIND segment for each mbind section. */
4467 unsigned int page_align_power
= bfd_log2 (bed
->commonpagesize
);
4468 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4469 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4471 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4474 /* xgettext:c-format */
4475 (_("%pB: GNU_MBIND section `%pA' has invalid "
4476 "sh_info field: %d"),
4477 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4480 /* Align mbind section to page size. */
4481 if (s
->alignment_power
< page_align_power
)
4482 s
->alignment_power
= page_align_power
;
4487 /* Let the backend count up any program headers it might need. */
4488 if (bed
->elf_backend_additional_program_headers
)
4492 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4498 return segs
* bed
->s
->sizeof_phdr
;
4501 /* Find the segment that contains the output_section of section. */
4504 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4506 struct elf_segment_map
*m
;
4507 Elf_Internal_Phdr
*p
;
4509 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4515 for (i
= m
->count
- 1; i
>= 0; i
--)
4516 if (m
->sections
[i
] == section
)
4523 /* Create a mapping from a set of sections to a program segment. */
4525 static struct elf_segment_map
*
4526 make_mapping (bfd
*abfd
,
4527 asection
**sections
,
4532 struct elf_segment_map
*m
;
4537 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4538 amt
+= (to
- from
) * sizeof (asection
*);
4539 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4543 m
->p_type
= PT_LOAD
;
4544 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4545 m
->sections
[i
- from
] = *hdrpp
;
4546 m
->count
= to
- from
;
4548 if (from
== 0 && phdr
)
4550 /* Include the headers in the first PT_LOAD segment. */
4551 m
->includes_filehdr
= 1;
4552 m
->includes_phdrs
= 1;
4558 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4561 struct elf_segment_map
*
4562 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4564 struct elf_segment_map
*m
;
4566 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4567 sizeof (struct elf_segment_map
));
4571 m
->p_type
= PT_DYNAMIC
;
4573 m
->sections
[0] = dynsec
;
4578 /* Possibly add or remove segments from the segment map. */
4581 elf_modify_segment_map (bfd
*abfd
,
4582 struct bfd_link_info
*info
,
4583 bfd_boolean remove_empty_load
)
4585 struct elf_segment_map
**m
;
4586 const struct elf_backend_data
*bed
;
4588 /* The placement algorithm assumes that non allocated sections are
4589 not in PT_LOAD segments. We ensure this here by removing such
4590 sections from the segment map. We also remove excluded
4591 sections. Finally, any PT_LOAD segment without sections is
4593 m
= &elf_seg_map (abfd
);
4596 unsigned int i
, new_count
;
4598 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4600 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4601 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4602 || (*m
)->p_type
!= PT_LOAD
))
4604 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4608 (*m
)->count
= new_count
;
4610 if (remove_empty_load
4611 && (*m
)->p_type
== PT_LOAD
4613 && !(*m
)->includes_phdrs
)
4619 bed
= get_elf_backend_data (abfd
);
4620 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4622 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4629 #define IS_TBSS(s) \
4630 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4632 /* Set up a mapping from BFD sections to program segments. */
4635 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4638 struct elf_segment_map
*m
;
4639 asection
**sections
= NULL
;
4640 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4641 bfd_boolean no_user_phdrs
;
4643 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4646 info
->user_phdrs
= !no_user_phdrs
;
4648 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4652 struct elf_segment_map
*mfirst
;
4653 struct elf_segment_map
**pm
;
4656 unsigned int hdr_index
;
4657 bfd_vma maxpagesize
;
4659 bfd_boolean phdr_in_segment
;
4660 bfd_boolean writable
;
4661 bfd_boolean executable
;
4662 unsigned int tls_count
= 0;
4663 asection
*first_tls
= NULL
;
4664 asection
*first_mbind
= NULL
;
4665 asection
*dynsec
, *eh_frame_hdr
;
4667 bfd_vma addr_mask
, wrap_to
= 0; /* Bytes. */
4668 bfd_size_type phdr_size
; /* Octets/bytes. */
4669 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
4671 /* Select the allocated sections, and sort them. */
4673 amt
= bfd_count_sections (abfd
) * sizeof (asection
*);
4674 sections
= (asection
**) bfd_malloc (amt
);
4675 if (sections
== NULL
)
4678 /* Calculate top address, avoiding undefined behaviour of shift
4679 left operator when shift count is equal to size of type
4681 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4682 addr_mask
= (addr_mask
<< 1) + 1;
4685 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4687 if ((s
->flags
& SEC_ALLOC
) != 0)
4689 /* target_index is unused until bfd_elf_final_link
4690 starts output of section symbols. Use it to make
4692 s
->target_index
= i
;
4695 /* A wrapping section potentially clashes with header. */
4696 if (((s
->lma
+ s
->size
/ opb
) & addr_mask
) < (s
->lma
& addr_mask
))
4697 wrap_to
= (s
->lma
+ s
->size
/ opb
) & addr_mask
;
4700 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4703 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4705 phdr_size
= elf_program_header_size (abfd
);
4706 if (phdr_size
== (bfd_size_type
) -1)
4707 phdr_size
= get_program_header_size (abfd
, info
);
4708 phdr_size
+= bed
->s
->sizeof_ehdr
;
4709 /* phdr_size is compared to LMA values which are in bytes. */
4711 maxpagesize
= bed
->maxpagesize
;
4712 if (maxpagesize
== 0)
4714 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4716 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4717 >= (phdr_size
& (maxpagesize
- 1))))
4718 /* For compatibility with old scripts that may not be using
4719 SIZEOF_HEADERS, add headers when it looks like space has
4720 been left for them. */
4721 phdr_in_segment
= TRUE
;
4723 /* Build the mapping. */
4727 /* If we have a .interp section, then create a PT_PHDR segment for
4728 the program headers and a PT_INTERP segment for the .interp
4730 s
= bfd_get_section_by_name (abfd
, ".interp");
4731 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4733 amt
= sizeof (struct elf_segment_map
);
4734 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4738 m
->p_type
= PT_PHDR
;
4740 m
->p_flags_valid
= 1;
4741 m
->includes_phdrs
= 1;
4742 phdr_in_segment
= TRUE
;
4746 amt
= sizeof (struct elf_segment_map
);
4747 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4751 m
->p_type
= PT_INTERP
;
4759 /* Look through the sections. We put sections in the same program
4760 segment when the start of the second section can be placed within
4761 a few bytes of the end of the first section. */
4767 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4769 && (dynsec
->flags
& SEC_LOAD
) == 0)
4772 if ((abfd
->flags
& D_PAGED
) == 0)
4773 phdr_in_segment
= FALSE
;
4775 /* Deal with -Ttext or something similar such that the first section
4776 is not adjacent to the program headers. This is an
4777 approximation, since at this point we don't know exactly how many
4778 program headers we will need. */
4779 if (phdr_in_segment
&& count
> 0)
4781 bfd_vma phdr_lma
; /* Bytes. */
4782 bfd_boolean separate_phdr
= FALSE
;
4784 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4786 && info
->separate_code
4787 && (sections
[0]->flags
& SEC_CODE
) != 0)
4789 /* If data sections should be separate from code and
4790 thus not executable, and the first section is
4791 executable then put the file and program headers in
4792 their own PT_LOAD. */
4793 separate_phdr
= TRUE
;
4794 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4795 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4797 /* The file and program headers are currently on the
4798 same page as the first section. Put them on the
4799 previous page if we can. */
4800 if (phdr_lma
>= maxpagesize
)
4801 phdr_lma
-= maxpagesize
;
4803 separate_phdr
= FALSE
;
4806 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4807 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4808 /* If file and program headers would be placed at the end
4809 of memory then it's probably better to omit them. */
4810 phdr_in_segment
= FALSE
;
4811 else if (phdr_lma
< wrap_to
)
4812 /* If a section wraps around to where we'll be placing
4813 file and program headers, then the headers will be
4815 phdr_in_segment
= FALSE
;
4816 else if (separate_phdr
)
4818 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4821 m
->p_paddr
= phdr_lma
* opb
;
4823 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4824 m
->p_paddr_valid
= 1;
4827 phdr_in_segment
= FALSE
;
4831 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4834 bfd_boolean new_segment
;
4838 /* See if this section and the last one will fit in the same
4841 if (last_hdr
== NULL
)
4843 /* If we don't have a segment yet, then we don't need a new
4844 one (we build the last one after this loop). */
4845 new_segment
= FALSE
;
4847 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4849 /* If this section has a different relation between the
4850 virtual address and the load address, then we need a new
4854 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4855 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4857 /* If this section has a load address that makes it overlap
4858 the previous section, then we need a new segment. */
4861 else if ((abfd
->flags
& D_PAGED
) != 0
4862 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4863 == (hdr
->lma
& -maxpagesize
)))
4865 /* If we are demand paged then we can't map two disk
4866 pages onto the same memory page. */
4867 new_segment
= FALSE
;
4869 /* In the next test we have to be careful when last_hdr->lma is close
4870 to the end of the address space. If the aligned address wraps
4871 around to the start of the address space, then there are no more
4872 pages left in memory and it is OK to assume that the current
4873 section can be included in the current segment. */
4874 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4875 + maxpagesize
> last_hdr
->lma
)
4876 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4877 + maxpagesize
<= hdr
->lma
))
4879 /* If putting this section in this segment would force us to
4880 skip a page in the segment, then we need a new segment. */
4883 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4884 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4886 /* We don't want to put a loaded section after a
4887 nonloaded (ie. bss style) section in the same segment
4888 as that will force the non-loaded section to be loaded.
4889 Consider .tbss sections as loaded for this purpose. */
4892 else if ((abfd
->flags
& D_PAGED
) == 0)
4894 /* If the file is not demand paged, which means that we
4895 don't require the sections to be correctly aligned in the
4896 file, then there is no other reason for a new segment. */
4897 new_segment
= FALSE
;
4899 else if (info
!= NULL
4900 && info
->separate_code
4901 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4906 && (hdr
->flags
& SEC_READONLY
) == 0)
4908 /* We don't want to put a writable section in a read only
4914 /* Otherwise, we can use the same segment. */
4915 new_segment
= FALSE
;
4918 /* Allow interested parties a chance to override our decision. */
4919 if (last_hdr
!= NULL
4921 && info
->callbacks
->override_segment_assignment
!= NULL
)
4923 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4929 if ((hdr
->flags
& SEC_READONLY
) == 0)
4931 if ((hdr
->flags
& SEC_CODE
) != 0)
4934 /* .tbss sections effectively have zero size. */
4935 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4939 /* We need a new program segment. We must create a new program
4940 header holding all the sections from hdr_index until hdr. */
4942 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4949 if ((hdr
->flags
& SEC_READONLY
) == 0)
4954 if ((hdr
->flags
& SEC_CODE
) == 0)
4960 /* .tbss sections effectively have zero size. */
4961 last_size
= (!IS_TBSS (hdr
) ? hdr
->size
: 0) / opb
;
4963 phdr_in_segment
= FALSE
;
4966 /* Create a final PT_LOAD program segment, but not if it's just
4968 if (last_hdr
!= NULL
4969 && (i
- hdr_index
!= 1
4970 || !IS_TBSS (last_hdr
)))
4972 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4980 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4983 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4990 /* For each batch of consecutive loadable SHT_NOTE sections,
4991 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4992 because if we link together nonloadable .note sections and
4993 loadable .note sections, we will generate two .note sections
4994 in the output file. */
4995 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4997 if ((s
->flags
& SEC_LOAD
) != 0
4998 && elf_section_type (s
) == SHT_NOTE
)
5001 unsigned int alignment_power
= s
->alignment_power
;
5004 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
5006 if (s2
->next
->alignment_power
== alignment_power
5007 && (s2
->next
->flags
& SEC_LOAD
) != 0
5008 && elf_section_type (s2
->next
) == SHT_NOTE
5009 && align_power (s2
->lma
+ s2
->size
/ opb
,
5016 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5017 amt
+= count
* sizeof (asection
*);
5018 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5022 m
->p_type
= PT_NOTE
;
5026 m
->sections
[m
->count
- count
--] = s
;
5027 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5030 m
->sections
[m
->count
- 1] = s
;
5031 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5035 if (s
->flags
& SEC_THREAD_LOCAL
)
5041 if (first_mbind
== NULL
5042 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5046 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5049 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5050 amt
+= tls_count
* sizeof (asection
*);
5051 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5056 m
->count
= tls_count
;
5057 /* Mandated PF_R. */
5059 m
->p_flags_valid
= 1;
5061 for (i
= 0; i
< tls_count
; ++i
)
5063 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5066 (_("%pB: TLS sections are not adjacent:"), abfd
);
5069 while (i
< tls_count
)
5071 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5073 _bfd_error_handler (_(" TLS: %pA"), s
);
5077 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5080 bfd_set_error (bfd_error_bad_value
);
5092 && (abfd
->flags
& D_PAGED
) != 0
5093 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5094 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5095 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5096 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5098 /* Mandated PF_R. */
5099 unsigned long p_flags
= PF_R
;
5100 if ((s
->flags
& SEC_READONLY
) == 0)
5102 if ((s
->flags
& SEC_CODE
) != 0)
5105 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5106 m
= bfd_zalloc (abfd
, amt
);
5110 m
->p_type
= (PT_GNU_MBIND_LO
5111 + elf_section_data (s
)->this_hdr
.sh_info
);
5113 m
->p_flags_valid
= 1;
5115 m
->p_flags
= p_flags
;
5121 s
= bfd_get_section_by_name (abfd
,
5122 NOTE_GNU_PROPERTY_SECTION_NAME
);
5123 if (s
!= NULL
&& s
->size
!= 0)
5125 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5126 m
= bfd_zalloc (abfd
, amt
);
5130 m
->p_type
= PT_GNU_PROPERTY
;
5132 m
->p_flags_valid
= 1;
5139 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5141 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5142 if (eh_frame_hdr
!= NULL
5143 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5145 amt
= sizeof (struct elf_segment_map
);
5146 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5150 m
->p_type
= PT_GNU_EH_FRAME
;
5152 m
->sections
[0] = eh_frame_hdr
->output_section
;
5158 if (elf_stack_flags (abfd
))
5160 amt
= sizeof (struct elf_segment_map
);
5161 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5165 m
->p_type
= PT_GNU_STACK
;
5166 m
->p_flags
= elf_stack_flags (abfd
);
5167 m
->p_align
= bed
->stack_align
;
5168 m
->p_flags_valid
= 1;
5169 m
->p_align_valid
= m
->p_align
!= 0;
5170 if (info
->stacksize
> 0)
5172 m
->p_size
= info
->stacksize
;
5173 m
->p_size_valid
= 1;
5180 if (info
!= NULL
&& info
->relro
)
5182 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5184 if (m
->p_type
== PT_LOAD
5186 && m
->sections
[0]->vma
>= info
->relro_start
5187 && m
->sections
[0]->vma
< info
->relro_end
)
5190 while (--i
!= (unsigned) -1)
5192 if (m
->sections
[i
]->size
> 0
5193 && (m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5194 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5198 if (i
!= (unsigned) -1)
5203 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5206 amt
= sizeof (struct elf_segment_map
);
5207 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5211 m
->p_type
= PT_GNU_RELRO
;
5218 elf_seg_map (abfd
) = mfirst
;
5221 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5224 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5226 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5235 /* Sort sections by address. */
5238 elf_sort_sections (const void *arg1
, const void *arg2
)
5240 const asection
*sec1
= *(const asection
**) arg1
;
5241 const asection
*sec2
= *(const asection
**) arg2
;
5242 bfd_size_type size1
, size2
;
5244 /* Sort by LMA first, since this is the address used to
5245 place the section into a segment. */
5246 if (sec1
->lma
< sec2
->lma
)
5248 else if (sec1
->lma
> sec2
->lma
)
5251 /* Then sort by VMA. Normally the LMA and the VMA will be
5252 the same, and this will do nothing. */
5253 if (sec1
->vma
< sec2
->vma
)
5255 else if (sec1
->vma
> sec2
->vma
)
5258 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5260 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5267 else if (TOEND (sec2
))
5272 /* Sort by size, to put zero sized sections
5273 before others at the same address. */
5275 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5276 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5283 return sec1
->target_index
- sec2
->target_index
;
5286 /* This qsort comparison functions sorts PT_LOAD segments first and
5287 by p_paddr, for assign_file_positions_for_load_sections. */
5290 elf_sort_segments (const void *arg1
, const void *arg2
)
5292 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5293 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5295 if (m1
->p_type
!= m2
->p_type
)
5297 if (m1
->p_type
== PT_NULL
)
5299 if (m2
->p_type
== PT_NULL
)
5301 return m1
->p_type
< m2
->p_type
? -1 : 1;
5303 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5304 return m1
->includes_filehdr
? -1 : 1;
5305 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5306 return m1
->no_sort_lma
? -1 : 1;
5307 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5309 bfd_vma lma1
, lma2
; /* Octets. */
5311 if (m1
->p_paddr_valid
)
5313 else if (m1
->count
!= 0)
5315 unsigned int opb
= bfd_octets_per_byte (m1
->sections
[0]->owner
,
5317 lma1
= (m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
) * opb
;
5320 if (m2
->p_paddr_valid
)
5322 else if (m2
->count
!= 0)
5324 unsigned int opb
= bfd_octets_per_byte (m2
->sections
[0]->owner
,
5326 lma2
= (m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
) * opb
;
5329 return lma1
< lma2
? -1 : 1;
5331 if (m1
->idx
!= m2
->idx
)
5332 return m1
->idx
< m2
->idx
? -1 : 1;
5336 /* Ian Lance Taylor writes:
5338 We shouldn't be using % with a negative signed number. That's just
5339 not good. We have to make sure either that the number is not
5340 negative, or that the number has an unsigned type. When the types
5341 are all the same size they wind up as unsigned. When file_ptr is a
5342 larger signed type, the arithmetic winds up as signed long long,
5345 What we're trying to say here is something like ``increase OFF by
5346 the least amount that will cause it to be equal to the VMA modulo
5348 /* In other words, something like:
5350 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5351 off_offset = off % bed->maxpagesize;
5352 if (vma_offset < off_offset)
5353 adjustment = vma_offset + bed->maxpagesize - off_offset;
5355 adjustment = vma_offset - off_offset;
5357 which can be collapsed into the expression below. */
5360 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5362 /* PR binutils/16199: Handle an alignment of zero. */
5363 if (maxpagesize
== 0)
5365 return ((vma
- off
) % maxpagesize
);
5369 print_segment_map (const struct elf_segment_map
*m
)
5372 const char *pt
= get_segment_type (m
->p_type
);
5377 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5378 sprintf (buf
, "LOPROC+%7.7x",
5379 (unsigned int) (m
->p_type
- PT_LOPROC
));
5380 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5381 sprintf (buf
, "LOOS+%7.7x",
5382 (unsigned int) (m
->p_type
- PT_LOOS
));
5384 snprintf (buf
, sizeof (buf
), "%8.8x",
5385 (unsigned int) m
->p_type
);
5389 fprintf (stderr
, "%s:", pt
);
5390 for (j
= 0; j
< m
->count
; j
++)
5391 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5397 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5402 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5404 buf
= bfd_zmalloc (len
);
5407 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5412 /* Assign file positions to the sections based on the mapping from
5413 sections to segments. This function also sets up some fields in
5417 assign_file_positions_for_load_sections (bfd
*abfd
,
5418 struct bfd_link_info
*link_info
)
5420 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5421 struct elf_segment_map
*m
;
5422 struct elf_segment_map
*phdr_load_seg
;
5423 Elf_Internal_Phdr
*phdrs
;
5424 Elf_Internal_Phdr
*p
;
5425 file_ptr off
; /* Octets. */
5426 bfd_size_type maxpagesize
;
5427 unsigned int alloc
, actual
;
5429 struct elf_segment_map
**sorted_seg_map
;
5430 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
5432 if (link_info
== NULL
5433 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5437 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5442 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5443 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5447 /* PR binutils/12467. */
5448 elf_elfheader (abfd
)->e_phoff
= 0;
5449 elf_elfheader (abfd
)->e_phentsize
= 0;
5452 elf_elfheader (abfd
)->e_phnum
= alloc
;
5454 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5457 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5461 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5462 BFD_ASSERT (elf_program_header_size (abfd
)
5463 == actual
* bed
->s
->sizeof_phdr
);
5464 BFD_ASSERT (actual
>= alloc
);
5469 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5473 /* We're writing the size in elf_program_header_size (abfd),
5474 see assign_file_positions_except_relocs, so make sure we have
5475 that amount allocated, with trailing space cleared.
5476 The variable alloc contains the computed need, while
5477 elf_program_header_size (abfd) contains the size used for the
5479 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5480 where the layout is forced to according to a larger size in the
5481 last iterations for the testcase ld-elf/header. */
5482 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5483 + alloc
* sizeof (*sorted_seg_map
)));
5484 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5485 elf_tdata (abfd
)->phdr
= phdrs
;
5489 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5491 sorted_seg_map
[j
] = m
;
5492 /* If elf_segment_map is not from map_sections_to_segments, the
5493 sections may not be correctly ordered. NOTE: sorting should
5494 not be done to the PT_NOTE section of a corefile, which may
5495 contain several pseudo-sections artificially created by bfd.
5496 Sorting these pseudo-sections breaks things badly. */
5498 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5499 && m
->p_type
== PT_NOTE
))
5501 for (i
= 0; i
< m
->count
; i
++)
5502 m
->sections
[i
]->target_index
= i
;
5503 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5508 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5512 if ((abfd
->flags
& D_PAGED
) != 0)
5513 maxpagesize
= bed
->maxpagesize
;
5515 /* Sections must map to file offsets past the ELF file header. */
5516 off
= bed
->s
->sizeof_ehdr
;
5517 /* And if one of the PT_LOAD headers doesn't include the program
5518 headers then we'll be mapping program headers in the usual
5519 position after the ELF file header. */
5520 phdr_load_seg
= NULL
;
5521 for (j
= 0; j
< alloc
; j
++)
5523 m
= sorted_seg_map
[j
];
5524 if (m
->p_type
!= PT_LOAD
)
5526 if (m
->includes_phdrs
)
5532 if (phdr_load_seg
== NULL
)
5533 off
+= actual
* bed
->s
->sizeof_phdr
;
5535 for (j
= 0; j
< alloc
; j
++)
5538 bfd_vma off_adjust
; /* Octets. */
5539 bfd_boolean no_contents
;
5541 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5542 number of sections with contents contributing to both p_filesz
5543 and p_memsz, followed by a number of sections with no contents
5544 that just contribute to p_memsz. In this loop, OFF tracks next
5545 available file offset for PT_LOAD and PT_NOTE segments. */
5546 m
= sorted_seg_map
[j
];
5548 p
->p_type
= m
->p_type
;
5549 p
->p_flags
= m
->p_flags
;
5552 p
->p_vaddr
= m
->p_vaddr_offset
* opb
;
5554 p
->p_vaddr
= (m
->sections
[0]->vma
+ m
->p_vaddr_offset
) * opb
;
5556 if (m
->p_paddr_valid
)
5557 p
->p_paddr
= m
->p_paddr
;
5558 else if (m
->count
== 0)
5561 p
->p_paddr
= (m
->sections
[0]->lma
+ m
->p_vaddr_offset
) * opb
;
5563 if (p
->p_type
== PT_LOAD
5564 && (abfd
->flags
& D_PAGED
) != 0)
5566 /* p_align in demand paged PT_LOAD segments effectively stores
5567 the maximum page size. When copying an executable with
5568 objcopy, we set m->p_align from the input file. Use this
5569 value for maxpagesize rather than bed->maxpagesize, which
5570 may be different. Note that we use maxpagesize for PT_TLS
5571 segment alignment later in this function, so we are relying
5572 on at least one PT_LOAD segment appearing before a PT_TLS
5574 if (m
->p_align_valid
)
5575 maxpagesize
= m
->p_align
;
5577 p
->p_align
= maxpagesize
;
5579 else if (m
->p_align_valid
)
5580 p
->p_align
= m
->p_align
;
5581 else if (m
->count
== 0)
5582 p
->p_align
= 1 << bed
->s
->log_file_align
;
5584 if (m
== phdr_load_seg
)
5586 if (!m
->includes_filehdr
)
5588 off
+= actual
* bed
->s
->sizeof_phdr
;
5591 no_contents
= FALSE
;
5593 if (p
->p_type
== PT_LOAD
5596 bfd_size_type align
; /* Bytes. */
5597 unsigned int align_power
= 0;
5599 if (m
->p_align_valid
)
5603 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5605 unsigned int secalign
;
5607 secalign
= bfd_section_alignment (*secpp
);
5608 if (secalign
> align_power
)
5609 align_power
= secalign
;
5611 align
= (bfd_size_type
) 1 << align_power
;
5612 if (align
< maxpagesize
)
5613 align
= maxpagesize
;
5616 for (i
= 0; i
< m
->count
; i
++)
5617 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5618 /* If we aren't making room for this section, then
5619 it must be SHT_NOBITS regardless of what we've
5620 set via struct bfd_elf_special_section. */
5621 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5623 /* Find out whether this segment contains any loadable
5626 for (i
= 0; i
< m
->count
; i
++)
5627 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5629 no_contents
= FALSE
;
5633 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
* opb
);
5635 /* Broken hardware and/or kernel require that files do not
5636 map the same page with different permissions on some hppa
5639 && (abfd
->flags
& D_PAGED
) != 0
5640 && bed
->no_page_alias
5641 && (off
& (maxpagesize
- 1)) != 0
5642 && ((off
& -maxpagesize
)
5643 == ((off
+ off_adjust
) & -maxpagesize
)))
5644 off_adjust
+= maxpagesize
;
5648 /* We shouldn't need to align the segment on disk since
5649 the segment doesn't need file space, but the gABI
5650 arguably requires the alignment and glibc ld.so
5651 checks it. So to comply with the alignment
5652 requirement but not waste file space, we adjust
5653 p_offset for just this segment. (OFF_ADJUST is
5654 subtracted from OFF later.) This may put p_offset
5655 past the end of file, but that shouldn't matter. */
5660 /* Make sure the .dynamic section is the first section in the
5661 PT_DYNAMIC segment. */
5662 else if (p
->p_type
== PT_DYNAMIC
5664 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5667 (_("%pB: The first section in the PT_DYNAMIC segment"
5668 " is not the .dynamic section"),
5670 bfd_set_error (bfd_error_bad_value
);
5673 /* Set the note section type to SHT_NOTE. */
5674 else if (p
->p_type
== PT_NOTE
)
5675 for (i
= 0; i
< m
->count
; i
++)
5676 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5678 if (m
->includes_filehdr
)
5680 if (!m
->p_flags_valid
)
5682 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5683 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5684 if (p
->p_type
== PT_LOAD
)
5688 if (p
->p_vaddr
< (bfd_vma
) off
5689 || (!m
->p_paddr_valid
5690 && p
->p_paddr
< (bfd_vma
) off
))
5693 (_("%pB: not enough room for program headers,"
5694 " try linking with -N"),
5696 bfd_set_error (bfd_error_bad_value
);
5700 if (!m
->p_paddr_valid
)
5704 else if (sorted_seg_map
[0]->includes_filehdr
)
5706 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5707 p
->p_vaddr
= filehdr
->p_vaddr
;
5708 if (!m
->p_paddr_valid
)
5709 p
->p_paddr
= filehdr
->p_paddr
;
5713 if (m
->includes_phdrs
)
5715 if (!m
->p_flags_valid
)
5717 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5718 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5719 if (!m
->includes_filehdr
)
5721 if (p
->p_type
== PT_LOAD
)
5723 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5726 p
->p_vaddr
-= off
- p
->p_offset
;
5727 if (!m
->p_paddr_valid
)
5728 p
->p_paddr
-= off
- p
->p_offset
;
5731 else if (phdr_load_seg
!= NULL
)
5733 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5734 bfd_vma phdr_off
= 0; /* Octets. */
5735 if (phdr_load_seg
->includes_filehdr
)
5736 phdr_off
= bed
->s
->sizeof_ehdr
;
5737 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5738 if (!m
->p_paddr_valid
)
5739 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5740 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5743 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5747 if (p
->p_type
== PT_LOAD
5748 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5750 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5755 /* Put meaningless p_offset for PT_LOAD segments
5756 without file contents somewhere within the first
5757 page, in an attempt to not point past EOF. */
5758 bfd_size_type align
= maxpagesize
;
5759 if (align
< p
->p_align
)
5763 p
->p_offset
= off
% align
;
5768 file_ptr adjust
; /* Octets. */
5770 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5772 p
->p_filesz
+= adjust
;
5773 p
->p_memsz
+= adjust
;
5777 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5778 maps. Set filepos for sections in PT_LOAD segments, and in
5779 core files, for sections in PT_NOTE segments.
5780 assign_file_positions_for_non_load_sections will set filepos
5781 for other sections and update p_filesz for other segments. */
5782 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5785 bfd_size_type align
;
5786 Elf_Internal_Shdr
*this_hdr
;
5789 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5790 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5792 if ((p
->p_type
== PT_LOAD
5793 || p
->p_type
== PT_TLS
)
5794 && (this_hdr
->sh_type
!= SHT_NOBITS
5795 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5796 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5797 || p
->p_type
== PT_TLS
))))
5799 bfd_vma p_start
= p
->p_paddr
; /* Octets. */
5800 bfd_vma p_end
= p_start
+ p
->p_memsz
; /* Octets. */
5801 bfd_vma s_start
= sec
->lma
* opb
; /* Octets. */
5802 bfd_vma adjust
= s_start
- p_end
; /* Octets. */
5806 || p_end
< p_start
))
5809 /* xgettext:c-format */
5810 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5811 abfd
, sec
, (uint64_t) s_start
/ opb
,
5812 (uint64_t) p_end
/ opb
);
5814 sec
->lma
= p_end
/ opb
;
5816 p
->p_memsz
+= adjust
;
5818 if (p
->p_type
== PT_LOAD
)
5820 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5823 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5825 /* We have a PROGBITS section following NOBITS ones.
5826 Allocate file space for the NOBITS section(s) and
5828 adjust
= p
->p_memsz
- p
->p_filesz
;
5829 if (!write_zeros (abfd
, off
, adjust
))
5833 /* We only adjust sh_offset in SHT_NOBITS sections
5834 as would seem proper for their address when the
5835 section is first in the segment. sh_offset
5836 doesn't really have any significance for
5837 SHT_NOBITS anyway, apart from a notional position
5838 relative to other sections. Historically we
5839 didn't bother with adjusting sh_offset and some
5840 programs depend on it not being adjusted. See
5841 pr12921 and pr25662. */
5842 if (this_hdr
->sh_type
!= SHT_NOBITS
|| i
== 0)
5845 if (this_hdr
->sh_type
== SHT_NOBITS
)
5846 off_adjust
+= adjust
;
5849 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5850 p
->p_filesz
+= adjust
;
5853 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5855 /* The section at i == 0 is the one that actually contains
5859 this_hdr
->sh_offset
= sec
->filepos
= off
;
5860 off
+= this_hdr
->sh_size
;
5861 p
->p_filesz
= this_hdr
->sh_size
;
5867 /* The rest are fake sections that shouldn't be written. */
5876 if (p
->p_type
== PT_LOAD
)
5878 this_hdr
->sh_offset
= sec
->filepos
= off
;
5879 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5880 off
+= this_hdr
->sh_size
;
5882 else if (this_hdr
->sh_type
== SHT_NOBITS
5883 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5884 && this_hdr
->sh_offset
== 0)
5886 /* This is a .tbss section that didn't get a PT_LOAD.
5887 (See _bfd_elf_map_sections_to_segments "Create a
5888 final PT_LOAD".) Set sh_offset to the value it
5889 would have if we had created a zero p_filesz and
5890 p_memsz PT_LOAD header for the section. This
5891 also makes the PT_TLS header have the same
5893 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5895 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5898 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5900 p
->p_filesz
+= this_hdr
->sh_size
;
5901 /* A load section without SHF_ALLOC is something like
5902 a note section in a PT_NOTE segment. These take
5903 file space but are not loaded into memory. */
5904 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5905 p
->p_memsz
+= this_hdr
->sh_size
;
5907 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5909 if (p
->p_type
== PT_TLS
)
5910 p
->p_memsz
+= this_hdr
->sh_size
;
5912 /* .tbss is special. It doesn't contribute to p_memsz of
5914 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5915 p
->p_memsz
+= this_hdr
->sh_size
;
5918 if (align
> p
->p_align
5919 && !m
->p_align_valid
5920 && (p
->p_type
!= PT_LOAD
5921 || (abfd
->flags
& D_PAGED
) == 0))
5925 if (!m
->p_flags_valid
)
5928 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5930 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5937 /* PR ld/20815 - Check that the program header segment, if
5938 present, will be loaded into memory. */
5939 if (p
->p_type
== PT_PHDR
5940 && phdr_load_seg
== NULL
5941 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5942 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5944 /* The fix for this error is usually to edit the linker script being
5945 used and set up the program headers manually. Either that or
5946 leave room for the headers at the start of the SECTIONS. */
5947 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5948 " by LOAD segment"),
5950 if (link_info
== NULL
)
5952 /* Arrange for the linker to exit with an error, deleting
5953 the output file unless --noinhibit-exec is given. */
5954 link_info
->callbacks
->info ("%X");
5957 /* Check that all sections are in a PT_LOAD segment.
5958 Don't check funky gdb generated core files. */
5959 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5961 bfd_boolean check_vma
= TRUE
;
5963 for (i
= 1; i
< m
->count
; i
++)
5964 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5965 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5966 ->this_hdr
), p
) != 0
5967 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5968 ->this_hdr
), p
) != 0)
5970 /* Looks like we have overlays packed into the segment. */
5975 for (i
= 0; i
< m
->count
; i
++)
5977 Elf_Internal_Shdr
*this_hdr
;
5980 sec
= m
->sections
[i
];
5981 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5982 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5983 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5986 /* xgettext:c-format */
5987 (_("%pB: section `%pA' can't be allocated in segment %d"),
5989 print_segment_map (m
);
5995 elf_next_file_pos (abfd
) = off
;
5997 if (link_info
!= NULL
5998 && phdr_load_seg
!= NULL
5999 && phdr_load_seg
->includes_filehdr
)
6001 /* There is a segment that contains both the file headers and the
6002 program headers, so provide a symbol __ehdr_start pointing there.
6003 A program can use this to examine itself robustly. */
6005 struct elf_link_hash_entry
*hash
6006 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
6007 FALSE
, FALSE
, TRUE
);
6008 /* If the symbol was referenced and not defined, define it. */
6010 && (hash
->root
.type
== bfd_link_hash_new
6011 || hash
->root
.type
== bfd_link_hash_undefined
6012 || hash
->root
.type
== bfd_link_hash_undefweak
6013 || hash
->root
.type
== bfd_link_hash_common
))
6016 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
/ opb
;
6018 if (phdr_load_seg
->count
!= 0)
6019 /* The segment contains sections, so use the first one. */
6020 s
= phdr_load_seg
->sections
[0];
6022 /* Use the first (i.e. lowest-addressed) section in any segment. */
6023 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6024 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6032 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6033 hash
->root
.u
.def
.section
= s
;
6037 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6038 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6041 hash
->root
.type
= bfd_link_hash_defined
;
6042 hash
->def_regular
= 1;
6050 /* Determine if a bfd is a debuginfo file. Unfortunately there
6051 is no defined method for detecting such files, so we have to
6052 use heuristics instead. */
6055 is_debuginfo_file (bfd
*abfd
)
6057 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6060 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6061 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6062 Elf_Internal_Shdr
**headerp
;
6064 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6066 Elf_Internal_Shdr
*header
= * headerp
;
6068 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6069 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6070 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6071 && header
->sh_type
!= SHT_NOBITS
6072 && header
->sh_type
!= SHT_NOTE
)
6079 /* Assign file positions for the other sections, except for compressed debugging
6080 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6083 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6084 struct bfd_link_info
*link_info
)
6086 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6087 Elf_Internal_Shdr
**i_shdrpp
;
6088 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6089 Elf_Internal_Phdr
*phdrs
;
6090 Elf_Internal_Phdr
*p
;
6091 struct elf_segment_map
*m
;
6093 unsigned int opb
= bfd_octets_per_byte (abfd
, NULL
);
6095 i_shdrpp
= elf_elfsections (abfd
);
6096 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6097 off
= elf_next_file_pos (abfd
);
6098 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6100 Elf_Internal_Shdr
*hdr
;
6103 if (hdr
->bfd_section
!= NULL
6104 && (hdr
->bfd_section
->filepos
!= 0
6105 || (hdr
->sh_type
== SHT_NOBITS
6106 && hdr
->contents
== NULL
)))
6107 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6108 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6110 if (hdr
->sh_size
!= 0
6111 /* PR 24717 - debuginfo files are known to be not strictly
6112 compliant with the ELF standard. In particular they often
6113 have .note.gnu.property sections that are outside of any
6114 loadable segment. This is not a problem for such files,
6115 so do not warn about them. */
6116 && ! is_debuginfo_file (abfd
))
6118 /* xgettext:c-format */
6119 (_("%pB: warning: allocated section `%s' not in segment"),
6121 (hdr
->bfd_section
== NULL
6123 : hdr
->bfd_section
->name
));
6124 /* We don't need to page align empty sections. */
6125 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6126 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6129 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6131 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6134 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6135 && hdr
->bfd_section
== NULL
)
6136 /* We don't know the offset of these sections yet: their size has
6137 not been decided. */
6138 || (hdr
->bfd_section
!= NULL
6139 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6140 || (bfd_section_is_ctf (hdr
->bfd_section
)
6141 && abfd
->is_linker_output
)))
6142 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6143 || (elf_symtab_shndx_list (abfd
) != NULL
6144 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6145 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6146 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6147 hdr
->sh_offset
= -1;
6149 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6151 elf_next_file_pos (abfd
) = off
;
6153 /* Now that we have set the section file positions, we can set up
6154 the file positions for the non PT_LOAD segments. */
6155 phdrs
= elf_tdata (abfd
)->phdr
;
6156 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6158 if (p
->p_type
== PT_GNU_RELRO
)
6160 bfd_vma start
, end
; /* Bytes. */
6163 if (link_info
!= NULL
)
6165 /* During linking the range of the RELRO segment is passed
6166 in link_info. Note that there may be padding between
6167 relro_start and the first RELRO section. */
6168 start
= link_info
->relro_start
;
6169 end
= link_info
->relro_end
;
6171 else if (m
->count
!= 0)
6173 if (!m
->p_size_valid
)
6175 start
= m
->sections
[0]->vma
;
6176 end
= start
+ m
->p_size
/ opb
;
6187 struct elf_segment_map
*lm
;
6188 const Elf_Internal_Phdr
*lp
;
6191 /* Find a LOAD segment containing a section in the RELRO
6193 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6195 lm
= lm
->next
, lp
++)
6197 if (lp
->p_type
== PT_LOAD
6199 && (lm
->sections
[lm
->count
- 1]->vma
6200 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6201 ? lm
->sections
[lm
->count
- 1]->size
/ opb
6203 && lm
->sections
[0]->vma
< end
)
6209 /* Find the section starting the RELRO segment. */
6210 for (i
= 0; i
< lm
->count
; i
++)
6212 asection
*s
= lm
->sections
[i
];
6221 p
->p_vaddr
= lm
->sections
[i
]->vma
* opb
;
6222 p
->p_paddr
= lm
->sections
[i
]->lma
* opb
;
6223 p
->p_offset
= lm
->sections
[i
]->filepos
;
6224 p
->p_memsz
= end
* opb
- p
->p_vaddr
;
6225 p
->p_filesz
= p
->p_memsz
;
6227 /* The RELRO segment typically ends a few bytes
6228 into .got.plt but other layouts are possible.
6229 In cases where the end does not match any
6230 loaded section (for instance is in file
6231 padding), trim p_filesz back to correspond to
6232 the end of loaded section contents. */
6233 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6234 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6236 /* Preserve the alignment and flags if they are
6237 valid. The gold linker generates RW/4 for
6238 the PT_GNU_RELRO section. It is better for
6239 objcopy/strip to honor these attributes
6240 otherwise gdb will choke when using separate
6242 if (!m
->p_align_valid
)
6244 if (!m
->p_flags_valid
)
6250 if (link_info
!= NULL
)
6253 memset (p
, 0, sizeof *p
);
6255 else if (p
->p_type
== PT_GNU_STACK
)
6257 if (m
->p_size_valid
)
6258 p
->p_memsz
= m
->p_size
;
6260 else if (m
->count
!= 0)
6264 if (p
->p_type
!= PT_LOAD
6265 && (p
->p_type
!= PT_NOTE
6266 || bfd_get_format (abfd
) != bfd_core
))
6268 /* A user specified segment layout may include a PHDR
6269 segment that overlaps with a LOAD segment... */
6270 if (p
->p_type
== PT_PHDR
)
6276 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6278 /* PR 17512: file: 2195325e. */
6280 (_("%pB: error: non-load segment %d includes file header "
6281 "and/or program header"),
6282 abfd
, (int) (p
- phdrs
));
6287 p
->p_offset
= m
->sections
[0]->filepos
;
6288 for (i
= m
->count
; i
-- != 0;)
6290 asection
*sect
= m
->sections
[i
];
6291 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6292 if (hdr
->sh_type
!= SHT_NOBITS
)
6294 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6306 static elf_section_list
*
6307 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6309 for (;list
!= NULL
; list
= list
->next
)
6315 /* Work out the file positions of all the sections. This is called by
6316 _bfd_elf_compute_section_file_positions. All the section sizes and
6317 VMAs must be known before this is called.
6319 Reloc sections come in two flavours: Those processed specially as
6320 "side-channel" data attached to a section to which they apply, and those that
6321 bfd doesn't process as relocations. The latter sort are stored in a normal
6322 bfd section by bfd_section_from_shdr. We don't consider the former sort
6323 here, unless they form part of the loadable image. Reloc sections not
6324 assigned here (and compressed debugging sections and CTF sections which
6325 nothing else in the file can rely upon) will be handled later by
6326 assign_file_positions_for_relocs.
6328 We also don't set the positions of the .symtab and .strtab here. */
6331 assign_file_positions_except_relocs (bfd
*abfd
,
6332 struct bfd_link_info
*link_info
)
6334 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6335 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6336 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6339 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6340 && bfd_get_format (abfd
) != bfd_core
)
6342 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6343 unsigned int num_sec
= elf_numsections (abfd
);
6344 Elf_Internal_Shdr
**hdrpp
;
6348 /* Start after the ELF header. */
6349 off
= i_ehdrp
->e_ehsize
;
6351 /* We are not creating an executable, which means that we are
6352 not creating a program header, and that the actual order of
6353 the sections in the file is unimportant. */
6354 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6356 Elf_Internal_Shdr
*hdr
;
6359 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6360 && hdr
->bfd_section
== NULL
)
6361 /* Do not assign offsets for these sections yet: we don't know
6363 || (hdr
->bfd_section
!= NULL
6364 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6365 || (bfd_section_is_ctf (hdr
->bfd_section
)
6366 && abfd
->is_linker_output
)))
6367 || i
== elf_onesymtab (abfd
)
6368 || (elf_symtab_shndx_list (abfd
) != NULL
6369 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6370 || i
== elf_strtab_sec (abfd
)
6371 || i
== elf_shstrtab_sec (abfd
))
6373 hdr
->sh_offset
= -1;
6376 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6379 elf_next_file_pos (abfd
) = off
;
6380 elf_program_header_size (abfd
) = 0;
6384 /* Assign file positions for the loaded sections based on the
6385 assignment of sections to segments. */
6386 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6389 /* And for non-load sections. */
6390 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6394 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6397 /* Write out the program headers. */
6398 alloc
= i_ehdrp
->e_phnum
;
6401 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6402 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6410 _bfd_elf_init_file_header (bfd
*abfd
,
6411 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6413 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6414 struct elf_strtab_hash
*shstrtab
;
6415 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6417 i_ehdrp
= elf_elfheader (abfd
);
6419 shstrtab
= _bfd_elf_strtab_init ();
6420 if (shstrtab
== NULL
)
6423 elf_shstrtab (abfd
) = shstrtab
;
6425 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6426 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6427 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6428 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6430 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6431 i_ehdrp
->e_ident
[EI_DATA
] =
6432 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6433 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6435 if ((abfd
->flags
& DYNAMIC
) != 0)
6436 i_ehdrp
->e_type
= ET_DYN
;
6437 else if ((abfd
->flags
& EXEC_P
) != 0)
6438 i_ehdrp
->e_type
= ET_EXEC
;
6439 else if (bfd_get_format (abfd
) == bfd_core
)
6440 i_ehdrp
->e_type
= ET_CORE
;
6442 i_ehdrp
->e_type
= ET_REL
;
6444 switch (bfd_get_arch (abfd
))
6446 case bfd_arch_unknown
:
6447 i_ehdrp
->e_machine
= EM_NONE
;
6450 /* There used to be a long list of cases here, each one setting
6451 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6452 in the corresponding bfd definition. To avoid duplication,
6453 the switch was removed. Machines that need special handling
6454 can generally do it in elf_backend_final_write_processing(),
6455 unless they need the information earlier than the final write.
6456 Such need can generally be supplied by replacing the tests for
6457 e_machine with the conditions used to determine it. */
6459 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6462 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6463 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6465 /* No program header, for now. */
6466 i_ehdrp
->e_phoff
= 0;
6467 i_ehdrp
->e_phentsize
= 0;
6468 i_ehdrp
->e_phnum
= 0;
6470 /* Each bfd section is section header entry. */
6471 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6472 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6474 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6475 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6476 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6477 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6478 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6479 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6480 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6481 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6482 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6488 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6490 FIXME: We used to have code here to sort the PT_LOAD segments into
6491 ascending order, as per the ELF spec. But this breaks some programs,
6492 including the Linux kernel. But really either the spec should be
6493 changed or the programs updated. */
6496 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6498 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6500 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6501 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6502 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6503 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6504 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6506 /* Find the lowest p_vaddr in PT_LOAD segments. */
6507 bfd_vma p_vaddr
= (bfd_vma
) -1;
6508 for (; segment
< end_segment
; segment
++)
6509 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6510 p_vaddr
= segment
->p_vaddr
;
6512 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6513 segments is non-zero. */
6515 i_ehdrp
->e_type
= ET_EXEC
;
6520 /* Assign file positions for all the reloc sections which are not part
6521 of the loadable file image, and the file position of section headers. */
6524 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6527 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6528 Elf_Internal_Shdr
*shdrp
;
6529 Elf_Internal_Ehdr
*i_ehdrp
;
6530 const struct elf_backend_data
*bed
;
6532 off
= elf_next_file_pos (abfd
);
6534 shdrpp
= elf_elfsections (abfd
);
6535 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6536 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6539 if (shdrp
->sh_offset
== -1)
6541 asection
*sec
= shdrp
->bfd_section
;
6542 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6543 || shdrp
->sh_type
== SHT_RELA
);
6544 bfd_boolean is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6547 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6549 if (!is_rel
&& !is_ctf
)
6551 const char *name
= sec
->name
;
6552 struct bfd_elf_section_data
*d
;
6554 /* Compress DWARF debug sections. */
6555 if (!bfd_compress_section (abfd
, sec
,
6559 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6560 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6562 /* If section is compressed with zlib-gnu, convert
6563 section name from .debug_* to .zdebug_*. */
6565 = convert_debug_to_zdebug (abfd
, name
);
6566 if (new_name
== NULL
)
6570 /* Add section name to section name section. */
6571 if (shdrp
->sh_name
!= (unsigned int) -1)
6574 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6576 d
= elf_section_data (sec
);
6578 /* Add reloc section name to section name section. */
6580 && !_bfd_elf_set_reloc_sh_name (abfd
,
6585 && !_bfd_elf_set_reloc_sh_name (abfd
,
6590 /* Update section size and contents. */
6591 shdrp
->sh_size
= sec
->size
;
6592 shdrp
->contents
= sec
->contents
;
6593 shdrp
->bfd_section
->contents
= NULL
;
6597 /* Update section size and contents. */
6598 shdrp
->sh_size
= sec
->size
;
6599 shdrp
->contents
= sec
->contents
;
6602 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6609 /* Place section name section after DWARF debug sections have been
6611 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6612 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6613 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6614 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6616 /* Place the section headers. */
6617 i_ehdrp
= elf_elfheader (abfd
);
6618 bed
= get_elf_backend_data (abfd
);
6619 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6620 i_ehdrp
->e_shoff
= off
;
6621 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6622 elf_next_file_pos (abfd
) = off
;
6628 _bfd_elf_write_object_contents (bfd
*abfd
)
6630 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6631 Elf_Internal_Shdr
**i_shdrp
;
6633 unsigned int count
, num_sec
;
6634 struct elf_obj_tdata
*t
;
6636 if (! abfd
->output_has_begun
6637 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6639 /* Do not rewrite ELF data when the BFD has been opened for update.
6640 abfd->output_has_begun was set to TRUE on opening, so creation of new
6641 sections, and modification of existing section sizes was restricted.
6642 This means the ELF header, program headers and section headers can't have
6644 If the contents of any sections has been modified, then those changes have
6645 already been written to the BFD. */
6646 else if (abfd
->direction
== both_direction
)
6648 BFD_ASSERT (abfd
->output_has_begun
);
6652 i_shdrp
= elf_elfsections (abfd
);
6655 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6659 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6662 /* After writing the headers, we need to write the sections too... */
6663 num_sec
= elf_numsections (abfd
);
6664 for (count
= 1; count
< num_sec
; count
++)
6666 i_shdrp
[count
]->sh_name
6667 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6668 i_shdrp
[count
]->sh_name
);
6669 if (bed
->elf_backend_section_processing
)
6670 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6672 if (i_shdrp
[count
]->contents
)
6674 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6676 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6677 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6682 /* Write out the section header names. */
6683 t
= elf_tdata (abfd
);
6684 if (elf_shstrtab (abfd
) != NULL
6685 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6686 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6689 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6692 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6695 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6696 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6697 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6703 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6705 /* Hopefully this can be done just like an object file. */
6706 return _bfd_elf_write_object_contents (abfd
);
6709 /* Given a section, search the header to find them. */
6712 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6714 const struct elf_backend_data
*bed
;
6715 unsigned int sec_index
;
6717 if (elf_section_data (asect
) != NULL
6718 && elf_section_data (asect
)->this_idx
!= 0)
6719 return elf_section_data (asect
)->this_idx
;
6721 if (bfd_is_abs_section (asect
))
6722 sec_index
= SHN_ABS
;
6723 else if (bfd_is_com_section (asect
))
6724 sec_index
= SHN_COMMON
;
6725 else if (bfd_is_und_section (asect
))
6726 sec_index
= SHN_UNDEF
;
6728 sec_index
= SHN_BAD
;
6730 bed
= get_elf_backend_data (abfd
);
6731 if (bed
->elf_backend_section_from_bfd_section
)
6733 int retval
= sec_index
;
6735 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6739 if (sec_index
== SHN_BAD
)
6740 bfd_set_error (bfd_error_nonrepresentable_section
);
6745 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6749 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6751 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6753 flagword flags
= asym_ptr
->flags
;
6755 /* When gas creates relocations against local labels, it creates its
6756 own symbol for the section, but does put the symbol into the
6757 symbol chain, so udata is 0. When the linker is generating
6758 relocatable output, this section symbol may be for one of the
6759 input sections rather than the output section. */
6760 if (asym_ptr
->udata
.i
== 0
6761 && (flags
& BSF_SECTION_SYM
)
6762 && asym_ptr
->section
)
6767 sec
= asym_ptr
->section
;
6768 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6769 sec
= sec
->output_section
;
6770 if (sec
->owner
== abfd
6771 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6772 && elf_section_syms (abfd
)[indx
] != NULL
)
6773 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6776 idx
= asym_ptr
->udata
.i
;
6780 /* This case can occur when using --strip-symbol on a symbol
6781 which is used in a relocation entry. */
6783 /* xgettext:c-format */
6784 (_("%pB: symbol `%s' required but not present"),
6785 abfd
, bfd_asymbol_name (asym_ptr
));
6786 bfd_set_error (bfd_error_no_symbols
);
6793 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6794 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6802 /* Rewrite program header information. */
6805 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6807 Elf_Internal_Ehdr
*iehdr
;
6808 struct elf_segment_map
*map
;
6809 struct elf_segment_map
*map_first
;
6810 struct elf_segment_map
**pointer_to_map
;
6811 Elf_Internal_Phdr
*segment
;
6814 unsigned int num_segments
;
6815 bfd_boolean phdr_included
= FALSE
;
6816 bfd_boolean p_paddr_valid
;
6817 bfd_vma maxpagesize
;
6818 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6819 unsigned int phdr_adjust_num
= 0;
6820 const struct elf_backend_data
*bed
;
6821 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
6823 bed
= get_elf_backend_data (ibfd
);
6824 iehdr
= elf_elfheader (ibfd
);
6827 pointer_to_map
= &map_first
;
6829 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6830 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6832 /* Returns the end address of the segment + 1. */
6833 #define SEGMENT_END(segment, start) \
6834 (start + (segment->p_memsz > segment->p_filesz \
6835 ? segment->p_memsz : segment->p_filesz))
6837 #define SECTION_SIZE(section, segment) \
6838 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6839 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6840 ? section->size : 0)
6842 /* Returns TRUE if the given section is contained within
6843 the given segment. VMA addresses are compared. */
6844 #define IS_CONTAINED_BY_VMA(section, segment, opb) \
6845 (section->vma * (opb) >= segment->p_vaddr \
6846 && (section->vma * (opb) + SECTION_SIZE (section, segment) \
6847 <= (SEGMENT_END (segment, segment->p_vaddr))))
6849 /* Returns TRUE if the given section is contained within
6850 the given segment. LMA addresses are compared. */
6851 #define IS_CONTAINED_BY_LMA(section, segment, base, opb) \
6852 (section->lma * (opb) >= base \
6853 && (section->lma + SECTION_SIZE (section, segment) / (opb) >= section->lma) \
6854 && (section->lma * (opb) + SECTION_SIZE (section, segment) \
6855 <= SEGMENT_END (segment, base)))
6857 /* Handle PT_NOTE segment. */
6858 #define IS_NOTE(p, s) \
6859 (p->p_type == PT_NOTE \
6860 && elf_section_type (s) == SHT_NOTE \
6861 && (bfd_vma) s->filepos >= p->p_offset \
6862 && ((bfd_vma) s->filepos + s->size \
6863 <= p->p_offset + p->p_filesz))
6865 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6867 #define IS_COREFILE_NOTE(p, s) \
6869 && bfd_get_format (ibfd) == bfd_core \
6873 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6874 linker, which generates a PT_INTERP section with p_vaddr and
6875 p_memsz set to 0. */
6876 #define IS_SOLARIS_PT_INTERP(p, s) \
6878 && p->p_paddr == 0 \
6879 && p->p_memsz == 0 \
6880 && p->p_filesz > 0 \
6881 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6883 && (bfd_vma) s->filepos >= p->p_offset \
6884 && ((bfd_vma) s->filepos + s->size \
6885 <= p->p_offset + p->p_filesz))
6887 /* Decide if the given section should be included in the given segment.
6888 A section will be included if:
6889 1. It is within the address space of the segment -- we use the LMA
6890 if that is set for the segment and the VMA otherwise,
6891 2. It is an allocated section or a NOTE section in a PT_NOTE
6893 3. There is an output section associated with it,
6894 4. The section has not already been allocated to a previous segment.
6895 5. PT_GNU_STACK segments do not include any sections.
6896 6. PT_TLS segment includes only SHF_TLS sections.
6897 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6898 8. PT_DYNAMIC should not contain empty sections at the beginning
6899 (with the possible exception of .dynamic). */
6900 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed, opb) \
6901 ((((segment->p_paddr \
6902 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr, opb) \
6903 : IS_CONTAINED_BY_VMA (section, segment, opb)) \
6904 && (section->flags & SEC_ALLOC) != 0) \
6905 || IS_NOTE (segment, section)) \
6906 && segment->p_type != PT_GNU_STACK \
6907 && (segment->p_type != PT_TLS \
6908 || (section->flags & SEC_THREAD_LOCAL)) \
6909 && (segment->p_type == PT_LOAD \
6910 || segment->p_type == PT_TLS \
6911 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6912 && (segment->p_type != PT_DYNAMIC \
6913 || SECTION_SIZE (section, segment) > 0 \
6914 || (segment->p_paddr \
6915 ? segment->p_paddr != section->lma * (opb) \
6916 : segment->p_vaddr != section->vma * (opb)) \
6917 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6918 && (segment->p_type != PT_LOAD || !section->segment_mark))
6920 /* If the output section of a section in the input segment is NULL,
6921 it is removed from the corresponding output segment. */
6922 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed, opb) \
6923 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed, opb) \
6924 && section->output_section != NULL)
6926 /* Returns TRUE iff seg1 starts after the end of seg2. */
6927 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6928 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6930 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6931 their VMA address ranges and their LMA address ranges overlap.
6932 It is possible to have overlapping VMA ranges without overlapping LMA
6933 ranges. RedBoot images for example can have both .data and .bss mapped
6934 to the same VMA range, but with the .data section mapped to a different
6936 #define SEGMENT_OVERLAPS(seg1, seg2) \
6937 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6938 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6939 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6940 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6942 /* Initialise the segment mark field. */
6943 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6944 section
->segment_mark
= FALSE
;
6946 /* The Solaris linker creates program headers in which all the
6947 p_paddr fields are zero. When we try to objcopy or strip such a
6948 file, we get confused. Check for this case, and if we find it
6949 don't set the p_paddr_valid fields. */
6950 p_paddr_valid
= FALSE
;
6951 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6954 if (segment
->p_paddr
!= 0)
6956 p_paddr_valid
= TRUE
;
6960 /* Scan through the segments specified in the program header
6961 of the input BFD. For this first scan we look for overlaps
6962 in the loadable segments. These can be created by weird
6963 parameters to objcopy. Also, fix some solaris weirdness. */
6964 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6969 Elf_Internal_Phdr
*segment2
;
6971 if (segment
->p_type
== PT_INTERP
)
6972 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6973 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6975 /* Mininal change so that the normal section to segment
6976 assignment code will work. */
6977 segment
->p_vaddr
= section
->vma
* opb
;
6981 if (segment
->p_type
!= PT_LOAD
)
6983 /* Remove PT_GNU_RELRO segment. */
6984 if (segment
->p_type
== PT_GNU_RELRO
)
6985 segment
->p_type
= PT_NULL
;
6989 /* Determine if this segment overlaps any previous segments. */
6990 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6992 bfd_signed_vma extra_length
;
6994 if (segment2
->p_type
!= PT_LOAD
6995 || !SEGMENT_OVERLAPS (segment
, segment2
))
6998 /* Merge the two segments together. */
6999 if (segment2
->p_vaddr
< segment
->p_vaddr
)
7001 /* Extend SEGMENT2 to include SEGMENT and then delete
7003 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
7004 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
7006 if (extra_length
> 0)
7008 segment2
->p_memsz
+= extra_length
;
7009 segment2
->p_filesz
+= extra_length
;
7012 segment
->p_type
= PT_NULL
;
7014 /* Since we have deleted P we must restart the outer loop. */
7016 segment
= elf_tdata (ibfd
)->phdr
;
7021 /* Extend SEGMENT to include SEGMENT2 and then delete
7023 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7024 - SEGMENT_END (segment
, segment
->p_vaddr
));
7026 if (extra_length
> 0)
7028 segment
->p_memsz
+= extra_length
;
7029 segment
->p_filesz
+= extra_length
;
7032 segment2
->p_type
= PT_NULL
;
7037 /* The second scan attempts to assign sections to segments. */
7038 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7042 unsigned int section_count
;
7043 asection
**sections
;
7044 asection
*output_section
;
7046 asection
*matching_lma
;
7047 asection
*suggested_lma
;
7050 asection
*first_section
;
7052 if (segment
->p_type
== PT_NULL
)
7055 first_section
= NULL
;
7056 /* Compute how many sections might be placed into this segment. */
7057 for (section
= ibfd
->sections
, section_count
= 0;
7059 section
= section
->next
)
7061 /* Find the first section in the input segment, which may be
7062 removed from the corresponding output segment. */
7063 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
, opb
))
7065 if (first_section
== NULL
)
7066 first_section
= section
;
7067 if (section
->output_section
!= NULL
)
7072 /* Allocate a segment map big enough to contain
7073 all of the sections we have selected. */
7074 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7075 amt
+= section_count
* sizeof (asection
*);
7076 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7080 /* Initialise the fields of the segment map. Default to
7081 using the physical address of the segment in the input BFD. */
7083 map
->p_type
= segment
->p_type
;
7084 map
->p_flags
= segment
->p_flags
;
7085 map
->p_flags_valid
= 1;
7087 /* If the first section in the input segment is removed, there is
7088 no need to preserve segment physical address in the corresponding
7090 if (!first_section
|| first_section
->output_section
!= NULL
)
7092 map
->p_paddr
= segment
->p_paddr
;
7093 map
->p_paddr_valid
= p_paddr_valid
;
7096 /* Determine if this segment contains the ELF file header
7097 and if it contains the program headers themselves. */
7098 map
->includes_filehdr
= (segment
->p_offset
== 0
7099 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7100 map
->includes_phdrs
= 0;
7102 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7104 map
->includes_phdrs
=
7105 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7106 && (segment
->p_offset
+ segment
->p_filesz
7107 >= ((bfd_vma
) iehdr
->e_phoff
7108 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7110 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7111 phdr_included
= TRUE
;
7114 if (section_count
== 0)
7116 /* Special segments, such as the PT_PHDR segment, may contain
7117 no sections, but ordinary, loadable segments should contain
7118 something. They are allowed by the ELF spec however, so only
7119 a warning is produced.
7120 There is however the valid use case of embedded systems which
7121 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7122 flash memory with zeros. No warning is shown for that case. */
7123 if (segment
->p_type
== PT_LOAD
7124 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7125 /* xgettext:c-format */
7127 (_("%pB: warning: empty loadable segment detected"
7128 " at vaddr=%#" PRIx64
", is this intentional?"),
7129 ibfd
, (uint64_t) segment
->p_vaddr
);
7131 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7133 *pointer_to_map
= map
;
7134 pointer_to_map
= &map
->next
;
7139 /* Now scan the sections in the input BFD again and attempt
7140 to add their corresponding output sections to the segment map.
7141 The problem here is how to handle an output section which has
7142 been moved (ie had its LMA changed). There are four possibilities:
7144 1. None of the sections have been moved.
7145 In this case we can continue to use the segment LMA from the
7148 2. All of the sections have been moved by the same amount.
7149 In this case we can change the segment's LMA to match the LMA
7150 of the first section.
7152 3. Some of the sections have been moved, others have not.
7153 In this case those sections which have not been moved can be
7154 placed in the current segment which will have to have its size,
7155 and possibly its LMA changed, and a new segment or segments will
7156 have to be created to contain the other sections.
7158 4. The sections have been moved, but not by the same amount.
7159 In this case we can change the segment's LMA to match the LMA
7160 of the first section and we will have to create a new segment
7161 or segments to contain the other sections.
7163 In order to save time, we allocate an array to hold the section
7164 pointers that we are interested in. As these sections get assigned
7165 to a segment, they are removed from this array. */
7167 amt
= section_count
* sizeof (asection
*);
7168 sections
= (asection
**) bfd_malloc (amt
);
7169 if (sections
== NULL
)
7172 /* Step One: Scan for segment vs section LMA conflicts.
7173 Also add the sections to the section array allocated above.
7174 Also add the sections to the current segment. In the common
7175 case, where the sections have not been moved, this means that
7176 we have completely filled the segment, and there is nothing
7179 matching_lma
= NULL
;
7180 suggested_lma
= NULL
;
7182 for (section
= first_section
, j
= 0;
7184 section
= section
->next
)
7186 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
, opb
))
7188 output_section
= section
->output_section
;
7190 sections
[j
++] = section
;
7192 /* The Solaris native linker always sets p_paddr to 0.
7193 We try to catch that case here, and set it to the
7194 correct value. Note - some backends require that
7195 p_paddr be left as zero. */
7197 && segment
->p_vaddr
!= 0
7198 && !bed
->want_p_paddr_set_to_zero
7200 && output_section
->lma
!= 0
7201 && (align_power (segment
->p_vaddr
7202 + (map
->includes_filehdr
7203 ? iehdr
->e_ehsize
: 0)
7204 + (map
->includes_phdrs
7205 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7207 output_section
->alignment_power
* opb
)
7208 == (output_section
->vma
* opb
)))
7209 map
->p_paddr
= segment
->p_vaddr
;
7211 /* Match up the physical address of the segment with the
7212 LMA address of the output section. */
7213 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7215 || IS_COREFILE_NOTE (segment
, section
)
7216 || (bed
->want_p_paddr_set_to_zero
7217 && IS_CONTAINED_BY_VMA (output_section
, segment
, opb
)))
7219 if (matching_lma
== NULL
7220 || output_section
->lma
< matching_lma
->lma
)
7221 matching_lma
= output_section
;
7223 /* We assume that if the section fits within the segment
7224 then it does not overlap any other section within that
7226 map
->sections
[isec
++] = output_section
;
7228 else if (suggested_lma
== NULL
)
7229 suggested_lma
= output_section
;
7231 if (j
== section_count
)
7236 BFD_ASSERT (j
== section_count
);
7238 /* Step Two: Adjust the physical address of the current segment,
7240 if (isec
== section_count
)
7242 /* All of the sections fitted within the segment as currently
7243 specified. This is the default case. Add the segment to
7244 the list of built segments and carry on to process the next
7245 program header in the input BFD. */
7246 map
->count
= section_count
;
7247 *pointer_to_map
= map
;
7248 pointer_to_map
= &map
->next
;
7251 && !bed
->want_p_paddr_set_to_zero
)
7253 bfd_vma hdr_size
= 0;
7254 if (map
->includes_filehdr
)
7255 hdr_size
= iehdr
->e_ehsize
;
7256 if (map
->includes_phdrs
)
7257 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7259 /* Account for padding before the first section in the
7261 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7262 - matching_lma
->lma
);
7270 /* Change the current segment's physical address to match
7271 the LMA of the first section that fitted, or if no
7272 section fitted, the first section. */
7273 if (matching_lma
== NULL
)
7274 matching_lma
= suggested_lma
;
7276 map
->p_paddr
= matching_lma
->lma
* opb
;
7278 /* Offset the segment physical address from the lma
7279 to allow for space taken up by elf headers. */
7280 if (map
->includes_phdrs
)
7282 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7284 /* iehdr->e_phnum is just an estimate of the number
7285 of program headers that we will need. Make a note
7286 here of the number we used and the segment we chose
7287 to hold these headers, so that we can adjust the
7288 offset when we know the correct value. */
7289 phdr_adjust_num
= iehdr
->e_phnum
;
7290 phdr_adjust_seg
= map
;
7293 if (map
->includes_filehdr
)
7295 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7296 map
->p_paddr
-= iehdr
->e_ehsize
;
7297 /* We've subtracted off the size of headers from the
7298 first section lma, but there may have been some
7299 alignment padding before that section too. Try to
7300 account for that by adjusting the segment lma down to
7301 the same alignment. */
7302 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7303 align
= segment
->p_align
;
7304 map
->p_paddr
&= -(align
* opb
);
7308 /* Step Three: Loop over the sections again, this time assigning
7309 those that fit to the current segment and removing them from the
7310 sections array; but making sure not to leave large gaps. Once all
7311 possible sections have been assigned to the current segment it is
7312 added to the list of built segments and if sections still remain
7313 to be assigned, a new segment is constructed before repeating
7319 suggested_lma
= NULL
;
7321 /* Fill the current segment with sections that fit. */
7322 for (j
= 0; j
< section_count
; j
++)
7324 section
= sections
[j
];
7326 if (section
== NULL
)
7329 output_section
= section
->output_section
;
7331 BFD_ASSERT (output_section
!= NULL
);
7333 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
,
7335 || IS_COREFILE_NOTE (segment
, section
))
7337 if (map
->count
== 0)
7339 /* If the first section in a segment does not start at
7340 the beginning of the segment, then something is
7342 if (align_power (map
->p_paddr
7343 + (map
->includes_filehdr
7344 ? iehdr
->e_ehsize
: 0)
7345 + (map
->includes_phdrs
7346 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7348 output_section
->alignment_power
* opb
)
7349 != output_section
->lma
* opb
)
7356 prev_sec
= map
->sections
[map
->count
- 1];
7358 /* If the gap between the end of the previous section
7359 and the start of this section is more than
7360 maxpagesize then we need to start a new segment. */
7361 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7363 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7364 || (prev_sec
->lma
+ prev_sec
->size
7365 > output_section
->lma
))
7367 if (suggested_lma
== NULL
)
7368 suggested_lma
= output_section
;
7374 map
->sections
[map
->count
++] = output_section
;
7377 if (segment
->p_type
== PT_LOAD
)
7378 section
->segment_mark
= TRUE
;
7380 else if (suggested_lma
== NULL
)
7381 suggested_lma
= output_section
;
7384 /* PR 23932. A corrupt input file may contain sections that cannot
7385 be assigned to any segment - because for example they have a
7386 negative size - or segments that do not contain any sections.
7387 But there are also valid reasons why a segment can be empty.
7388 So allow a count of zero. */
7390 /* Add the current segment to the list of built segments. */
7391 *pointer_to_map
= map
;
7392 pointer_to_map
= &map
->next
;
7394 if (isec
< section_count
)
7396 /* We still have not allocated all of the sections to
7397 segments. Create a new segment here, initialise it
7398 and carry on looping. */
7399 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7400 amt
+= section_count
* sizeof (asection
*);
7401 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7408 /* Initialise the fields of the segment map. Set the physical
7409 physical address to the LMA of the first section that has
7410 not yet been assigned. */
7412 map
->p_type
= segment
->p_type
;
7413 map
->p_flags
= segment
->p_flags
;
7414 map
->p_flags_valid
= 1;
7415 map
->p_paddr
= suggested_lma
->lma
* opb
;
7416 map
->p_paddr_valid
= p_paddr_valid
;
7417 map
->includes_filehdr
= 0;
7418 map
->includes_phdrs
= 0;
7423 bfd_set_error (bfd_error_sorry
);
7427 while (isec
< section_count
);
7432 elf_seg_map (obfd
) = map_first
;
7434 /* If we had to estimate the number of program headers that were
7435 going to be needed, then check our estimate now and adjust
7436 the offset if necessary. */
7437 if (phdr_adjust_seg
!= NULL
)
7441 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7444 if (count
> phdr_adjust_num
)
7445 phdr_adjust_seg
->p_paddr
7446 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7448 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7449 if (map
->p_type
== PT_PHDR
)
7452 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7453 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7460 #undef IS_CONTAINED_BY_VMA
7461 #undef IS_CONTAINED_BY_LMA
7463 #undef IS_COREFILE_NOTE
7464 #undef IS_SOLARIS_PT_INTERP
7465 #undef IS_SECTION_IN_INPUT_SEGMENT
7466 #undef INCLUDE_SECTION_IN_SEGMENT
7467 #undef SEGMENT_AFTER_SEGMENT
7468 #undef SEGMENT_OVERLAPS
7472 /* Copy ELF program header information. */
7475 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7477 Elf_Internal_Ehdr
*iehdr
;
7478 struct elf_segment_map
*map
;
7479 struct elf_segment_map
*map_first
;
7480 struct elf_segment_map
**pointer_to_map
;
7481 Elf_Internal_Phdr
*segment
;
7483 unsigned int num_segments
;
7484 bfd_boolean phdr_included
= FALSE
;
7485 bfd_boolean p_paddr_valid
;
7486 unsigned int opb
= bfd_octets_per_byte (ibfd
, NULL
);
7488 iehdr
= elf_elfheader (ibfd
);
7491 pointer_to_map
= &map_first
;
7493 /* If all the segment p_paddr fields are zero, don't set
7494 map->p_paddr_valid. */
7495 p_paddr_valid
= FALSE
;
7496 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7497 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7500 if (segment
->p_paddr
!= 0)
7502 p_paddr_valid
= TRUE
;
7506 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7511 unsigned int section_count
;
7513 Elf_Internal_Shdr
*this_hdr
;
7514 asection
*first_section
= NULL
;
7515 asection
*lowest_section
;
7517 /* Compute how many sections are in this segment. */
7518 for (section
= ibfd
->sections
, section_count
= 0;
7520 section
= section
->next
)
7522 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7523 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7525 if (first_section
== NULL
)
7526 first_section
= section
;
7531 /* Allocate a segment map big enough to contain
7532 all of the sections we have selected. */
7533 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7534 amt
+= section_count
* sizeof (asection
*);
7535 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7539 /* Initialize the fields of the output segment map with the
7542 map
->p_type
= segment
->p_type
;
7543 map
->p_flags
= segment
->p_flags
;
7544 map
->p_flags_valid
= 1;
7545 map
->p_paddr
= segment
->p_paddr
;
7546 map
->p_paddr_valid
= p_paddr_valid
;
7547 map
->p_align
= segment
->p_align
;
7548 map
->p_align_valid
= 1;
7549 map
->p_vaddr_offset
= 0;
7551 if (map
->p_type
== PT_GNU_RELRO
7552 || map
->p_type
== PT_GNU_STACK
)
7554 /* The PT_GNU_RELRO segment may contain the first a few
7555 bytes in the .got.plt section even if the whole .got.plt
7556 section isn't in the PT_GNU_RELRO segment. We won't
7557 change the size of the PT_GNU_RELRO segment.
7558 Similarly, PT_GNU_STACK size is significant on uclinux
7560 map
->p_size
= segment
->p_memsz
;
7561 map
->p_size_valid
= 1;
7564 /* Determine if this segment contains the ELF file header
7565 and if it contains the program headers themselves. */
7566 map
->includes_filehdr
= (segment
->p_offset
== 0
7567 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7569 map
->includes_phdrs
= 0;
7570 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7572 map
->includes_phdrs
=
7573 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7574 && (segment
->p_offset
+ segment
->p_filesz
7575 >= ((bfd_vma
) iehdr
->e_phoff
7576 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7578 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7579 phdr_included
= TRUE
;
7582 lowest_section
= NULL
;
7583 if (section_count
!= 0)
7585 unsigned int isec
= 0;
7587 for (section
= first_section
;
7589 section
= section
->next
)
7591 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7592 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7594 map
->sections
[isec
++] = section
->output_section
;
7595 if ((section
->flags
& SEC_ALLOC
) != 0)
7599 if (lowest_section
== NULL
7600 || section
->lma
< lowest_section
->lma
)
7601 lowest_section
= section
;
7603 /* Section lmas are set up from PT_LOAD header
7604 p_paddr in _bfd_elf_make_section_from_shdr.
7605 If this header has a p_paddr that disagrees
7606 with the section lma, flag the p_paddr as
7608 if ((section
->flags
& SEC_LOAD
) != 0)
7609 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7611 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7612 if (section
->lma
* opb
- segment
->p_paddr
!= seg_off
)
7613 map
->p_paddr_valid
= FALSE
;
7615 if (isec
== section_count
)
7621 if (section_count
== 0)
7622 map
->p_vaddr_offset
= segment
->p_vaddr
/ opb
;
7623 else if (map
->p_paddr_valid
)
7625 /* Account for padding before the first section in the segment. */
7626 bfd_vma hdr_size
= 0;
7627 if (map
->includes_filehdr
)
7628 hdr_size
= iehdr
->e_ehsize
;
7629 if (map
->includes_phdrs
)
7630 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7632 map
->p_vaddr_offset
= ((map
->p_paddr
+ hdr_size
) / opb
7633 - (lowest_section
? lowest_section
->lma
: 0));
7636 map
->count
= section_count
;
7637 *pointer_to_map
= map
;
7638 pointer_to_map
= &map
->next
;
7641 elf_seg_map (obfd
) = map_first
;
7645 /* Copy private BFD data. This copies or rewrites ELF program header
7649 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7651 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7652 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7655 if (elf_tdata (ibfd
)->phdr
== NULL
)
7658 if (ibfd
->xvec
== obfd
->xvec
)
7660 /* Check to see if any sections in the input BFD
7661 covered by ELF program header have changed. */
7662 Elf_Internal_Phdr
*segment
;
7663 asection
*section
, *osec
;
7664 unsigned int i
, num_segments
;
7665 Elf_Internal_Shdr
*this_hdr
;
7666 const struct elf_backend_data
*bed
;
7668 bed
= get_elf_backend_data (ibfd
);
7670 /* Regenerate the segment map if p_paddr is set to 0. */
7671 if (bed
->want_p_paddr_set_to_zero
)
7674 /* Initialize the segment mark field. */
7675 for (section
= obfd
->sections
; section
!= NULL
;
7676 section
= section
->next
)
7677 section
->segment_mark
= FALSE
;
7679 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7680 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7684 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7685 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7686 which severly confuses things, so always regenerate the segment
7687 map in this case. */
7688 if (segment
->p_paddr
== 0
7689 && segment
->p_memsz
== 0
7690 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7693 for (section
= ibfd
->sections
;
7694 section
!= NULL
; section
= section
->next
)
7696 /* We mark the output section so that we know it comes
7697 from the input BFD. */
7698 osec
= section
->output_section
;
7700 osec
->segment_mark
= TRUE
;
7702 /* Check if this section is covered by the segment. */
7703 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7704 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7706 /* FIXME: Check if its output section is changed or
7707 removed. What else do we need to check? */
7709 || section
->flags
!= osec
->flags
7710 || section
->lma
!= osec
->lma
7711 || section
->vma
!= osec
->vma
7712 || section
->size
!= osec
->size
7713 || section
->rawsize
!= osec
->rawsize
7714 || section
->alignment_power
!= osec
->alignment_power
)
7720 /* Check to see if any output section do not come from the
7722 for (section
= obfd
->sections
; section
!= NULL
;
7723 section
= section
->next
)
7725 if (!section
->segment_mark
)
7728 section
->segment_mark
= FALSE
;
7731 return copy_elf_program_header (ibfd
, obfd
);
7735 if (ibfd
->xvec
== obfd
->xvec
)
7737 /* When rewriting program header, set the output maxpagesize to
7738 the maximum alignment of input PT_LOAD segments. */
7739 Elf_Internal_Phdr
*segment
;
7741 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7742 bfd_vma maxpagesize
= 0;
7744 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7747 if (segment
->p_type
== PT_LOAD
7748 && maxpagesize
< segment
->p_align
)
7750 /* PR 17512: file: f17299af. */
7751 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7752 /* xgettext:c-format */
7753 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7754 PRIx64
" is too large"),
7755 ibfd
, (uint64_t) segment
->p_align
);
7757 maxpagesize
= segment
->p_align
;
7760 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7761 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7764 return rewrite_elf_program_header (ibfd
, obfd
);
7767 /* Initialize private output section information from input section. */
7770 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7774 struct bfd_link_info
*link_info
)
7777 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7778 bfd_boolean final_link
= (link_info
!= NULL
7779 && !bfd_link_relocatable (link_info
));
7781 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7782 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7785 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7787 /* If this is a known ABI section, ELF section type and flags may
7788 have been set up when OSEC was created. For normal sections we
7789 allow the user to override the type and flags other than
7790 SHF_MASKOS and SHF_MASKPROC. */
7791 if (elf_section_type (osec
) == SHT_PROGBITS
7792 || elf_section_type (osec
) == SHT_NOTE
7793 || elf_section_type (osec
) == SHT_NOBITS
)
7794 elf_section_type (osec
) = SHT_NULL
;
7795 /* For objcopy and relocatable link, copy the ELF section type from
7796 the input file if the BFD section flags are the same. (If they
7797 are different the user may be doing something like
7798 "objcopy --set-section-flags .text=alloc,data".) For a final
7799 link allow some flags that the linker clears to differ. */
7800 if (elf_section_type (osec
) == SHT_NULL
7801 && (osec
->flags
== isec
->flags
7803 && ((osec
->flags
^ isec
->flags
)
7804 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7805 elf_section_type (osec
) = elf_section_type (isec
);
7807 /* FIXME: Is this correct for all OS/PROC specific flags? */
7808 elf_section_flags (osec
) = (elf_section_flags (isec
)
7809 & (SHF_MASKOS
| SHF_MASKPROC
));
7811 /* Copy sh_info from input for mbind section. */
7812 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7813 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7814 elf_section_data (osec
)->this_hdr
.sh_info
7815 = elf_section_data (isec
)->this_hdr
.sh_info
;
7817 /* Set things up for objcopy and relocatable link. The output
7818 SHT_GROUP section will have its elf_next_in_group pointing back
7819 to the input group members. Ignore linker created group section.
7820 See elfNN_ia64_object_p in elfxx-ia64.c. */
7821 if ((link_info
== NULL
7822 || !link_info
->resolve_section_groups
)
7823 && (elf_sec_group (isec
) == NULL
7824 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7826 if (elf_section_flags (isec
) & SHF_GROUP
)
7827 elf_section_flags (osec
) |= SHF_GROUP
;
7828 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7829 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7832 /* If not decompress, preserve SHF_COMPRESSED. */
7833 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7834 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7837 ihdr
= &elf_section_data (isec
)->this_hdr
;
7839 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7840 don't use the output section of the linked-to section since it
7841 may be NULL at this point. */
7842 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7844 ohdr
= &elf_section_data (osec
)->this_hdr
;
7845 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7846 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7849 osec
->use_rela_p
= isec
->use_rela_p
;
7854 /* Copy private section information. This copies over the entsize
7855 field, and sometimes the info field. */
7858 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7863 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7865 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7866 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7869 ihdr
= &elf_section_data (isec
)->this_hdr
;
7870 ohdr
= &elf_section_data (osec
)->this_hdr
;
7872 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7874 if (ihdr
->sh_type
== SHT_SYMTAB
7875 || ihdr
->sh_type
== SHT_DYNSYM
7876 || ihdr
->sh_type
== SHT_GNU_verneed
7877 || ihdr
->sh_type
== SHT_GNU_verdef
)
7878 ohdr
->sh_info
= ihdr
->sh_info
;
7880 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7884 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7885 necessary if we are removing either the SHT_GROUP section or any of
7886 the group member sections. DISCARDED is the value that a section's
7887 output_section has if the section will be discarded, NULL when this
7888 function is called from objcopy, bfd_abs_section_ptr when called
7892 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7896 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7897 if (elf_section_type (isec
) == SHT_GROUP
)
7899 asection
*first
= elf_next_in_group (isec
);
7900 asection
*s
= first
;
7901 bfd_size_type removed
= 0;
7905 /* If this member section is being output but the
7906 SHT_GROUP section is not, then clear the group info
7907 set up by _bfd_elf_copy_private_section_data. */
7908 if (s
->output_section
!= discarded
7909 && isec
->output_section
== discarded
)
7911 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7912 elf_group_name (s
->output_section
) = NULL
;
7916 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7917 if (s
->output_section
== discarded
7918 && isec
->output_section
!= discarded
)
7920 /* Conversely, if the member section is not being
7921 output but the SHT_GROUP section is, then adjust
7924 if (elf_sec
->rel
.hdr
!= NULL
7925 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7927 if (elf_sec
->rela
.hdr
!= NULL
7928 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7933 /* Also adjust for zero-sized relocation member
7935 if (elf_sec
->rel
.hdr
!= NULL
7936 && elf_sec
->rel
.hdr
->sh_size
== 0)
7938 if (elf_sec
->rela
.hdr
!= NULL
7939 && elf_sec
->rela
.hdr
->sh_size
== 0)
7943 s
= elf_next_in_group (s
);
7949 if (discarded
!= NULL
)
7951 /* If we've been called for ld -r, then we need to
7952 adjust the input section size. */
7953 if (isec
->rawsize
== 0)
7954 isec
->rawsize
= isec
->size
;
7955 isec
->size
= isec
->rawsize
- removed
;
7956 if (isec
->size
<= 4)
7959 isec
->flags
|= SEC_EXCLUDE
;
7964 /* Adjust the output section size when called from
7966 isec
->output_section
->size
-= removed
;
7967 if (isec
->output_section
->size
<= 4)
7969 isec
->output_section
->size
= 0;
7970 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7979 /* Copy private header information. */
7982 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7984 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7985 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7988 /* Copy over private BFD data if it has not already been copied.
7989 This must be done here, rather than in the copy_private_bfd_data
7990 entry point, because the latter is called after the section
7991 contents have been set, which means that the program headers have
7992 already been worked out. */
7993 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7995 if (! copy_private_bfd_data (ibfd
, obfd
))
7999 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
8002 /* Copy private symbol information. If this symbol is in a section
8003 which we did not map into a BFD section, try to map the section
8004 index correctly. We use special macro definitions for the mapped
8005 section indices; these definitions are interpreted by the
8006 swap_out_syms function. */
8008 #define MAP_ONESYMTAB (SHN_HIOS + 1)
8009 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
8010 #define MAP_STRTAB (SHN_HIOS + 3)
8011 #define MAP_SHSTRTAB (SHN_HIOS + 4)
8012 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
8015 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
8020 elf_symbol_type
*isym
, *osym
;
8022 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
8023 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
8026 isym
= elf_symbol_from (isymarg
);
8027 osym
= elf_symbol_from (osymarg
);
8030 && isym
->internal_elf_sym
.st_shndx
!= 0
8032 && bfd_is_abs_section (isym
->symbol
.section
))
8036 shndx
= isym
->internal_elf_sym
.st_shndx
;
8037 if (shndx
== elf_onesymtab (ibfd
))
8038 shndx
= MAP_ONESYMTAB
;
8039 else if (shndx
== elf_dynsymtab (ibfd
))
8040 shndx
= MAP_DYNSYMTAB
;
8041 else if (shndx
== elf_strtab_sec (ibfd
))
8043 else if (shndx
== elf_shstrtab_sec (ibfd
))
8044 shndx
= MAP_SHSTRTAB
;
8045 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
8046 shndx
= MAP_SYM_SHNDX
;
8047 osym
->internal_elf_sym
.st_shndx
= shndx
;
8053 /* Swap out the symbols. */
8056 swap_out_syms (bfd
*abfd
,
8057 struct elf_strtab_hash
**sttp
,
8059 struct bfd_link_info
*info
)
8061 const struct elf_backend_data
*bed
;
8062 unsigned int symcount
;
8064 struct elf_strtab_hash
*stt
;
8065 Elf_Internal_Shdr
*symtab_hdr
;
8066 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8067 Elf_Internal_Shdr
*symstrtab_hdr
;
8068 struct elf_sym_strtab
*symstrtab
;
8069 bfd_byte
*outbound_syms
;
8070 bfd_byte
*outbound_shndx
;
8071 unsigned long outbound_syms_index
;
8072 unsigned long outbound_shndx_index
;
8074 unsigned int num_locals
;
8076 bfd_boolean name_local_sections
;
8078 if (!elf_map_symbols (abfd
, &num_locals
))
8081 /* Dump out the symtabs. */
8082 stt
= _bfd_elf_strtab_init ();
8086 bed
= get_elf_backend_data (abfd
);
8087 symcount
= bfd_get_symcount (abfd
);
8088 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8089 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8090 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8091 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8092 symtab_hdr
->sh_info
= num_locals
+ 1;
8093 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8095 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8096 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8098 /* Allocate buffer to swap out the .strtab section. */
8099 if (_bfd_mul_overflow (symcount
+ 1, sizeof (*symstrtab
), &amt
)
8100 || (symstrtab
= (struct elf_sym_strtab
*) bfd_malloc (amt
)) == NULL
)
8102 bfd_set_error (bfd_error_no_memory
);
8103 _bfd_elf_strtab_free (stt
);
8107 if (_bfd_mul_overflow (symcount
+ 1, bed
->s
->sizeof_sym
, &amt
)
8108 || (outbound_syms
= (bfd_byte
*) bfd_alloc (abfd
, amt
)) == NULL
)
8111 bfd_set_error (bfd_error_no_memory
);
8114 _bfd_elf_strtab_free (stt
);
8117 symtab_hdr
->contents
= outbound_syms
;
8118 outbound_syms_index
= 0;
8120 outbound_shndx
= NULL
;
8121 outbound_shndx_index
= 0;
8123 if (elf_symtab_shndx_list (abfd
))
8125 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8126 if (symtab_shndx_hdr
->sh_name
!= 0)
8128 if (_bfd_mul_overflow (symcount
+ 1,
8129 sizeof (Elf_External_Sym_Shndx
), &amt
))
8131 outbound_shndx
= (bfd_byte
*) bfd_zalloc (abfd
, amt
);
8132 if (outbound_shndx
== NULL
)
8135 symtab_shndx_hdr
->contents
= outbound_shndx
;
8136 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8137 symtab_shndx_hdr
->sh_size
= amt
;
8138 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8139 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8141 /* FIXME: What about any other headers in the list ? */
8144 /* Now generate the data (for "contents"). */
8146 /* Fill in zeroth symbol and swap it out. */
8147 Elf_Internal_Sym sym
;
8153 sym
.st_shndx
= SHN_UNDEF
;
8154 sym
.st_target_internal
= 0;
8155 symstrtab
[0].sym
= sym
;
8156 symstrtab
[0].dest_index
= outbound_syms_index
;
8157 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8158 outbound_syms_index
++;
8159 if (outbound_shndx
!= NULL
)
8160 outbound_shndx_index
++;
8164 = (bed
->elf_backend_name_local_section_symbols
8165 && bed
->elf_backend_name_local_section_symbols (abfd
));
8167 syms
= bfd_get_outsymbols (abfd
);
8168 for (idx
= 0; idx
< symcount
;)
8170 Elf_Internal_Sym sym
;
8171 bfd_vma value
= syms
[idx
]->value
;
8172 elf_symbol_type
*type_ptr
;
8173 flagword flags
= syms
[idx
]->flags
;
8176 if (!name_local_sections
8177 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8179 /* Local section symbols have no name. */
8180 sym
.st_name
= (unsigned long) -1;
8184 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8185 to get the final offset for st_name. */
8187 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8189 if (sym
.st_name
== (unsigned long) -1)
8193 type_ptr
= elf_symbol_from (syms
[idx
]);
8195 if ((flags
& BSF_SECTION_SYM
) == 0
8196 && bfd_is_com_section (syms
[idx
]->section
))
8198 /* ELF common symbols put the alignment into the `value' field,
8199 and the size into the `size' field. This is backwards from
8200 how BFD handles it, so reverse it here. */
8201 sym
.st_size
= value
;
8202 if (type_ptr
== NULL
8203 || type_ptr
->internal_elf_sym
.st_value
== 0)
8204 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8206 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8207 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8208 (abfd
, syms
[idx
]->section
);
8212 asection
*sec
= syms
[idx
]->section
;
8215 if (sec
->output_section
)
8217 value
+= sec
->output_offset
;
8218 sec
= sec
->output_section
;
8221 /* Don't add in the section vma for relocatable output. */
8222 if (! relocatable_p
)
8224 sym
.st_value
= value
;
8225 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8227 if (bfd_is_abs_section (sec
)
8229 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8231 /* This symbol is in a real ELF section which we did
8232 not create as a BFD section. Undo the mapping done
8233 by copy_private_symbol_data. */
8234 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8238 shndx
= elf_onesymtab (abfd
);
8241 shndx
= elf_dynsymtab (abfd
);
8244 shndx
= elf_strtab_sec (abfd
);
8247 shndx
= elf_shstrtab_sec (abfd
);
8250 if (elf_symtab_shndx_list (abfd
))
8251 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8258 if (shndx
>= SHN_LOPROC
&& shndx
<= SHN_HIOS
)
8260 if (bed
->symbol_section_index
)
8261 shndx
= bed
->symbol_section_index (abfd
, type_ptr
);
8262 /* Otherwise just leave the index alone. */
8266 if (shndx
> SHN_HIOS
&& shndx
< SHN_HIRESERVE
)
8267 _bfd_error_handler (_("%pB: \
8268 Unable to handle section index %x in ELF symbol. Using ABS instead."),
8277 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8279 if (shndx
== SHN_BAD
)
8283 /* Writing this would be a hell of a lot easier if
8284 we had some decent documentation on bfd, and
8285 knew what to expect of the library, and what to
8286 demand of applications. For example, it
8287 appears that `objcopy' might not set the
8288 section of a symbol to be a section that is
8289 actually in the output file. */
8290 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8292 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8293 if (shndx
== SHN_BAD
)
8295 /* xgettext:c-format */
8297 (_("unable to find equivalent output section"
8298 " for symbol '%s' from section '%s'"),
8299 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8301 bfd_set_error (bfd_error_invalid_operation
);
8307 sym
.st_shndx
= shndx
;
8310 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8312 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8313 type
= STT_GNU_IFUNC
;
8314 else if ((flags
& BSF_FUNCTION
) != 0)
8316 else if ((flags
& BSF_OBJECT
) != 0)
8318 else if ((flags
& BSF_RELC
) != 0)
8320 else if ((flags
& BSF_SRELC
) != 0)
8325 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8328 /* Processor-specific types. */
8329 if (type_ptr
!= NULL
8330 && bed
->elf_backend_get_symbol_type
)
8331 type
= ((*bed
->elf_backend_get_symbol_type
)
8332 (&type_ptr
->internal_elf_sym
, type
));
8334 if (flags
& BSF_SECTION_SYM
)
8336 if (flags
& BSF_GLOBAL
)
8337 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8339 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8341 else if (bfd_is_com_section (syms
[idx
]->section
))
8343 if (type
!= STT_TLS
)
8345 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8346 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8347 ? STT_COMMON
: STT_OBJECT
);
8349 type
= ((flags
& BSF_ELF_COMMON
) != 0
8350 ? STT_COMMON
: STT_OBJECT
);
8352 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8354 else if (bfd_is_und_section (syms
[idx
]->section
))
8355 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8359 else if (flags
& BSF_FILE
)
8360 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8363 int bind
= STB_LOCAL
;
8365 if (flags
& BSF_LOCAL
)
8367 else if (flags
& BSF_GNU_UNIQUE
)
8368 bind
= STB_GNU_UNIQUE
;
8369 else if (flags
& BSF_WEAK
)
8371 else if (flags
& BSF_GLOBAL
)
8374 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8377 if (type_ptr
!= NULL
)
8379 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8380 sym
.st_target_internal
8381 = type_ptr
->internal_elf_sym
.st_target_internal
;
8386 sym
.st_target_internal
= 0;
8390 symstrtab
[idx
].sym
= sym
;
8391 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8392 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8394 outbound_syms_index
++;
8395 if (outbound_shndx
!= NULL
)
8396 outbound_shndx_index
++;
8399 /* Finalize the .strtab section. */
8400 _bfd_elf_strtab_finalize (stt
);
8402 /* Swap out the .strtab section. */
8403 for (idx
= 0; idx
<= symcount
; idx
++)
8405 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8406 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8407 elfsym
->sym
.st_name
= 0;
8409 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8410 elfsym
->sym
.st_name
);
8411 if (info
&& info
->callbacks
->ctf_new_symbol
)
8412 info
->callbacks
->ctf_new_symbol (elfsym
->dest_index
,
8415 /* Inform the linker of the addition of this symbol. */
8417 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8419 + (elfsym
->dest_index
8420 * bed
->s
->sizeof_sym
)),
8422 + (elfsym
->destshndx_index
8423 * sizeof (Elf_External_Sym_Shndx
))));
8428 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8429 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8430 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8431 symstrtab_hdr
->sh_addr
= 0;
8432 symstrtab_hdr
->sh_entsize
= 0;
8433 symstrtab_hdr
->sh_link
= 0;
8434 symstrtab_hdr
->sh_info
= 0;
8435 symstrtab_hdr
->sh_addralign
= 1;
8440 /* Return the number of bytes required to hold the symtab vector.
8442 Note that we base it on the count plus 1, since we will null terminate
8443 the vector allocated based on this size. However, the ELF symbol table
8444 always has a dummy entry as symbol #0, so it ends up even. */
8447 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8449 bfd_size_type symcount
;
8451 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8453 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8454 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8456 bfd_set_error (bfd_error_file_too_big
);
8459 symtab_size
= symcount
* (sizeof (asymbol
*));
8461 symtab_size
= sizeof (asymbol
*);
8462 else if (!bfd_write_p (abfd
))
8464 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8466 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8468 bfd_set_error (bfd_error_file_truncated
);
8477 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8479 bfd_size_type symcount
;
8481 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8483 if (elf_dynsymtab (abfd
) == 0)
8485 bfd_set_error (bfd_error_invalid_operation
);
8489 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8490 if (symcount
> LONG_MAX
/ sizeof (asymbol
*))
8492 bfd_set_error (bfd_error_file_too_big
);
8495 symtab_size
= symcount
* (sizeof (asymbol
*));
8497 symtab_size
= sizeof (asymbol
*);
8498 else if (!bfd_write_p (abfd
))
8500 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8502 if (filesize
!= 0 && (unsigned long) symtab_size
> filesize
)
8504 bfd_set_error (bfd_error_file_truncated
);
8513 _bfd_elf_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
8515 if (asect
->reloc_count
!= 0 && !bfd_write_p (abfd
))
8517 /* Sanity check reloc section size. */
8518 struct bfd_elf_section_data
*d
= elf_section_data (asect
);
8519 Elf_Internal_Shdr
*rel_hdr
= &d
->this_hdr
;
8520 bfd_size_type ext_rel_size
= rel_hdr
->sh_size
;
8521 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8523 if (filesize
!= 0 && ext_rel_size
> filesize
)
8525 bfd_set_error (bfd_error_file_truncated
);
8530 #if SIZEOF_LONG == SIZEOF_INT
8531 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8533 bfd_set_error (bfd_error_file_too_big
);
8537 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8540 /* Canonicalize the relocs. */
8543 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8550 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8552 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
8555 tblptr
= section
->relocation
;
8556 for (i
= 0; i
< section
->reloc_count
; i
++)
8557 *relptr
++ = tblptr
++;
8561 return section
->reloc_count
;
8565 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8567 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8568 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
8571 abfd
->symcount
= symcount
;
8576 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8577 asymbol
**allocation
)
8579 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8580 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
8583 abfd
->dynsymcount
= symcount
;
8587 /* Return the size required for the dynamic reloc entries. Any loadable
8588 section that was actually installed in the BFD, and has type SHT_REL
8589 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8590 dynamic reloc section. */
8593 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8595 bfd_size_type count
, ext_rel_size
;
8598 if (elf_dynsymtab (abfd
) == 0)
8600 bfd_set_error (bfd_error_invalid_operation
);
8606 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8607 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8608 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8609 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8611 ext_rel_size
+= s
->size
;
8612 if (ext_rel_size
< s
->size
)
8614 bfd_set_error (bfd_error_file_truncated
);
8617 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8618 if (count
> LONG_MAX
/ sizeof (arelent
*))
8620 bfd_set_error (bfd_error_file_too_big
);
8624 if (count
> 1 && !bfd_write_p (abfd
))
8626 /* Sanity check reloc section sizes. */
8627 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8628 if (filesize
!= 0 && ext_rel_size
> filesize
)
8630 bfd_set_error (bfd_error_file_truncated
);
8634 return count
* sizeof (arelent
*);
8637 /* Canonicalize the dynamic relocation entries. Note that we return the
8638 dynamic relocations as a single block, although they are actually
8639 associated with particular sections; the interface, which was
8640 designed for SunOS style shared libraries, expects that there is only
8641 one set of dynamic relocs. Any loadable section that was actually
8642 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8643 dynamic symbol table, is considered to be a dynamic reloc section. */
8646 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8650 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8654 if (elf_dynsymtab (abfd
) == 0)
8656 bfd_set_error (bfd_error_invalid_operation
);
8660 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8662 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8664 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8665 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8666 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8671 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8673 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8675 for (i
= 0; i
< count
; i
++)
8686 /* Read in the version information. */
8689 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8691 bfd_byte
*contents
= NULL
;
8692 unsigned int freeidx
= 0;
8695 if (elf_dynverref (abfd
) != 0)
8697 Elf_Internal_Shdr
*hdr
;
8698 Elf_External_Verneed
*everneed
;
8699 Elf_Internal_Verneed
*iverneed
;
8701 bfd_byte
*contents_end
;
8703 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8705 if (hdr
->sh_info
== 0
8706 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8708 error_return_bad_verref
:
8710 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8711 bfd_set_error (bfd_error_bad_value
);
8712 error_return_verref
:
8713 elf_tdata (abfd
)->verref
= NULL
;
8714 elf_tdata (abfd
)->cverrefs
= 0;
8718 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8719 goto error_return_verref
;
8720 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8721 if (contents
== NULL
)
8722 goto error_return_verref
;
8724 if (_bfd_mul_overflow (hdr
->sh_info
, sizeof (Elf_Internal_Verneed
), &amt
))
8726 bfd_set_error (bfd_error_file_too_big
);
8727 goto error_return_verref
;
8729 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*) bfd_alloc (abfd
, amt
);
8730 if (elf_tdata (abfd
)->verref
== NULL
)
8731 goto error_return_verref
;
8733 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8734 == sizeof (Elf_External_Vernaux
));
8735 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8736 everneed
= (Elf_External_Verneed
*) contents
;
8737 iverneed
= elf_tdata (abfd
)->verref
;
8738 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8740 Elf_External_Vernaux
*evernaux
;
8741 Elf_Internal_Vernaux
*ivernaux
;
8744 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8746 iverneed
->vn_bfd
= abfd
;
8748 iverneed
->vn_filename
=
8749 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8751 if (iverneed
->vn_filename
== NULL
)
8752 goto error_return_bad_verref
;
8754 if (iverneed
->vn_cnt
== 0)
8755 iverneed
->vn_auxptr
= NULL
;
8758 if (_bfd_mul_overflow (iverneed
->vn_cnt
,
8759 sizeof (Elf_Internal_Vernaux
), &amt
))
8761 bfd_set_error (bfd_error_file_too_big
);
8762 goto error_return_verref
;
8764 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8765 bfd_alloc (abfd
, amt
);
8766 if (iverneed
->vn_auxptr
== NULL
)
8767 goto error_return_verref
;
8770 if (iverneed
->vn_aux
8771 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8772 goto error_return_bad_verref
;
8774 evernaux
= ((Elf_External_Vernaux
*)
8775 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8776 ivernaux
= iverneed
->vn_auxptr
;
8777 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8779 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8781 ivernaux
->vna_nodename
=
8782 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8783 ivernaux
->vna_name
);
8784 if (ivernaux
->vna_nodename
== NULL
)
8785 goto error_return_bad_verref
;
8787 if (ivernaux
->vna_other
> freeidx
)
8788 freeidx
= ivernaux
->vna_other
;
8790 ivernaux
->vna_nextptr
= NULL
;
8791 if (ivernaux
->vna_next
== 0)
8793 iverneed
->vn_cnt
= j
+ 1;
8796 if (j
+ 1 < iverneed
->vn_cnt
)
8797 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8799 if (ivernaux
->vna_next
8800 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8801 goto error_return_bad_verref
;
8803 evernaux
= ((Elf_External_Vernaux
*)
8804 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8807 iverneed
->vn_nextref
= NULL
;
8808 if (iverneed
->vn_next
== 0)
8810 if (i
+ 1 < hdr
->sh_info
)
8811 iverneed
->vn_nextref
= iverneed
+ 1;
8813 if (iverneed
->vn_next
8814 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8815 goto error_return_bad_verref
;
8817 everneed
= ((Elf_External_Verneed
*)
8818 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8820 elf_tdata (abfd
)->cverrefs
= i
;
8826 if (elf_dynverdef (abfd
) != 0)
8828 Elf_Internal_Shdr
*hdr
;
8829 Elf_External_Verdef
*everdef
;
8830 Elf_Internal_Verdef
*iverdef
;
8831 Elf_Internal_Verdef
*iverdefarr
;
8832 Elf_Internal_Verdef iverdefmem
;
8834 unsigned int maxidx
;
8835 bfd_byte
*contents_end_def
, *contents_end_aux
;
8837 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8839 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8841 error_return_bad_verdef
:
8843 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8844 bfd_set_error (bfd_error_bad_value
);
8845 error_return_verdef
:
8846 elf_tdata (abfd
)->verdef
= NULL
;
8847 elf_tdata (abfd
)->cverdefs
= 0;
8851 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
8852 goto error_return_verdef
;
8853 contents
= _bfd_malloc_and_read (abfd
, hdr
->sh_size
, hdr
->sh_size
);
8854 if (contents
== NULL
)
8855 goto error_return_verdef
;
8857 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8858 >= sizeof (Elf_External_Verdaux
));
8859 contents_end_def
= contents
+ hdr
->sh_size
8860 - sizeof (Elf_External_Verdef
);
8861 contents_end_aux
= contents
+ hdr
->sh_size
8862 - sizeof (Elf_External_Verdaux
);
8864 /* We know the number of entries in the section but not the maximum
8865 index. Therefore we have to run through all entries and find
8867 everdef
= (Elf_External_Verdef
*) contents
;
8869 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8871 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8873 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8874 goto error_return_bad_verdef
;
8875 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8876 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8878 if (iverdefmem
.vd_next
== 0)
8881 if (iverdefmem
.vd_next
8882 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8883 goto error_return_bad_verdef
;
8885 everdef
= ((Elf_External_Verdef
*)
8886 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8889 if (default_imported_symver
)
8891 if (freeidx
> maxidx
)
8896 if (_bfd_mul_overflow (maxidx
, sizeof (Elf_Internal_Verdef
), &amt
))
8898 bfd_set_error (bfd_error_file_too_big
);
8899 goto error_return_verdef
;
8901 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
8902 if (elf_tdata (abfd
)->verdef
== NULL
)
8903 goto error_return_verdef
;
8905 elf_tdata (abfd
)->cverdefs
= maxidx
;
8907 everdef
= (Elf_External_Verdef
*) contents
;
8908 iverdefarr
= elf_tdata (abfd
)->verdef
;
8909 for (i
= 0; i
< hdr
->sh_info
; i
++)
8911 Elf_External_Verdaux
*everdaux
;
8912 Elf_Internal_Verdaux
*iverdaux
;
8915 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8917 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8918 goto error_return_bad_verdef
;
8920 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8921 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8923 iverdef
->vd_bfd
= abfd
;
8925 if (iverdef
->vd_cnt
== 0)
8926 iverdef
->vd_auxptr
= NULL
;
8929 if (_bfd_mul_overflow (iverdef
->vd_cnt
,
8930 sizeof (Elf_Internal_Verdaux
), &amt
))
8932 bfd_set_error (bfd_error_file_too_big
);
8933 goto error_return_verdef
;
8935 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8936 bfd_alloc (abfd
, amt
);
8937 if (iverdef
->vd_auxptr
== NULL
)
8938 goto error_return_verdef
;
8942 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8943 goto error_return_bad_verdef
;
8945 everdaux
= ((Elf_External_Verdaux
*)
8946 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8947 iverdaux
= iverdef
->vd_auxptr
;
8948 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8950 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8952 iverdaux
->vda_nodename
=
8953 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8954 iverdaux
->vda_name
);
8955 if (iverdaux
->vda_nodename
== NULL
)
8956 goto error_return_bad_verdef
;
8958 iverdaux
->vda_nextptr
= NULL
;
8959 if (iverdaux
->vda_next
== 0)
8961 iverdef
->vd_cnt
= j
+ 1;
8964 if (j
+ 1 < iverdef
->vd_cnt
)
8965 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8967 if (iverdaux
->vda_next
8968 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8969 goto error_return_bad_verdef
;
8971 everdaux
= ((Elf_External_Verdaux
*)
8972 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8975 iverdef
->vd_nodename
= NULL
;
8976 if (iverdef
->vd_cnt
)
8977 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8979 iverdef
->vd_nextdef
= NULL
;
8980 if (iverdef
->vd_next
== 0)
8982 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8983 iverdef
->vd_nextdef
= iverdef
+ 1;
8985 everdef
= ((Elf_External_Verdef
*)
8986 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8992 else if (default_imported_symver
)
8999 if (_bfd_mul_overflow (freeidx
, sizeof (Elf_Internal_Verdef
), &amt
))
9001 bfd_set_error (bfd_error_file_too_big
);
9004 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*) bfd_zalloc (abfd
, amt
);
9005 if (elf_tdata (abfd
)->verdef
== NULL
)
9008 elf_tdata (abfd
)->cverdefs
= freeidx
;
9011 /* Create a default version based on the soname. */
9012 if (default_imported_symver
)
9014 Elf_Internal_Verdef
*iverdef
;
9015 Elf_Internal_Verdaux
*iverdaux
;
9017 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
9019 iverdef
->vd_version
= VER_DEF_CURRENT
;
9020 iverdef
->vd_flags
= 0;
9021 iverdef
->vd_ndx
= freeidx
;
9022 iverdef
->vd_cnt
= 1;
9024 iverdef
->vd_bfd
= abfd
;
9026 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
9027 if (iverdef
->vd_nodename
== NULL
)
9028 goto error_return_verdef
;
9029 iverdef
->vd_nextdef
= NULL
;
9030 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
9031 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
9032 if (iverdef
->vd_auxptr
== NULL
)
9033 goto error_return_verdef
;
9035 iverdaux
= iverdef
->vd_auxptr
;
9036 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
9047 _bfd_elf_make_empty_symbol (bfd
*abfd
)
9049 elf_symbol_type
*newsym
;
9051 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
9054 newsym
->symbol
.the_bfd
= abfd
;
9055 return &newsym
->symbol
;
9059 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
9063 bfd_symbol_info (symbol
, ret
);
9066 /* Return whether a symbol name implies a local symbol. Most targets
9067 use this function for the is_local_label_name entry point, but some
9071 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
9074 /* Normal local symbols start with ``.L''. */
9075 if (name
[0] == '.' && name
[1] == 'L')
9078 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
9079 DWARF debugging symbols starting with ``..''. */
9080 if (name
[0] == '.' && name
[1] == '.')
9083 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
9084 emitting DWARF debugging output. I suspect this is actually a
9085 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
9086 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
9087 underscore to be emitted on some ELF targets). For ease of use,
9088 we treat such symbols as local. */
9089 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
9092 /* Treat assembler generated fake symbols, dollar local labels and
9093 forward-backward labels (aka local labels) as locals.
9094 These labels have the form:
9096 L0^A.* (fake symbols)
9098 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
9100 Versions which start with .L will have already been matched above,
9101 so we only need to match the rest. */
9102 if (name
[0] == 'L' && ISDIGIT (name
[1]))
9104 bfd_boolean ret
= FALSE
;
9108 for (p
= name
+ 2; (c
= *p
); p
++)
9110 if (c
== 1 || c
== 2)
9112 if (c
== 1 && p
== name
+ 2)
9113 /* A fake symbol. */
9116 /* FIXME: We are being paranoid here and treating symbols like
9117 L0^Bfoo as if there were non-local, on the grounds that the
9118 assembler will never generate them. But can any symbol
9119 containing an ASCII value in the range 1-31 ever be anything
9120 other than some kind of local ? */
9137 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9138 asymbol
*symbol ATTRIBUTE_UNUSED
)
9145 _bfd_elf_set_arch_mach (bfd
*abfd
,
9146 enum bfd_architecture arch
,
9147 unsigned long machine
)
9149 /* If this isn't the right architecture for this backend, and this
9150 isn't the generic backend, fail. */
9151 if (arch
!= get_elf_backend_data (abfd
)->arch
9152 && arch
!= bfd_arch_unknown
9153 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9156 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9159 /* Find the nearest line to a particular section and offset,
9160 for error reporting. */
9163 _bfd_elf_find_nearest_line (bfd
*abfd
,
9167 const char **filename_ptr
,
9168 const char **functionname_ptr
,
9169 unsigned int *line_ptr
,
9170 unsigned int *discriminator_ptr
)
9174 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9175 filename_ptr
, functionname_ptr
,
9176 line_ptr
, discriminator_ptr
,
9177 dwarf_debug_sections
,
9178 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9181 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9182 filename_ptr
, functionname_ptr
, line_ptr
))
9184 if (!*functionname_ptr
)
9185 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9186 *filename_ptr
? NULL
: filename_ptr
,
9191 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9192 &found
, filename_ptr
,
9193 functionname_ptr
, line_ptr
,
9194 &elf_tdata (abfd
)->line_info
))
9196 if (found
&& (*functionname_ptr
|| *line_ptr
))
9199 if (symbols
== NULL
)
9202 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9203 filename_ptr
, functionname_ptr
))
9210 /* Find the line for a symbol. */
9213 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9214 const char **filename_ptr
, unsigned int *line_ptr
)
9216 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9217 filename_ptr
, NULL
, line_ptr
, NULL
,
9218 dwarf_debug_sections
,
9219 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9222 /* After a call to bfd_find_nearest_line, successive calls to
9223 bfd_find_inliner_info can be used to get source information about
9224 each level of function inlining that terminated at the address
9225 passed to bfd_find_nearest_line. Currently this is only supported
9226 for DWARF2 with appropriate DWARF3 extensions. */
9229 _bfd_elf_find_inliner_info (bfd
*abfd
,
9230 const char **filename_ptr
,
9231 const char **functionname_ptr
,
9232 unsigned int *line_ptr
)
9235 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9236 functionname_ptr
, line_ptr
,
9237 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9242 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9244 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9245 int ret
= bed
->s
->sizeof_ehdr
;
9247 if (!bfd_link_relocatable (info
))
9249 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9251 if (phdr_size
== (bfd_size_type
) -1)
9253 struct elf_segment_map
*m
;
9256 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9257 phdr_size
+= bed
->s
->sizeof_phdr
;
9260 phdr_size
= get_program_header_size (abfd
, info
);
9263 elf_program_header_size (abfd
) = phdr_size
;
9271 _bfd_elf_set_section_contents (bfd
*abfd
,
9273 const void *location
,
9275 bfd_size_type count
)
9277 Elf_Internal_Shdr
*hdr
;
9280 if (! abfd
->output_has_begun
9281 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9287 hdr
= &elf_section_data (section
)->this_hdr
;
9288 if (hdr
->sh_offset
== (file_ptr
) -1)
9290 unsigned char *contents
;
9292 if (bfd_section_is_ctf (section
))
9293 /* Nothing to do with this section: the contents are generated
9297 if ((section
->flags
& SEC_ELF_COMPRESS
) == 0)
9300 (_("%pB:%pA: error: attempting to write into an unallocated compressed section"),
9302 bfd_set_error (bfd_error_invalid_operation
);
9306 if ((offset
+ count
) > hdr
->sh_size
)
9309 (_("%pB:%pA: error: attempting to write over the end of the section"),
9312 bfd_set_error (bfd_error_invalid_operation
);
9316 contents
= hdr
->contents
;
9317 if (contents
== NULL
)
9320 (_("%pB:%pA: error: attempting to write section into an empty buffer"),
9323 bfd_set_error (bfd_error_invalid_operation
);
9327 memcpy (contents
+ offset
, location
, count
);
9331 pos
= hdr
->sh_offset
+ offset
;
9332 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9333 || bfd_bwrite (location
, count
, abfd
) != count
)
9340 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9341 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9342 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9348 /* Try to convert a non-ELF reloc into an ELF one. */
9351 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9353 /* Check whether we really have an ELF howto. */
9355 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9357 bfd_reloc_code_real_type code
;
9358 reloc_howto_type
*howto
;
9360 /* Alien reloc: Try to determine its type to replace it with an
9361 equivalent ELF reloc. */
9363 if (areloc
->howto
->pc_relative
)
9365 switch (areloc
->howto
->bitsize
)
9368 code
= BFD_RELOC_8_PCREL
;
9371 code
= BFD_RELOC_12_PCREL
;
9374 code
= BFD_RELOC_16_PCREL
;
9377 code
= BFD_RELOC_24_PCREL
;
9380 code
= BFD_RELOC_32_PCREL
;
9383 code
= BFD_RELOC_64_PCREL
;
9389 howto
= bfd_reloc_type_lookup (abfd
, code
);
9391 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9393 if (howto
->pcrel_offset
)
9394 areloc
->addend
+= areloc
->address
;
9396 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9401 switch (areloc
->howto
->bitsize
)
9407 code
= BFD_RELOC_14
;
9410 code
= BFD_RELOC_16
;
9413 code
= BFD_RELOC_26
;
9416 code
= BFD_RELOC_32
;
9419 code
= BFD_RELOC_64
;
9425 howto
= bfd_reloc_type_lookup (abfd
, code
);
9429 areloc
->howto
= howto
;
9437 /* xgettext:c-format */
9438 _bfd_error_handler (_("%pB: %s unsupported"),
9439 abfd
, areloc
->howto
->name
);
9440 bfd_set_error (bfd_error_sorry
);
9445 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9447 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9449 && (bfd_get_format (abfd
) == bfd_object
9450 || bfd_get_format (abfd
) == bfd_core
))
9452 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9453 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9454 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9457 return _bfd_generic_close_and_cleanup (abfd
);
9460 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9461 in the relocation's offset. Thus we cannot allow any sort of sanity
9462 range-checking to interfere. There is nothing else to do in processing
9465 bfd_reloc_status_type
9466 _bfd_elf_rel_vtable_reloc_fn
9467 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9468 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9469 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9470 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9472 return bfd_reloc_ok
;
9475 /* Elf core file support. Much of this only works on native
9476 toolchains, since we rely on knowing the
9477 machine-dependent procfs structure in order to pick
9478 out details about the corefile. */
9480 #ifdef HAVE_SYS_PROCFS_H
9481 # include <sys/procfs.h>
9484 /* Return a PID that identifies a "thread" for threaded cores, or the
9485 PID of the main process for non-threaded cores. */
9488 elfcore_make_pid (bfd
*abfd
)
9492 pid
= elf_tdata (abfd
)->core
->lwpid
;
9494 pid
= elf_tdata (abfd
)->core
->pid
;
9499 /* If there isn't a section called NAME, make one, using
9500 data from SECT. Note, this function will generate a
9501 reference to NAME, so you shouldn't deallocate or
9505 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9509 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9512 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9516 sect2
->size
= sect
->size
;
9517 sect2
->filepos
= sect
->filepos
;
9518 sect2
->alignment_power
= sect
->alignment_power
;
9522 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9523 actually creates up to two pseudosections:
9524 - For the single-threaded case, a section named NAME, unless
9525 such a section already exists.
9526 - For the multi-threaded case, a section named "NAME/PID", where
9527 PID is elfcore_make_pid (abfd).
9528 Both pseudosections have identical contents. */
9530 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9536 char *threaded_name
;
9540 /* Build the section name. */
9542 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9543 len
= strlen (buf
) + 1;
9544 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9545 if (threaded_name
== NULL
)
9547 memcpy (threaded_name
, buf
, len
);
9549 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9554 sect
->filepos
= filepos
;
9555 sect
->alignment_power
= 2;
9557 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9561 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9564 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9570 sect
->size
= note
->descsz
- offs
;
9571 sect
->filepos
= note
->descpos
+ offs
;
9572 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9577 /* prstatus_t exists on:
9579 linux 2.[01] + glibc
9583 #if defined (HAVE_PRSTATUS_T)
9586 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9591 if (note
->descsz
== sizeof (prstatus_t
))
9595 size
= sizeof (prstat
.pr_reg
);
9596 offset
= offsetof (prstatus_t
, pr_reg
);
9597 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9599 /* Do not overwrite the core signal if it
9600 has already been set by another thread. */
9601 if (elf_tdata (abfd
)->core
->signal
== 0)
9602 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9603 if (elf_tdata (abfd
)->core
->pid
== 0)
9604 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9606 /* pr_who exists on:
9609 pr_who doesn't exist on:
9612 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9613 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9615 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9618 #if defined (HAVE_PRSTATUS32_T)
9619 else if (note
->descsz
== sizeof (prstatus32_t
))
9621 /* 64-bit host, 32-bit corefile */
9622 prstatus32_t prstat
;
9624 size
= sizeof (prstat
.pr_reg
);
9625 offset
= offsetof (prstatus32_t
, pr_reg
);
9626 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9628 /* Do not overwrite the core signal if it
9629 has already been set by another thread. */
9630 if (elf_tdata (abfd
)->core
->signal
== 0)
9631 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9632 if (elf_tdata (abfd
)->core
->pid
== 0)
9633 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9635 /* pr_who exists on:
9638 pr_who doesn't exist on:
9641 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9642 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9644 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9647 #endif /* HAVE_PRSTATUS32_T */
9650 /* Fail - we don't know how to handle any other
9651 note size (ie. data object type). */
9655 /* Make a ".reg/999" section and a ".reg" section. */
9656 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9657 size
, note
->descpos
+ offset
);
9659 #endif /* defined (HAVE_PRSTATUS_T) */
9661 /* Create a pseudosection containing the exact contents of NOTE. */
9663 elfcore_make_note_pseudosection (bfd
*abfd
,
9665 Elf_Internal_Note
*note
)
9667 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9668 note
->descsz
, note
->descpos
);
9671 /* There isn't a consistent prfpregset_t across platforms,
9672 but it doesn't matter, because we don't have to pick this
9673 data structure apart. */
9676 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9678 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9681 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9682 type of NT_PRXFPREG. Just include the whole note's contents
9686 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9688 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9691 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9692 with a note type of NT_X86_XSTATE. Just include the whole note's
9693 contents literally. */
9696 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9698 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9702 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9704 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9708 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9710 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9714 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9716 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9720 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9722 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9726 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9728 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9732 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9734 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9738 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9740 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9744 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9746 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9750 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9752 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9756 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9758 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9762 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9764 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9768 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9770 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9774 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9776 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9780 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9782 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9786 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9788 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9792 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9794 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9798 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9800 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9804 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9806 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9810 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9812 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9816 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9818 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9822 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9824 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9828 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9830 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9834 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9836 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9840 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9842 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9846 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9848 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9852 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9854 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9858 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9860 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9864 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9866 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9870 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9872 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9876 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9878 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9882 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9884 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9888 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9890 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9894 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9896 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9900 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9902 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9906 elfcore_grok_arc_v2 (bfd
*abfd
, Elf_Internal_Note
*note
)
9908 return elfcore_make_note_pseudosection (abfd
, ".reg-arc-v2", note
);
9911 #if defined (HAVE_PRPSINFO_T)
9912 typedef prpsinfo_t elfcore_psinfo_t
;
9913 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9914 typedef prpsinfo32_t elfcore_psinfo32_t
;
9918 #if defined (HAVE_PSINFO_T)
9919 typedef psinfo_t elfcore_psinfo_t
;
9920 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9921 typedef psinfo32_t elfcore_psinfo32_t
;
9925 /* return a malloc'ed copy of a string at START which is at
9926 most MAX bytes long, possibly without a terminating '\0'.
9927 the copy will always have a terminating '\0'. */
9930 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9933 char *end
= (char *) memchr (start
, '\0', max
);
9941 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9945 memcpy (dups
, start
, len
);
9951 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9953 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9955 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9957 elfcore_psinfo_t psinfo
;
9959 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9961 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9962 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9964 elf_tdata (abfd
)->core
->program
9965 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9966 sizeof (psinfo
.pr_fname
));
9968 elf_tdata (abfd
)->core
->command
9969 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9970 sizeof (psinfo
.pr_psargs
));
9972 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9973 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9975 /* 64-bit host, 32-bit corefile */
9976 elfcore_psinfo32_t psinfo
;
9978 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9980 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9981 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9983 elf_tdata (abfd
)->core
->program
9984 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9985 sizeof (psinfo
.pr_fname
));
9987 elf_tdata (abfd
)->core
->command
9988 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9989 sizeof (psinfo
.pr_psargs
));
9995 /* Fail - we don't know how to handle any other
9996 note size (ie. data object type). */
10000 /* Note that for some reason, a spurious space is tacked
10001 onto the end of the args in some (at least one anyway)
10002 implementations, so strip it off if it exists. */
10005 char *command
= elf_tdata (abfd
)->core
->command
;
10006 int n
= strlen (command
);
10008 if (0 < n
&& command
[n
- 1] == ' ')
10009 command
[n
- 1] = '\0';
10014 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
10016 #if defined (HAVE_PSTATUS_T)
10018 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10020 if (note
->descsz
== sizeof (pstatus_t
)
10021 #if defined (HAVE_PXSTATUS_T)
10022 || note
->descsz
== sizeof (pxstatus_t
)
10028 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10030 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10032 #if defined (HAVE_PSTATUS32_T)
10033 else if (note
->descsz
== sizeof (pstatus32_t
))
10035 /* 64-bit host, 32-bit corefile */
10038 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
10040 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
10043 /* Could grab some more details from the "representative"
10044 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
10045 NT_LWPSTATUS note, presumably. */
10049 #endif /* defined (HAVE_PSTATUS_T) */
10051 #if defined (HAVE_LWPSTATUS_T)
10053 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10055 lwpstatus_t lwpstat
;
10061 if (note
->descsz
!= sizeof (lwpstat
)
10062 #if defined (HAVE_LWPXSTATUS_T)
10063 && note
->descsz
!= sizeof (lwpxstatus_t
)
10068 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
10070 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
10071 /* Do not overwrite the core signal if it has already been set by
10073 if (elf_tdata (abfd
)->core
->signal
== 0)
10074 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
10076 /* Make a ".reg/999" section. */
10078 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
10079 len
= strlen (buf
) + 1;
10080 name
= bfd_alloc (abfd
, len
);
10083 memcpy (name
, buf
, len
);
10085 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10089 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10090 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
10091 sect
->filepos
= note
->descpos
10092 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
10095 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10096 sect
->size
= sizeof (lwpstat
.pr_reg
);
10097 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
10100 sect
->alignment_power
= 2;
10102 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10105 /* Make a ".reg2/999" section */
10107 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
10108 len
= strlen (buf
) + 1;
10109 name
= bfd_alloc (abfd
, len
);
10112 memcpy (name
, buf
, len
);
10114 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10118 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10119 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
10120 sect
->filepos
= note
->descpos
10121 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
10124 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
10125 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
10126 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
10129 sect
->alignment_power
= 2;
10131 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
10133 #endif /* defined (HAVE_LWPSTATUS_T) */
10135 /* These constants, and the structure offsets used below, are defined by
10136 Cygwin's core_dump.h */
10137 #define NOTE_INFO_PROCESS 1
10138 #define NOTE_INFO_THREAD 2
10139 #define NOTE_INFO_MODULE 3
10140 #define NOTE_INFO_MODULE64 4
10143 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10148 unsigned int name_size
;
10151 int is_active_thread
;
10154 if (note
->descsz
< 4)
10157 if (! CONST_STRNEQ (note
->namedata
, "win32"))
10160 type
= bfd_get_32 (abfd
, note
->descdata
);
10163 const char *type_name
;
10164 unsigned long min_size
;
10167 { "NOTE_INFO_PROCESS", 12 },
10168 { "NOTE_INFO_THREAD", 12 },
10169 { "NOTE_INFO_MODULE", 12 },
10170 { "NOTE_INFO_MODULE64", 16 },
10173 if (type
> (sizeof(size_check
)/sizeof(size_check
[0])))
10176 if (note
->descsz
< size_check
[type
- 1].min_size
)
10178 _bfd_error_handler (_("%pB: warning: win32pstatus %s of size %lu bytes is too small"),
10179 abfd
, size_check
[type
- 1].type_name
, note
->descsz
);
10185 case NOTE_INFO_PROCESS
:
10186 /* FIXME: need to add ->core->command. */
10187 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10188 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10191 case NOTE_INFO_THREAD
:
10192 /* Make a ".reg/<tid>" section containing the Win32 API thread CONTEXT
10194 /* thread_info.tid */
10195 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 4));
10197 len
= strlen (buf
) + 1;
10198 name
= (char *) bfd_alloc (abfd
, len
);
10202 memcpy (name
, buf
, len
);
10204 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10208 /* sizeof (thread_info.thread_context) */
10209 sect
->size
= note
->descsz
- 12;
10210 /* offsetof (thread_info.thread_context) */
10211 sect
->filepos
= note
->descpos
+ 12;
10212 sect
->alignment_power
= 2;
10214 /* thread_info.is_active_thread */
10215 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10217 if (is_active_thread
)
10218 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10222 case NOTE_INFO_MODULE
:
10223 case NOTE_INFO_MODULE64
:
10224 /* Make a ".module/xxxxxxxx" section. */
10225 if (type
== NOTE_INFO_MODULE
)
10227 /* module_info.base_address */
10228 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10229 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10230 /* module_info.module_name_size */
10231 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10233 else /* NOTE_INFO_MODULE64 */
10235 /* module_info.base_address */
10236 base_addr
= bfd_get_64 (abfd
, note
->descdata
+ 4);
10237 sprintf (buf
, ".module/%016lx", (unsigned long) base_addr
);
10238 /* module_info.module_name_size */
10239 name_size
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10242 len
= strlen (buf
) + 1;
10243 name
= (char *) bfd_alloc (abfd
, len
);
10247 memcpy (name
, buf
, len
);
10249 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10254 if (note
->descsz
< 12 + name_size
)
10256 _bfd_error_handler (_("%pB: win32pstatus NOTE_INFO_MODULE of size %lu is too small to contain a name of size %u"),
10257 abfd
, note
->descsz
, name_size
);
10261 sect
->size
= note
->descsz
;
10262 sect
->filepos
= note
->descpos
;
10263 sect
->alignment_power
= 2;
10274 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10276 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10278 switch (note
->type
)
10284 if (bed
->elf_backend_grok_prstatus
)
10285 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10287 #if defined (HAVE_PRSTATUS_T)
10288 return elfcore_grok_prstatus (abfd
, note
);
10293 #if defined (HAVE_PSTATUS_T)
10295 return elfcore_grok_pstatus (abfd
, note
);
10298 #if defined (HAVE_LWPSTATUS_T)
10300 return elfcore_grok_lwpstatus (abfd
, note
);
10303 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10304 return elfcore_grok_prfpreg (abfd
, note
);
10306 case NT_WIN32PSTATUS
:
10307 return elfcore_grok_win32pstatus (abfd
, note
);
10309 case NT_PRXFPREG
: /* Linux SSE extension */
10310 if (note
->namesz
== 6
10311 && strcmp (note
->namedata
, "LINUX") == 0)
10312 return elfcore_grok_prxfpreg (abfd
, note
);
10316 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10317 if (note
->namesz
== 6
10318 && strcmp (note
->namedata
, "LINUX") == 0)
10319 return elfcore_grok_xstatereg (abfd
, note
);
10324 if (note
->namesz
== 6
10325 && strcmp (note
->namedata
, "LINUX") == 0)
10326 return elfcore_grok_ppc_vmx (abfd
, note
);
10331 if (note
->namesz
== 6
10332 && strcmp (note
->namedata
, "LINUX") == 0)
10333 return elfcore_grok_ppc_vsx (abfd
, note
);
10338 if (note
->namesz
== 6
10339 && strcmp (note
->namedata
, "LINUX") == 0)
10340 return elfcore_grok_ppc_tar (abfd
, note
);
10345 if (note
->namesz
== 6
10346 && strcmp (note
->namedata
, "LINUX") == 0)
10347 return elfcore_grok_ppc_ppr (abfd
, note
);
10352 if (note
->namesz
== 6
10353 && strcmp (note
->namedata
, "LINUX") == 0)
10354 return elfcore_grok_ppc_dscr (abfd
, note
);
10359 if (note
->namesz
== 6
10360 && strcmp (note
->namedata
, "LINUX") == 0)
10361 return elfcore_grok_ppc_ebb (abfd
, note
);
10366 if (note
->namesz
== 6
10367 && strcmp (note
->namedata
, "LINUX") == 0)
10368 return elfcore_grok_ppc_pmu (abfd
, note
);
10372 case NT_PPC_TM_CGPR
:
10373 if (note
->namesz
== 6
10374 && strcmp (note
->namedata
, "LINUX") == 0)
10375 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10379 case NT_PPC_TM_CFPR
:
10380 if (note
->namesz
== 6
10381 && strcmp (note
->namedata
, "LINUX") == 0)
10382 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10386 case NT_PPC_TM_CVMX
:
10387 if (note
->namesz
== 6
10388 && strcmp (note
->namedata
, "LINUX") == 0)
10389 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10393 case NT_PPC_TM_CVSX
:
10394 if (note
->namesz
== 6
10395 && strcmp (note
->namedata
, "LINUX") == 0)
10396 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10400 case NT_PPC_TM_SPR
:
10401 if (note
->namesz
== 6
10402 && strcmp (note
->namedata
, "LINUX") == 0)
10403 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10407 case NT_PPC_TM_CTAR
:
10408 if (note
->namesz
== 6
10409 && strcmp (note
->namedata
, "LINUX") == 0)
10410 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10414 case NT_PPC_TM_CPPR
:
10415 if (note
->namesz
== 6
10416 && strcmp (note
->namedata
, "LINUX") == 0)
10417 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10421 case NT_PPC_TM_CDSCR
:
10422 if (note
->namesz
== 6
10423 && strcmp (note
->namedata
, "LINUX") == 0)
10424 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10428 case NT_S390_HIGH_GPRS
:
10429 if (note
->namesz
== 6
10430 && strcmp (note
->namedata
, "LINUX") == 0)
10431 return elfcore_grok_s390_high_gprs (abfd
, note
);
10435 case NT_S390_TIMER
:
10436 if (note
->namesz
== 6
10437 && strcmp (note
->namedata
, "LINUX") == 0)
10438 return elfcore_grok_s390_timer (abfd
, note
);
10442 case NT_S390_TODCMP
:
10443 if (note
->namesz
== 6
10444 && strcmp (note
->namedata
, "LINUX") == 0)
10445 return elfcore_grok_s390_todcmp (abfd
, note
);
10449 case NT_S390_TODPREG
:
10450 if (note
->namesz
== 6
10451 && strcmp (note
->namedata
, "LINUX") == 0)
10452 return elfcore_grok_s390_todpreg (abfd
, note
);
10457 if (note
->namesz
== 6
10458 && strcmp (note
->namedata
, "LINUX") == 0)
10459 return elfcore_grok_s390_ctrs (abfd
, note
);
10463 case NT_S390_PREFIX
:
10464 if (note
->namesz
== 6
10465 && strcmp (note
->namedata
, "LINUX") == 0)
10466 return elfcore_grok_s390_prefix (abfd
, note
);
10470 case NT_S390_LAST_BREAK
:
10471 if (note
->namesz
== 6
10472 && strcmp (note
->namedata
, "LINUX") == 0)
10473 return elfcore_grok_s390_last_break (abfd
, note
);
10477 case NT_S390_SYSTEM_CALL
:
10478 if (note
->namesz
== 6
10479 && strcmp (note
->namedata
, "LINUX") == 0)
10480 return elfcore_grok_s390_system_call (abfd
, note
);
10485 if (note
->namesz
== 6
10486 && strcmp (note
->namedata
, "LINUX") == 0)
10487 return elfcore_grok_s390_tdb (abfd
, note
);
10491 case NT_S390_VXRS_LOW
:
10492 if (note
->namesz
== 6
10493 && strcmp (note
->namedata
, "LINUX") == 0)
10494 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10498 case NT_S390_VXRS_HIGH
:
10499 if (note
->namesz
== 6
10500 && strcmp (note
->namedata
, "LINUX") == 0)
10501 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10505 case NT_S390_GS_CB
:
10506 if (note
->namesz
== 6
10507 && strcmp (note
->namedata
, "LINUX") == 0)
10508 return elfcore_grok_s390_gs_cb (abfd
, note
);
10512 case NT_S390_GS_BC
:
10513 if (note
->namesz
== 6
10514 && strcmp (note
->namedata
, "LINUX") == 0)
10515 return elfcore_grok_s390_gs_bc (abfd
, note
);
10520 if (note
->namesz
== 6
10521 && strcmp (note
->namedata
, "LINUX") == 0)
10522 return elfcore_grok_arc_v2 (abfd
, note
);
10527 if (note
->namesz
== 6
10528 && strcmp (note
->namedata
, "LINUX") == 0)
10529 return elfcore_grok_arm_vfp (abfd
, note
);
10534 if (note
->namesz
== 6
10535 && strcmp (note
->namedata
, "LINUX") == 0)
10536 return elfcore_grok_aarch_tls (abfd
, note
);
10540 case NT_ARM_HW_BREAK
:
10541 if (note
->namesz
== 6
10542 && strcmp (note
->namedata
, "LINUX") == 0)
10543 return elfcore_grok_aarch_hw_break (abfd
, note
);
10547 case NT_ARM_HW_WATCH
:
10548 if (note
->namesz
== 6
10549 && strcmp (note
->namedata
, "LINUX") == 0)
10550 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10555 if (note
->namesz
== 6
10556 && strcmp (note
->namedata
, "LINUX") == 0)
10557 return elfcore_grok_aarch_sve (abfd
, note
);
10561 case NT_ARM_PAC_MASK
:
10562 if (note
->namesz
== 6
10563 && strcmp (note
->namedata
, "LINUX") == 0)
10564 return elfcore_grok_aarch_pauth (abfd
, note
);
10570 if (bed
->elf_backend_grok_psinfo
)
10571 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10573 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10574 return elfcore_grok_psinfo (abfd
, note
);
10580 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10583 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10587 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10594 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10596 struct bfd_build_id
* build_id
;
10598 if (note
->descsz
== 0)
10601 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10602 if (build_id
== NULL
)
10605 build_id
->size
= note
->descsz
;
10606 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10607 abfd
->build_id
= build_id
;
10613 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10615 switch (note
->type
)
10620 case NT_GNU_PROPERTY_TYPE_0
:
10621 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10623 case NT_GNU_BUILD_ID
:
10624 return elfobj_grok_gnu_build_id (abfd
, note
);
10629 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10631 struct sdt_note
*cur
=
10632 (struct sdt_note
*) bfd_alloc (abfd
,
10633 sizeof (struct sdt_note
) + note
->descsz
);
10635 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10636 cur
->size
= (bfd_size_type
) note
->descsz
;
10637 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10639 elf_tdata (abfd
)->sdt_note_head
= cur
;
10645 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10647 switch (note
->type
)
10650 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10658 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10662 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10665 if (note
->descsz
< 108)
10670 if (note
->descsz
< 120)
10678 /* Check for version 1 in pr_version. */
10679 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10684 /* Skip over pr_psinfosz. */
10685 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10689 offset
+= 4; /* Padding before pr_psinfosz. */
10693 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10694 elf_tdata (abfd
)->core
->program
10695 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10698 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10699 elf_tdata (abfd
)->core
->command
10700 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10703 /* Padding before pr_pid. */
10706 /* The pr_pid field was added in version "1a". */
10707 if (note
->descsz
< offset
+ 4)
10710 elf_tdata (abfd
)->core
->pid
10711 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10717 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10723 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10724 Also compute minimum size of this note. */
10725 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10729 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10733 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10734 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10741 if (note
->descsz
< min_size
)
10744 /* Check for version 1 in pr_version. */
10745 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10748 /* Extract size of pr_reg from pr_gregsetsz. */
10749 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10750 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10752 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10757 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10761 /* Skip over pr_osreldate. */
10764 /* Read signal from pr_cursig. */
10765 if (elf_tdata (abfd
)->core
->signal
== 0)
10766 elf_tdata (abfd
)->core
->signal
10767 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10770 /* Read TID from pr_pid. */
10771 elf_tdata (abfd
)->core
->lwpid
10772 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10775 /* Padding before pr_reg. */
10776 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10779 /* Make sure that there is enough data remaining in the note. */
10780 if ((note
->descsz
- offset
) < size
)
10783 /* Make a ".reg/999" section and a ".reg" section. */
10784 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10785 size
, note
->descpos
+ offset
);
10789 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10791 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10793 switch (note
->type
)
10796 if (bed
->elf_backend_grok_freebsd_prstatus
)
10797 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10799 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10802 return elfcore_grok_prfpreg (abfd
, note
);
10805 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10807 case NT_FREEBSD_THRMISC
:
10808 if (note
->namesz
== 8)
10809 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10813 case NT_FREEBSD_PROCSTAT_PROC
:
10814 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10817 case NT_FREEBSD_PROCSTAT_FILES
:
10818 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10821 case NT_FREEBSD_PROCSTAT_VMMAP
:
10822 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10825 case NT_FREEBSD_PROCSTAT_AUXV
:
10826 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10828 case NT_X86_XSTATE
:
10829 if (note
->namesz
== 8)
10830 return elfcore_grok_xstatereg (abfd
, note
);
10834 case NT_FREEBSD_PTLWPINFO
:
10835 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10839 return elfcore_grok_arm_vfp (abfd
, note
);
10847 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10851 cp
= strchr (note
->namedata
, '@');
10854 *lwpidp
= atoi(cp
+ 1);
10861 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10863 if (note
->descsz
<= 0x7c + 31)
10866 /* Signal number at offset 0x08. */
10867 elf_tdata (abfd
)->core
->signal
10868 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10870 /* Process ID at offset 0x50. */
10871 elf_tdata (abfd
)->core
->pid
10872 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10874 /* Command name at 0x7c (max 32 bytes, including nul). */
10875 elf_tdata (abfd
)->core
->command
10876 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10878 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10883 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10887 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10888 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10890 switch (note
->type
)
10892 case NT_NETBSDCORE_PROCINFO
:
10893 /* NetBSD-specific core "procinfo". Note that we expect to
10894 find this note before any of the others, which is fine,
10895 since the kernel writes this note out first when it
10896 creates a core file. */
10897 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10898 #ifdef NT_NETBSDCORE_AUXV
10899 case NT_NETBSDCORE_AUXV
:
10900 /* NetBSD-specific Elf Auxiliary Vector data. */
10901 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10903 #ifdef NT_NETBSDCORE_LWPSTATUS
10904 case NT_NETBSDCORE_LWPSTATUS
:
10905 return elfcore_make_note_pseudosection (abfd
,
10906 ".note.netbsdcore.lwpstatus",
10913 /* As of March 2020 there are no other machine-independent notes
10914 defined for NetBSD core files. If the note type is less
10915 than the start of the machine-dependent note types, we don't
10918 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10922 switch (bfd_get_arch (abfd
))
10924 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10925 PT_GETFPREGS == mach+2. */
10927 case bfd_arch_aarch64
:
10928 case bfd_arch_alpha
:
10929 case bfd_arch_sparc
:
10930 switch (note
->type
)
10932 case NT_NETBSDCORE_FIRSTMACH
+0:
10933 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10935 case NT_NETBSDCORE_FIRSTMACH
+2:
10936 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10942 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10943 There's also old PT___GETREGS40 == mach + 1 for old reg
10944 structure which lacks GBR. */
10947 switch (note
->type
)
10949 case NT_NETBSDCORE_FIRSTMACH
+3:
10950 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10952 case NT_NETBSDCORE_FIRSTMACH
+5:
10953 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10959 /* On all other arch's, PT_GETREGS == mach+1 and
10960 PT_GETFPREGS == mach+3. */
10963 switch (note
->type
)
10965 case NT_NETBSDCORE_FIRSTMACH
+1:
10966 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10968 case NT_NETBSDCORE_FIRSTMACH
+3:
10969 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10979 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10981 if (note
->descsz
<= 0x48 + 31)
10984 /* Signal number at offset 0x08. */
10985 elf_tdata (abfd
)->core
->signal
10986 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10988 /* Process ID at offset 0x20. */
10989 elf_tdata (abfd
)->core
->pid
10990 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
10992 /* Command name at 0x48 (max 32 bytes, including nul). */
10993 elf_tdata (abfd
)->core
->command
10994 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
11000 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11002 if (note
->type
== NT_OPENBSD_PROCINFO
)
11003 return elfcore_grok_openbsd_procinfo (abfd
, note
);
11005 if (note
->type
== NT_OPENBSD_REGS
)
11006 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
11008 if (note
->type
== NT_OPENBSD_FPREGS
)
11009 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
11011 if (note
->type
== NT_OPENBSD_XFPREGS
)
11012 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
11014 if (note
->type
== NT_OPENBSD_AUXV
)
11015 return elfcore_make_auxv_note_section (abfd
, note
, 0);
11017 if (note
->type
== NT_OPENBSD_WCOOKIE
)
11019 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
11024 sect
->size
= note
->descsz
;
11025 sect
->filepos
= note
->descpos
;
11026 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
11035 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
11037 void *ddata
= note
->descdata
;
11044 if (note
->descsz
< 16)
11047 /* nto_procfs_status 'pid' field is at offset 0. */
11048 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
11050 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
11051 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
11053 /* nto_procfs_status 'flags' field is at offset 8. */
11054 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
11056 /* nto_procfs_status 'what' field is at offset 14. */
11057 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
11059 elf_tdata (abfd
)->core
->signal
= sig
;
11060 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11063 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
11064 do not come from signals so we make sure we set the current
11065 thread just in case. */
11066 if (flags
& 0x00000080)
11067 elf_tdata (abfd
)->core
->lwpid
= *tid
;
11069 /* Make a ".qnx_core_status/%d" section. */
11070 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
11072 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11075 strcpy (name
, buf
);
11077 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11081 sect
->size
= note
->descsz
;
11082 sect
->filepos
= note
->descpos
;
11083 sect
->alignment_power
= 2;
11085 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
11089 elfcore_grok_nto_regs (bfd
*abfd
,
11090 Elf_Internal_Note
*note
,
11098 /* Make a "(base)/%d" section. */
11099 sprintf (buf
, "%s/%ld", base
, tid
);
11101 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
11104 strcpy (name
, buf
);
11106 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11110 sect
->size
= note
->descsz
;
11111 sect
->filepos
= note
->descpos
;
11112 sect
->alignment_power
= 2;
11114 /* This is the current thread. */
11115 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
11116 return elfcore_maybe_make_sect (abfd
, base
, sect
);
11121 #define BFD_QNT_CORE_INFO 7
11122 #define BFD_QNT_CORE_STATUS 8
11123 #define BFD_QNT_CORE_GREG 9
11124 #define BFD_QNT_CORE_FPREG 10
11127 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11129 /* Every GREG section has a STATUS section before it. Store the
11130 tid from the previous call to pass down to the next gregs
11132 static long tid
= 1;
11134 switch (note
->type
)
11136 case BFD_QNT_CORE_INFO
:
11137 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
11138 case BFD_QNT_CORE_STATUS
:
11139 return elfcore_grok_nto_status (abfd
, note
, &tid
);
11140 case BFD_QNT_CORE_GREG
:
11141 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
11142 case BFD_QNT_CORE_FPREG
:
11143 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
11150 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
11156 /* Use note name as section name. */
11157 len
= note
->namesz
;
11158 name
= (char *) bfd_alloc (abfd
, len
);
11161 memcpy (name
, note
->namedata
, len
);
11162 name
[len
- 1] = '\0';
11164 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
11168 sect
->size
= note
->descsz
;
11169 sect
->filepos
= note
->descpos
;
11170 sect
->alignment_power
= 1;
11175 /* Function: elfcore_write_note
11178 buffer to hold note, and current size of buffer
11182 size of data for note
11184 Writes note to end of buffer. ELF64 notes are written exactly as
11185 for ELF32, despite the current (as of 2006) ELF gabi specifying
11186 that they ought to have 8-byte namesz and descsz field, and have
11187 8-byte alignment. Other writers, eg. Linux kernel, do the same.
11190 Pointer to realloc'd buffer, *BUFSIZ updated. */
11193 elfcore_write_note (bfd
*abfd
,
11201 Elf_External_Note
*xnp
;
11208 namesz
= strlen (name
) + 1;
11210 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
11212 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
11215 dest
= buf
+ *bufsiz
;
11216 *bufsiz
+= newspace
;
11217 xnp
= (Elf_External_Note
*) dest
;
11218 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
11219 H_PUT_32 (abfd
, size
, xnp
->descsz
);
11220 H_PUT_32 (abfd
, type
, xnp
->type
);
11224 memcpy (dest
, name
, namesz
);
11232 memcpy (dest
, input
, size
);
11242 /* gcc-8 warns (*) on all the strncpy calls in this function about
11243 possible string truncation. The "truncation" is not a bug. We
11244 have an external representation of structs with fields that are not
11245 necessarily NULL terminated and corresponding internal
11246 representation fields that are one larger so that they can always
11247 be NULL terminated.
11248 gcc versions between 4.2 and 4.6 do not allow pragma control of
11249 diagnostics inside functions, giving a hard error if you try to use
11250 the finer control available with later versions.
11251 gcc prior to 4.2 warns about diagnostic push and pop.
11252 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11253 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11254 (*) Depending on your system header files! */
11255 #if GCC_VERSION >= 8000
11256 # pragma GCC diagnostic push
11257 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11260 elfcore_write_prpsinfo (bfd
*abfd
,
11264 const char *psargs
)
11266 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11268 if (bed
->elf_backend_write_core_note
!= NULL
)
11271 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11272 NT_PRPSINFO
, fname
, psargs
);
11277 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11278 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11279 if (bed
->s
->elfclass
== ELFCLASS32
)
11281 # if defined (HAVE_PSINFO32_T)
11283 int note_type
= NT_PSINFO
;
11286 int note_type
= NT_PRPSINFO
;
11289 memset (&data
, 0, sizeof (data
));
11290 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11291 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11292 return elfcore_write_note (abfd
, buf
, bufsiz
,
11293 "CORE", note_type
, &data
, sizeof (data
));
11298 # if defined (HAVE_PSINFO_T)
11300 int note_type
= NT_PSINFO
;
11303 int note_type
= NT_PRPSINFO
;
11306 memset (&data
, 0, sizeof (data
));
11307 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11308 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11309 return elfcore_write_note (abfd
, buf
, bufsiz
,
11310 "CORE", note_type
, &data
, sizeof (data
));
11312 #endif /* PSINFO_T or PRPSINFO_T */
11317 #if GCC_VERSION >= 8000
11318 # pragma GCC diagnostic pop
11322 elfcore_write_linux_prpsinfo32
11323 (bfd
*abfd
, char *buf
, int *bufsiz
,
11324 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11326 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11328 struct elf_external_linux_prpsinfo32_ugid16 data
;
11330 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11331 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11332 &data
, sizeof (data
));
11336 struct elf_external_linux_prpsinfo32_ugid32 data
;
11338 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11339 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11340 &data
, sizeof (data
));
11345 elfcore_write_linux_prpsinfo64
11346 (bfd
*abfd
, char *buf
, int *bufsiz
,
11347 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11349 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11351 struct elf_external_linux_prpsinfo64_ugid16 data
;
11353 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11354 return elfcore_write_note (abfd
, buf
, bufsiz
,
11355 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11359 struct elf_external_linux_prpsinfo64_ugid32 data
;
11361 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11362 return elfcore_write_note (abfd
, buf
, bufsiz
,
11363 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11368 elfcore_write_prstatus (bfd
*abfd
,
11375 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11377 if (bed
->elf_backend_write_core_note
!= NULL
)
11380 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11382 pid
, cursig
, gregs
);
11387 #if defined (HAVE_PRSTATUS_T)
11388 #if defined (HAVE_PRSTATUS32_T)
11389 if (bed
->s
->elfclass
== ELFCLASS32
)
11391 prstatus32_t prstat
;
11393 memset (&prstat
, 0, sizeof (prstat
));
11394 prstat
.pr_pid
= pid
;
11395 prstat
.pr_cursig
= cursig
;
11396 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11397 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11398 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11405 memset (&prstat
, 0, sizeof (prstat
));
11406 prstat
.pr_pid
= pid
;
11407 prstat
.pr_cursig
= cursig
;
11408 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11409 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11410 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11412 #endif /* HAVE_PRSTATUS_T */
11418 #if defined (HAVE_LWPSTATUS_T)
11420 elfcore_write_lwpstatus (bfd
*abfd
,
11427 lwpstatus_t lwpstat
;
11428 const char *note_name
= "CORE";
11430 memset (&lwpstat
, 0, sizeof (lwpstat
));
11431 lwpstat
.pr_lwpid
= pid
>> 16;
11432 lwpstat
.pr_cursig
= cursig
;
11433 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11434 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11435 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11436 #if !defined(gregs)
11437 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11438 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11440 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11441 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11444 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11445 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11447 #endif /* HAVE_LWPSTATUS_T */
11449 #if defined (HAVE_PSTATUS_T)
11451 elfcore_write_pstatus (bfd
*abfd
,
11455 int cursig ATTRIBUTE_UNUSED
,
11456 const void *gregs ATTRIBUTE_UNUSED
)
11458 const char *note_name
= "CORE";
11459 #if defined (HAVE_PSTATUS32_T)
11460 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11462 if (bed
->s
->elfclass
== ELFCLASS32
)
11466 memset (&pstat
, 0, sizeof (pstat
));
11467 pstat
.pr_pid
= pid
& 0xffff;
11468 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11469 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11477 memset (&pstat
, 0, sizeof (pstat
));
11478 pstat
.pr_pid
= pid
& 0xffff;
11479 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11480 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11484 #endif /* HAVE_PSTATUS_T */
11487 elfcore_write_prfpreg (bfd
*abfd
,
11490 const void *fpregs
,
11493 const char *note_name
= "CORE";
11494 return elfcore_write_note (abfd
, buf
, bufsiz
,
11495 note_name
, NT_FPREGSET
, fpregs
, size
);
11499 elfcore_write_prxfpreg (bfd
*abfd
,
11502 const void *xfpregs
,
11505 char *note_name
= "LINUX";
11506 return elfcore_write_note (abfd
, buf
, bufsiz
,
11507 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11511 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11512 const void *xfpregs
, int size
)
11515 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11516 note_name
= "FreeBSD";
11518 note_name
= "LINUX";
11519 return elfcore_write_note (abfd
, buf
, bufsiz
,
11520 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11524 elfcore_write_ppc_vmx (bfd
*abfd
,
11527 const void *ppc_vmx
,
11530 char *note_name
= "LINUX";
11531 return elfcore_write_note (abfd
, buf
, bufsiz
,
11532 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11536 elfcore_write_ppc_vsx (bfd
*abfd
,
11539 const void *ppc_vsx
,
11542 char *note_name
= "LINUX";
11543 return elfcore_write_note (abfd
, buf
, bufsiz
,
11544 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11548 elfcore_write_ppc_tar (bfd
*abfd
,
11551 const void *ppc_tar
,
11554 char *note_name
= "LINUX";
11555 return elfcore_write_note (abfd
, buf
, bufsiz
,
11556 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11560 elfcore_write_ppc_ppr (bfd
*abfd
,
11563 const void *ppc_ppr
,
11566 char *note_name
= "LINUX";
11567 return elfcore_write_note (abfd
, buf
, bufsiz
,
11568 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11572 elfcore_write_ppc_dscr (bfd
*abfd
,
11575 const void *ppc_dscr
,
11578 char *note_name
= "LINUX";
11579 return elfcore_write_note (abfd
, buf
, bufsiz
,
11580 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11584 elfcore_write_ppc_ebb (bfd
*abfd
,
11587 const void *ppc_ebb
,
11590 char *note_name
= "LINUX";
11591 return elfcore_write_note (abfd
, buf
, bufsiz
,
11592 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11596 elfcore_write_ppc_pmu (bfd
*abfd
,
11599 const void *ppc_pmu
,
11602 char *note_name
= "LINUX";
11603 return elfcore_write_note (abfd
, buf
, bufsiz
,
11604 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11608 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11611 const void *ppc_tm_cgpr
,
11614 char *note_name
= "LINUX";
11615 return elfcore_write_note (abfd
, buf
, bufsiz
,
11616 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11620 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11623 const void *ppc_tm_cfpr
,
11626 char *note_name
= "LINUX";
11627 return elfcore_write_note (abfd
, buf
, bufsiz
,
11628 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11632 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11635 const void *ppc_tm_cvmx
,
11638 char *note_name
= "LINUX";
11639 return elfcore_write_note (abfd
, buf
, bufsiz
,
11640 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11644 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11647 const void *ppc_tm_cvsx
,
11650 char *note_name
= "LINUX";
11651 return elfcore_write_note (abfd
, buf
, bufsiz
,
11652 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11656 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11659 const void *ppc_tm_spr
,
11662 char *note_name
= "LINUX";
11663 return elfcore_write_note (abfd
, buf
, bufsiz
,
11664 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11668 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11671 const void *ppc_tm_ctar
,
11674 char *note_name
= "LINUX";
11675 return elfcore_write_note (abfd
, buf
, bufsiz
,
11676 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11680 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11683 const void *ppc_tm_cppr
,
11686 char *note_name
= "LINUX";
11687 return elfcore_write_note (abfd
, buf
, bufsiz
,
11688 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11692 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11695 const void *ppc_tm_cdscr
,
11698 char *note_name
= "LINUX";
11699 return elfcore_write_note (abfd
, buf
, bufsiz
,
11700 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11704 elfcore_write_s390_high_gprs (bfd
*abfd
,
11707 const void *s390_high_gprs
,
11710 char *note_name
= "LINUX";
11711 return elfcore_write_note (abfd
, buf
, bufsiz
,
11712 note_name
, NT_S390_HIGH_GPRS
,
11713 s390_high_gprs
, size
);
11717 elfcore_write_s390_timer (bfd
*abfd
,
11720 const void *s390_timer
,
11723 char *note_name
= "LINUX";
11724 return elfcore_write_note (abfd
, buf
, bufsiz
,
11725 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11729 elfcore_write_s390_todcmp (bfd
*abfd
,
11732 const void *s390_todcmp
,
11735 char *note_name
= "LINUX";
11736 return elfcore_write_note (abfd
, buf
, bufsiz
,
11737 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11741 elfcore_write_s390_todpreg (bfd
*abfd
,
11744 const void *s390_todpreg
,
11747 char *note_name
= "LINUX";
11748 return elfcore_write_note (abfd
, buf
, bufsiz
,
11749 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11753 elfcore_write_s390_ctrs (bfd
*abfd
,
11756 const void *s390_ctrs
,
11759 char *note_name
= "LINUX";
11760 return elfcore_write_note (abfd
, buf
, bufsiz
,
11761 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11765 elfcore_write_s390_prefix (bfd
*abfd
,
11768 const void *s390_prefix
,
11771 char *note_name
= "LINUX";
11772 return elfcore_write_note (abfd
, buf
, bufsiz
,
11773 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11777 elfcore_write_s390_last_break (bfd
*abfd
,
11780 const void *s390_last_break
,
11783 char *note_name
= "LINUX";
11784 return elfcore_write_note (abfd
, buf
, bufsiz
,
11785 note_name
, NT_S390_LAST_BREAK
,
11786 s390_last_break
, size
);
11790 elfcore_write_s390_system_call (bfd
*abfd
,
11793 const void *s390_system_call
,
11796 char *note_name
= "LINUX";
11797 return elfcore_write_note (abfd
, buf
, bufsiz
,
11798 note_name
, NT_S390_SYSTEM_CALL
,
11799 s390_system_call
, size
);
11803 elfcore_write_s390_tdb (bfd
*abfd
,
11806 const void *s390_tdb
,
11809 char *note_name
= "LINUX";
11810 return elfcore_write_note (abfd
, buf
, bufsiz
,
11811 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11815 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11818 const void *s390_vxrs_low
,
11821 char *note_name
= "LINUX";
11822 return elfcore_write_note (abfd
, buf
, bufsiz
,
11823 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11827 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11830 const void *s390_vxrs_high
,
11833 char *note_name
= "LINUX";
11834 return elfcore_write_note (abfd
, buf
, bufsiz
,
11835 note_name
, NT_S390_VXRS_HIGH
,
11836 s390_vxrs_high
, size
);
11840 elfcore_write_s390_gs_cb (bfd
*abfd
,
11843 const void *s390_gs_cb
,
11846 char *note_name
= "LINUX";
11847 return elfcore_write_note (abfd
, buf
, bufsiz
,
11848 note_name
, NT_S390_GS_CB
,
11853 elfcore_write_s390_gs_bc (bfd
*abfd
,
11856 const void *s390_gs_bc
,
11859 char *note_name
= "LINUX";
11860 return elfcore_write_note (abfd
, buf
, bufsiz
,
11861 note_name
, NT_S390_GS_BC
,
11866 elfcore_write_arm_vfp (bfd
*abfd
,
11869 const void *arm_vfp
,
11872 char *note_name
= "LINUX";
11873 return elfcore_write_note (abfd
, buf
, bufsiz
,
11874 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11878 elfcore_write_aarch_tls (bfd
*abfd
,
11881 const void *aarch_tls
,
11884 char *note_name
= "LINUX";
11885 return elfcore_write_note (abfd
, buf
, bufsiz
,
11886 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11890 elfcore_write_aarch_hw_break (bfd
*abfd
,
11893 const void *aarch_hw_break
,
11896 char *note_name
= "LINUX";
11897 return elfcore_write_note (abfd
, buf
, bufsiz
,
11898 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11902 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11905 const void *aarch_hw_watch
,
11908 char *note_name
= "LINUX";
11909 return elfcore_write_note (abfd
, buf
, bufsiz
,
11910 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11914 elfcore_write_aarch_sve (bfd
*abfd
,
11917 const void *aarch_sve
,
11920 char *note_name
= "LINUX";
11921 return elfcore_write_note (abfd
, buf
, bufsiz
,
11922 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11926 elfcore_write_aarch_pauth (bfd
*abfd
,
11929 const void *aarch_pauth
,
11932 char *note_name
= "LINUX";
11933 return elfcore_write_note (abfd
, buf
, bufsiz
,
11934 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11938 elfcore_write_arc_v2 (bfd
*abfd
,
11941 const void *arc_v2
,
11944 char *note_name
= "LINUX";
11945 return elfcore_write_note (abfd
, buf
, bufsiz
,
11946 note_name
, NT_ARC_V2
, arc_v2
, size
);
11950 elfcore_write_register_note (bfd
*abfd
,
11953 const char *section
,
11957 if (strcmp (section
, ".reg2") == 0)
11958 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
11959 if (strcmp (section
, ".reg-xfp") == 0)
11960 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
11961 if (strcmp (section
, ".reg-xstate") == 0)
11962 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
11963 if (strcmp (section
, ".reg-ppc-vmx") == 0)
11964 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
11965 if (strcmp (section
, ".reg-ppc-vsx") == 0)
11966 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
11967 if (strcmp (section
, ".reg-ppc-tar") == 0)
11968 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
11969 if (strcmp (section
, ".reg-ppc-ppr") == 0)
11970 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
11971 if (strcmp (section
, ".reg-ppc-dscr") == 0)
11972 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
11973 if (strcmp (section
, ".reg-ppc-ebb") == 0)
11974 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
11975 if (strcmp (section
, ".reg-ppc-pmu") == 0)
11976 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
11977 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
11978 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
11979 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
11980 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
11981 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
11982 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
11983 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
11984 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
11985 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
11986 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
11987 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
11988 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
11989 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
11990 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
11991 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
11992 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
11993 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
11994 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
11995 if (strcmp (section
, ".reg-s390-timer") == 0)
11996 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
11997 if (strcmp (section
, ".reg-s390-todcmp") == 0)
11998 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
11999 if (strcmp (section
, ".reg-s390-todpreg") == 0)
12000 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
12001 if (strcmp (section
, ".reg-s390-ctrs") == 0)
12002 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
12003 if (strcmp (section
, ".reg-s390-prefix") == 0)
12004 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
12005 if (strcmp (section
, ".reg-s390-last-break") == 0)
12006 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
12007 if (strcmp (section
, ".reg-s390-system-call") == 0)
12008 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
12009 if (strcmp (section
, ".reg-s390-tdb") == 0)
12010 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
12011 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
12012 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
12013 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
12014 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
12015 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
12016 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
12017 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
12018 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
12019 if (strcmp (section
, ".reg-arm-vfp") == 0)
12020 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
12021 if (strcmp (section
, ".reg-aarch-tls") == 0)
12022 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
12023 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
12024 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
12025 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
12026 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
12027 if (strcmp (section
, ".reg-aarch-sve") == 0)
12028 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
12029 if (strcmp (section
, ".reg-aarch-pauth") == 0)
12030 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
12031 if (strcmp (section
, ".reg-arc-v2") == 0)
12032 return elfcore_write_arc_v2 (abfd
, buf
, bufsiz
, data
, size
);
12037 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
12042 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
12043 gABI specifies that PT_NOTE alignment should be aligned to 4
12044 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
12045 align is less than 4, we use 4 byte alignment. */
12048 if (align
!= 4 && align
!= 8)
12052 while (p
< buf
+ size
)
12054 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
12055 Elf_Internal_Note in
;
12057 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
12060 in
.type
= H_GET_32 (abfd
, xnp
->type
);
12062 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
12063 in
.namedata
= xnp
->name
;
12064 if (in
.namesz
> buf
- in
.namedata
+ size
)
12067 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
12068 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
12069 in
.descpos
= offset
+ (in
.descdata
- buf
);
12071 && (in
.descdata
>= buf
+ size
12072 || in
.descsz
> buf
- in
.descdata
+ size
))
12075 switch (bfd_get_format (abfd
))
12082 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
12085 const char * string
;
12087 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
12091 GROKER_ELEMENT ("", elfcore_grok_note
),
12092 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
12093 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
12094 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
12095 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
12096 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
12097 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
12099 #undef GROKER_ELEMENT
12102 for (i
= ARRAY_SIZE (grokers
); i
--;)
12104 if (in
.namesz
>= grokers
[i
].len
12105 && strncmp (in
.namedata
, grokers
[i
].string
,
12106 grokers
[i
].len
) == 0)
12108 if (! grokers
[i
].func (abfd
, & in
))
12117 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
12119 if (! elfobj_grok_gnu_note (abfd
, &in
))
12122 else if (in
.namesz
== sizeof "stapsdt"
12123 && strcmp (in
.namedata
, "stapsdt") == 0)
12125 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
12131 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
12138 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
12143 if (size
== 0 || (size
+ 1) == 0)
12146 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
12149 buf
= (char *) _bfd_malloc_and_read (abfd
, size
+ 1, size
);
12153 /* PR 17512: file: ec08f814
12154 0-termintate the buffer so that string searches will not overflow. */
12157 if (!elf_parse_notes (abfd
, buf
, size
, offset
, align
))
12167 /* Providing external access to the ELF program header table. */
12169 /* Return an upper bound on the number of bytes required to store a
12170 copy of ABFD's program header table entries. Return -1 if an error
12171 occurs; bfd_get_error will return an appropriate code. */
12174 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
12176 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12178 bfd_set_error (bfd_error_wrong_format
);
12182 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
12185 /* Copy ABFD's program header table entries to *PHDRS. The entries
12186 will be stored as an array of Elf_Internal_Phdr structures, as
12187 defined in include/elf/internal.h. To find out how large the
12188 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
12190 Return the number of program header table entries read, or -1 if an
12191 error occurs; bfd_get_error will return an appropriate code. */
12194 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
12198 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
12200 bfd_set_error (bfd_error_wrong_format
);
12204 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
12205 if (num_phdrs
!= 0)
12206 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
12207 num_phdrs
* sizeof (Elf_Internal_Phdr
));
12212 enum elf_reloc_type_class
12213 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
12214 const asection
*rel_sec ATTRIBUTE_UNUSED
,
12215 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
12217 return reloc_class_normal
;
12220 /* For RELA architectures, return the relocation value for a
12221 relocation against a local symbol. */
12224 _bfd_elf_rela_local_sym (bfd
*abfd
,
12225 Elf_Internal_Sym
*sym
,
12227 Elf_Internal_Rela
*rel
)
12229 asection
*sec
= *psec
;
12230 bfd_vma relocation
;
12232 relocation
= (sec
->output_section
->vma
12233 + sec
->output_offset
12235 if ((sec
->flags
& SEC_MERGE
)
12236 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
12237 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12240 _bfd_merged_section_offset (abfd
, psec
,
12241 elf_section_data (sec
)->sec_info
,
12242 sym
->st_value
+ rel
->r_addend
);
12245 /* If we have changed the section, and our original section is
12246 marked with SEC_EXCLUDE, it means that the original
12247 SEC_MERGE section has been completely subsumed in some
12248 other SEC_MERGE section. In this case, we need to leave
12249 some info around for --emit-relocs. */
12250 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12251 sec
->kept_section
= *psec
;
12254 rel
->r_addend
-= relocation
;
12255 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12261 _bfd_elf_rel_local_sym (bfd
*abfd
,
12262 Elf_Internal_Sym
*sym
,
12266 asection
*sec
= *psec
;
12268 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12269 return sym
->st_value
+ addend
;
12271 return _bfd_merged_section_offset (abfd
, psec
,
12272 elf_section_data (sec
)->sec_info
,
12273 sym
->st_value
+ addend
);
12276 /* Adjust an address within a section. Given OFFSET within SEC, return
12277 the new offset within the section, based upon changes made to the
12278 section. Returns -1 if the offset is now invalid.
12279 The offset (in abnd out) is in target sized bytes, however big a
12283 _bfd_elf_section_offset (bfd
*abfd
,
12284 struct bfd_link_info
*info
,
12288 switch (sec
->sec_info_type
)
12290 case SEC_INFO_TYPE_STABS
:
12291 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12293 case SEC_INFO_TYPE_EH_FRAME
:
12294 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12297 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12299 /* Reverse the offset. */
12300 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12301 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12303 /* address_size and sec->size are in octets. Convert
12304 to bytes before subtracting the original offset. */
12305 offset
= ((sec
->size
- address_size
)
12306 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12312 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12313 reconstruct an ELF file by reading the segments out of remote memory
12314 based on the ELF file header at EHDR_VMA and the ELF program headers it
12315 points to. If not null, *LOADBASEP is filled in with the difference
12316 between the VMAs from which the segments were read, and the VMAs the
12317 file headers (and hence BFD's idea of each section's VMA) put them at.
12319 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12320 remote memory at target address VMA into the local buffer at MYADDR; it
12321 should return zero on success or an `errno' code on failure. TEMPL must
12322 be a BFD for an ELF target with the word size and byte order found in
12323 the remote memory. */
12326 bfd_elf_bfd_from_remote_memory
12329 bfd_size_type size
,
12330 bfd_vma
*loadbasep
,
12331 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12333 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12334 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12338 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12339 long symcount ATTRIBUTE_UNUSED
,
12340 asymbol
**syms ATTRIBUTE_UNUSED
,
12345 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12348 const char *relplt_name
;
12349 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
12353 Elf_Internal_Shdr
*hdr
;
12359 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12362 if (dynsymcount
<= 0)
12365 if (!bed
->plt_sym_val
)
12368 relplt_name
= bed
->relplt_name
;
12369 if (relplt_name
== NULL
)
12370 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12371 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12372 if (relplt
== NULL
)
12375 hdr
= &elf_section_data (relplt
)->this_hdr
;
12376 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12377 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12380 plt
= bfd_get_section_by_name (abfd
, ".plt");
12384 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12385 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
12388 count
= relplt
->size
/ hdr
->sh_entsize
;
12389 size
= count
* sizeof (asymbol
);
12390 p
= relplt
->relocation
;
12391 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12393 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12394 if (p
->addend
!= 0)
12397 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12399 size
+= sizeof ("+0x") - 1 + 8;
12404 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12408 names
= (char *) (s
+ count
);
12409 p
= relplt
->relocation
;
12411 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12416 addr
= bed
->plt_sym_val (i
, plt
, p
);
12417 if (addr
== (bfd_vma
) -1)
12420 *s
= **p
->sym_ptr_ptr
;
12421 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12422 we are defining a symbol, ensure one of them is set. */
12423 if ((s
->flags
& BSF_LOCAL
) == 0)
12424 s
->flags
|= BSF_GLOBAL
;
12425 s
->flags
|= BSF_SYNTHETIC
;
12427 s
->value
= addr
- plt
->vma
;
12430 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12431 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12433 if (p
->addend
!= 0)
12437 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12438 names
+= sizeof ("+0x") - 1;
12439 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12440 for (a
= buf
; *a
== '0'; ++a
)
12443 memcpy (names
, a
, len
);
12446 memcpy (names
, "@plt", sizeof ("@plt"));
12447 names
+= sizeof ("@plt");
12454 /* It is only used by x86-64 so far.
12455 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12456 but current usage would allow all of _bfd_std_section to be zero. */
12457 static const asymbol lcomm_sym
12458 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12459 asection _bfd_elf_large_com_section
12460 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12461 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12464 _bfd_elf_final_write_processing (bfd
*abfd
)
12466 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12468 i_ehdrp
= elf_elfheader (abfd
);
12470 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12471 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12473 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12474 SHF_GNU_MBIND or SHF_GNU_RETAIN sections or symbols of STT_GNU_IFUNC type
12475 or STB_GNU_UNIQUE binding. */
12476 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12478 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12479 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12480 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12481 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12483 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12484 _bfd_error_handler (_("GNU_MBIND section is supported only by GNU "
12485 "and FreeBSD targets"));
12486 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12487 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is supported "
12488 "only by GNU and FreeBSD targets"));
12489 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12490 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is supported "
12491 "only by GNU and FreeBSD targets"));
12492 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_retain
)
12493 _bfd_error_handler (_("GNU_RETAIN section is supported "
12494 "only by GNU and FreeBSD targets"));
12495 bfd_set_error (bfd_error_sorry
);
12503 /* Return TRUE for ELF symbol types that represent functions.
12504 This is the default version of this function, which is sufficient for
12505 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12508 _bfd_elf_is_function_type (unsigned int type
)
12510 return (type
== STT_FUNC
12511 || type
== STT_GNU_IFUNC
);
12514 /* If the ELF symbol SYM might be a function in SEC, return the
12515 function size and set *CODE_OFF to the function's entry point,
12516 otherwise return zero. */
12519 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12522 bfd_size_type size
;
12524 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12525 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12526 || sym
->section
!= sec
)
12529 *code_off
= sym
->value
;
12531 if (!(sym
->flags
& BSF_SYNTHETIC
))
12532 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
12538 /* Set to non-zero to enable some debug messages. */
12539 #define DEBUG_SECONDARY_RELOCS 0
12541 /* An internal-to-the-bfd-library only section type
12542 used to indicate a cached secondary reloc section. */
12543 #define SHT_SECONDARY_RELOC (SHT_LOOS + SHT_RELA)
12545 /* Create a BFD section to hold a secondary reloc section. */
12548 _bfd_elf_init_secondary_reloc_section (bfd
* abfd
,
12549 Elf_Internal_Shdr
*hdr
,
12551 unsigned int shindex
)
12553 /* We only support RELA secondary relocs. */
12554 if (hdr
->sh_type
!= SHT_RELA
)
12557 #if DEBUG_SECONDARY_RELOCS
12558 fprintf (stderr
, "secondary reloc section %s encountered\n", name
);
12560 hdr
->sh_type
= SHT_SECONDARY_RELOC
;
12561 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
12564 /* Read in any secondary relocs associated with SEC. */
12567 _bfd_elf_slurp_secondary_reloc_section (bfd
* abfd
,
12569 asymbol
** symbols
,
12570 bfd_boolean dynamic
)
12572 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12574 bfd_boolean result
= TRUE
;
12575 bfd_vma (*r_sym
) (bfd_vma
);
12577 #if BFD_DEFAULT_TARGET_SIZE > 32
12578 if (bfd_arch_bits_per_address (abfd
) != 32)
12579 r_sym
= elf64_r_sym
;
12582 r_sym
= elf32_r_sym
;
12584 /* Discover if there are any secondary reloc sections
12585 associated with SEC. */
12586 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12588 Elf_Internal_Shdr
* hdr
= & elf_section_data (relsec
)->this_hdr
;
12590 if (hdr
->sh_type
== SHT_SECONDARY_RELOC
12591 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
12592 && (hdr
->sh_entsize
== ebd
->s
->sizeof_rel
12593 || hdr
->sh_entsize
== ebd
->s
->sizeof_rela
))
12595 bfd_byte
* native_relocs
;
12596 bfd_byte
* native_reloc
;
12597 arelent
* internal_relocs
;
12598 arelent
* internal_reloc
;
12600 unsigned int entsize
;
12601 unsigned int symcount
;
12602 unsigned int reloc_count
;
12605 if (ebd
->elf_info_to_howto
== NULL
)
12608 #if DEBUG_SECONDARY_RELOCS
12609 fprintf (stderr
, "read secondary relocs for %s from %s\n",
12610 sec
->name
, relsec
->name
);
12612 entsize
= hdr
->sh_entsize
;
12614 native_relocs
= bfd_malloc (hdr
->sh_size
);
12615 if (native_relocs
== NULL
)
12621 reloc_count
= NUM_SHDR_ENTRIES (hdr
);
12622 if (_bfd_mul_overflow (reloc_count
, sizeof (arelent
), & amt
))
12624 free (native_relocs
);
12625 bfd_set_error (bfd_error_file_too_big
);
12630 internal_relocs
= (arelent
*) bfd_alloc (abfd
, amt
);
12631 if (internal_relocs
== NULL
)
12633 free (native_relocs
);
12638 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
12639 || (bfd_bread (native_relocs
, hdr
->sh_size
, abfd
)
12642 free (native_relocs
);
12643 /* The internal_relocs will be freed when
12644 the memory for the bfd is released. */
12650 symcount
= bfd_get_dynamic_symcount (abfd
);
12652 symcount
= bfd_get_symcount (abfd
);
12654 for (i
= 0, internal_reloc
= internal_relocs
,
12655 native_reloc
= native_relocs
;
12657 i
++, internal_reloc
++, native_reloc
+= entsize
)
12660 Elf_Internal_Rela rela
;
12662 if (entsize
== ebd
->s
->sizeof_rel
)
12663 ebd
->s
->swap_reloc_in (abfd
, native_reloc
, & rela
);
12664 else /* entsize == ebd->s->sizeof_rela */
12665 ebd
->s
->swap_reloca_in (abfd
, native_reloc
, & rela
);
12667 /* The address of an ELF reloc is section relative for an object
12668 file, and absolute for an executable file or shared library.
12669 The address of a normal BFD reloc is always section relative,
12670 and the address of a dynamic reloc is absolute.. */
12671 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
12672 internal_reloc
->address
= rela
.r_offset
;
12674 internal_reloc
->address
= rela
.r_offset
- sec
->vma
;
12676 if (r_sym (rela
.r_info
) == STN_UNDEF
)
12678 /* FIXME: This and the error case below mean that we
12679 have a symbol on relocs that is not elf_symbol_type. */
12680 internal_reloc
->sym_ptr_ptr
=
12681 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12683 else if (r_sym (rela
.r_info
) > symcount
)
12686 /* xgettext:c-format */
12687 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
12688 abfd
, sec
, i
, (long) r_sym (rela
.r_info
));
12689 bfd_set_error (bfd_error_bad_value
);
12690 internal_reloc
->sym_ptr_ptr
=
12691 bfd_abs_section_ptr
->symbol_ptr_ptr
;
12698 ps
= symbols
+ r_sym (rela
.r_info
) - 1;
12699 internal_reloc
->sym_ptr_ptr
= ps
;
12700 /* Make sure that this symbol is not removed by strip. */
12701 (*ps
)->flags
|= BSF_KEEP
;
12704 internal_reloc
->addend
= rela
.r_addend
;
12706 res
= ebd
->elf_info_to_howto (abfd
, internal_reloc
, & rela
);
12707 if (! res
|| internal_reloc
->howto
== NULL
)
12709 #if DEBUG_SECONDARY_RELOCS
12710 fprintf (stderr
, "there is no howto associated with reloc %lx\n",
12717 free (native_relocs
);
12718 /* Store the internal relocs. */
12719 elf_section_data (relsec
)->sec_info
= internal_relocs
;
12726 /* Set the ELF section header fields of an output secondary reloc section. */
12729 _bfd_elf_copy_special_section_fields (const bfd
* ibfd ATTRIBUTE_UNUSED
,
12730 bfd
* obfd ATTRIBUTE_UNUSED
,
12731 const Elf_Internal_Shdr
* isection
,
12732 Elf_Internal_Shdr
* osection
)
12736 struct bfd_elf_section_data
* esd
;
12738 if (isection
== NULL
)
12741 if (isection
->sh_type
!= SHT_SECONDARY_RELOC
)
12744 isec
= isection
->bfd_section
;
12748 osec
= osection
->bfd_section
;
12752 esd
= elf_section_data (osec
);
12753 BFD_ASSERT (esd
->sec_info
== NULL
);
12754 esd
->sec_info
= elf_section_data (isec
)->sec_info
;
12755 osection
->sh_type
= SHT_RELA
;
12756 osection
->sh_link
= elf_onesymtab (obfd
);
12757 if (osection
->sh_link
== 0)
12759 /* There is no symbol table - we are hosed... */
12761 /* xgettext:c-format */
12762 (_("%pB(%pA): link section cannot be set because the output file does not have a symbol table"),
12764 bfd_set_error (bfd_error_bad_value
);
12768 /* Find the output section that corresponds to the isection's sh_info link. */
12769 if (isection
->sh_info
== 0
12770 || isection
->sh_info
>= elf_numsections (ibfd
))
12773 /* xgettext:c-format */
12774 (_("%pB(%pA): info section index is invalid"),
12776 bfd_set_error (bfd_error_bad_value
);
12780 isection
= elf_elfsections (ibfd
)[isection
->sh_info
];
12782 if (isection
== NULL
12783 || isection
->bfd_section
== NULL
12784 || isection
->bfd_section
->output_section
== NULL
)
12787 /* xgettext:c-format */
12788 (_("%pB(%pA): info section index cannot be set because the section is not in the output"),
12790 bfd_set_error (bfd_error_bad_value
);
12794 esd
= elf_section_data (isection
->bfd_section
->output_section
);
12795 BFD_ASSERT (esd
!= NULL
);
12796 osection
->sh_info
= esd
->this_idx
;
12797 esd
->has_secondary_relocs
= TRUE
;
12798 #if DEBUG_SECONDARY_RELOCS
12799 fprintf (stderr
, "update header of %s, sh_link = %u, sh_info = %u\n",
12800 osec
->name
, osection
->sh_link
, osection
->sh_info
);
12801 fprintf (stderr
, "mark section %s as having secondary relocs\n",
12802 bfd_section_name (isection
->bfd_section
->output_section
));
12808 /* Write out a secondary reloc section.
12810 FIXME: Currently this function can result in a serious performance penalty
12811 for files with secondary relocs and lots of sections. The proper way to
12812 fix this is for _bfd_elf_copy_special_section_fields() to chain secondary
12813 relocs together and then to have this function just walk that chain. */
12816 _bfd_elf_write_secondary_reloc_section (bfd
*abfd
, asection
*sec
)
12818 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
12819 bfd_vma addr_offset
;
12821 bfd_vma (*r_info
) (bfd_vma
, bfd_vma
);
12822 bfd_boolean result
= TRUE
;
12827 #if BFD_DEFAULT_TARGET_SIZE > 32
12828 if (bfd_arch_bits_per_address (abfd
) != 32)
12829 r_info
= elf64_r_info
;
12832 r_info
= elf32_r_info
;
12834 /* The address of an ELF reloc is section relative for an object
12835 file, and absolute for an executable file or shared library.
12836 The address of a BFD reloc is always section relative. */
12838 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
12839 addr_offset
= sec
->vma
;
12841 /* Discover if there are any secondary reloc sections
12842 associated with SEC. */
12843 for (relsec
= abfd
->sections
; relsec
!= NULL
; relsec
= relsec
->next
)
12845 const struct bfd_elf_section_data
* const esd
= elf_section_data (relsec
);
12846 Elf_Internal_Shdr
* const hdr
= (Elf_Internal_Shdr
*) & esd
->this_hdr
;
12848 if (hdr
->sh_type
== SHT_RELA
12849 && hdr
->sh_info
== (unsigned) elf_section_data (sec
)->this_idx
)
12851 asymbol
* last_sym
;
12853 unsigned int reloc_count
;
12855 unsigned int entsize
;
12856 arelent
* src_irel
;
12857 bfd_byte
* dst_rela
;
12859 if (hdr
->contents
!= NULL
)
12862 /* xgettext:c-format */
12863 (_("%pB(%pA): error: secondary reloc section processed twice"),
12865 bfd_set_error (bfd_error_bad_value
);
12870 entsize
= hdr
->sh_entsize
;
12874 /* xgettext:c-format */
12875 (_("%pB(%pA): error: secondary reloc section has zero sized entries"),
12877 bfd_set_error (bfd_error_bad_value
);
12881 else if (entsize
!= ebd
->s
->sizeof_rel
12882 && entsize
!= ebd
->s
->sizeof_rela
)
12885 /* xgettext:c-format */
12886 (_("%pB(%pA): error: secondary reloc section has non-standard sized entries"),
12888 bfd_set_error (bfd_error_bad_value
);
12893 reloc_count
= hdr
->sh_size
/ entsize
;
12894 if (reloc_count
<= 0)
12897 /* xgettext:c-format */
12898 (_("%pB(%pA): error: secondary reloc section is empty!"),
12900 bfd_set_error (bfd_error_bad_value
);
12905 hdr
->contents
= bfd_alloc (abfd
, hdr
->sh_size
);
12906 if (hdr
->contents
== NULL
)
12909 #if DEBUG_SECONDARY_RELOCS
12910 fprintf (stderr
, "write %u secondary relocs for %s from %s\n",
12911 reloc_count
, sec
->name
, relsec
->name
);
12915 dst_rela
= hdr
->contents
;
12916 src_irel
= (arelent
*) esd
->sec_info
;
12917 if (src_irel
== NULL
)
12920 /* xgettext:c-format */
12921 (_("%pB(%pA): error: internal relocs missing for secondary reloc section"),
12923 bfd_set_error (bfd_error_bad_value
);
12928 for (idx
= 0; idx
< reloc_count
; idx
++, dst_rela
+= entsize
)
12930 Elf_Internal_Rela src_rela
;
12935 ptr
= src_irel
+ idx
;
12939 /* xgettext:c-format */
12940 (_("%pB(%pA): error: reloc table entry %u is empty"),
12941 abfd
, relsec
, idx
);
12942 bfd_set_error (bfd_error_bad_value
);
12947 if (ptr
->sym_ptr_ptr
== NULL
)
12949 /* FIXME: Is this an error ? */
12954 sym
= *ptr
->sym_ptr_ptr
;
12956 if (sym
== last_sym
)
12960 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, & sym
);
12964 /* xgettext:c-format */
12965 (_("%pB(%pA): error: secondary reloc %u references a missing symbol"),
12966 abfd
, relsec
, idx
);
12967 bfd_set_error (bfd_error_bad_value
);
12976 if (sym
->the_bfd
!= NULL
12977 && sym
->the_bfd
->xvec
!= abfd
->xvec
12978 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
12981 /* xgettext:c-format */
12982 (_("%pB(%pA): error: secondary reloc %u references a deleted symbol"),
12983 abfd
, relsec
, idx
);
12984 bfd_set_error (bfd_error_bad_value
);
12990 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
12991 if (ptr
->howto
== NULL
)
12994 /* xgettext:c-format */
12995 (_("%pB(%pA): error: secondary reloc %u is of an unknown type"),
12996 abfd
, relsec
, idx
);
12997 bfd_set_error (bfd_error_bad_value
);
12999 src_rela
.r_info
= r_info (0, 0);
13002 src_rela
.r_info
= r_info (n
, ptr
->howto
->type
);
13003 src_rela
.r_addend
= ptr
->addend
;
13005 if (entsize
== ebd
->s
->sizeof_rel
)
13006 ebd
->s
->swap_reloc_out (abfd
, &src_rela
, dst_rela
);
13007 else /* entsize == ebd->s->sizeof_rela */
13008 ebd
->s
->swap_reloca_out (abfd
, &src_rela
, dst_rela
);