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 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
56 file_ptr offset
, size_t align
);
58 /* Swap version information in and out. The version information is
59 currently size independent. If that ever changes, this code will
60 need to move into elfcode.h. */
62 /* Swap in a Verdef structure. */
65 _bfd_elf_swap_verdef_in (bfd
*abfd
,
66 const Elf_External_Verdef
*src
,
67 Elf_Internal_Verdef
*dst
)
69 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
70 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
71 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
72 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
73 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
74 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
75 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (bfd
*abfd
,
82 const Elf_Internal_Verdef
*src
,
83 Elf_External_Verdef
*dst
)
85 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
86 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
87 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
88 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
89 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
90 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
91 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
94 /* Swap in a Verdaux structure. */
97 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
98 const Elf_External_Verdaux
*src
,
99 Elf_Internal_Verdaux
*dst
)
101 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
102 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
105 /* Swap out a Verdaux structure. */
108 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
109 const Elf_Internal_Verdaux
*src
,
110 Elf_External_Verdaux
*dst
)
112 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
113 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
116 /* Swap in a Verneed structure. */
119 _bfd_elf_swap_verneed_in (bfd
*abfd
,
120 const Elf_External_Verneed
*src
,
121 Elf_Internal_Verneed
*dst
)
123 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
124 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
125 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
126 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
127 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
130 /* Swap out a Verneed structure. */
133 _bfd_elf_swap_verneed_out (bfd
*abfd
,
134 const Elf_Internal_Verneed
*src
,
135 Elf_External_Verneed
*dst
)
137 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
138 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
139 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
140 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
141 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
144 /* Swap in a Vernaux structure. */
147 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
148 const Elf_External_Vernaux
*src
,
149 Elf_Internal_Vernaux
*dst
)
151 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
152 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
153 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
154 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
155 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
158 /* Swap out a Vernaux structure. */
161 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
162 const Elf_Internal_Vernaux
*src
,
163 Elf_External_Vernaux
*dst
)
165 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
166 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
167 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
168 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
169 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
172 /* Swap in a Versym structure. */
175 _bfd_elf_swap_versym_in (bfd
*abfd
,
176 const Elf_External_Versym
*src
,
177 Elf_Internal_Versym
*dst
)
179 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
182 /* Swap out a Versym structure. */
185 _bfd_elf_swap_versym_out (bfd
*abfd
,
186 const Elf_Internal_Versym
*src
,
187 Elf_External_Versym
*dst
)
189 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
192 /* Standard ELF hash function. Do not change this function; you will
193 cause invalid hash tables to be generated. */
196 bfd_elf_hash (const char *namearg
)
198 const unsigned char *name
= (const unsigned char *) namearg
;
203 while ((ch
= *name
++) != '\0')
206 if ((g
= (h
& 0xf0000000)) != 0)
209 /* The ELF ABI says `h &= ~g', but this is equivalent in
210 this case and on some machines one insn instead of two. */
214 return h
& 0xffffffff;
217 /* DT_GNU_HASH hash function. Do not change this function; you will
218 cause invalid hash tables to be generated. */
221 bfd_elf_gnu_hash (const char *namearg
)
223 const unsigned char *name
= (const unsigned char *) namearg
;
224 unsigned long h
= 5381;
227 while ((ch
= *name
++) != '\0')
228 h
= (h
<< 5) + h
+ ch
;
229 return h
& 0xffffffff;
232 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
233 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
235 bfd_elf_allocate_object (bfd
*abfd
,
237 enum elf_target_id object_id
)
239 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
240 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
241 if (abfd
->tdata
.any
== NULL
)
244 elf_object_id (abfd
) = object_id
;
245 if (abfd
->direction
!= read_direction
)
247 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
250 elf_tdata (abfd
)->o
= o
;
251 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
258 bfd_elf_make_object (bfd
*abfd
)
260 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
261 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
266 bfd_elf_mkcorefile (bfd
*abfd
)
268 /* I think this can be done just like an object file. */
269 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
271 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
272 return elf_tdata (abfd
)->core
!= NULL
;
276 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
278 Elf_Internal_Shdr
**i_shdrp
;
279 bfd_byte
*shstrtab
= NULL
;
281 bfd_size_type shstrtabsize
;
283 i_shdrp
= elf_elfsections (abfd
);
285 || shindex
>= elf_numsections (abfd
)
286 || i_shdrp
[shindex
] == 0)
289 shstrtab
= i_shdrp
[shindex
]->contents
;
290 if (shstrtab
== NULL
)
292 /* No cached one, attempt to read, and cache what we read. */
293 offset
= i_shdrp
[shindex
]->sh_offset
;
294 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
296 /* Allocate and clear an extra byte at the end, to prevent crashes
297 in case the string table is not terminated. */
298 if (shstrtabsize
+ 1 <= 1
299 || shstrtabsize
> bfd_get_file_size (abfd
)
300 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
301 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
)
303 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
305 if (bfd_get_error () != bfd_error_system_call
)
306 bfd_set_error (bfd_error_file_truncated
);
307 bfd_release (abfd
, shstrtab
);
309 /* Once we've failed to read it, make sure we don't keep
310 trying. Otherwise, we'll keep allocating space for
311 the string table over and over. */
312 i_shdrp
[shindex
]->sh_size
= 0;
315 shstrtab
[shstrtabsize
] = '\0';
316 i_shdrp
[shindex
]->contents
= shstrtab
;
318 return (char *) shstrtab
;
322 bfd_elf_string_from_elf_section (bfd
*abfd
,
323 unsigned int shindex
,
324 unsigned int strindex
)
326 Elf_Internal_Shdr
*hdr
;
331 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
334 hdr
= elf_elfsections (abfd
)[shindex
];
336 if (hdr
->contents
== NULL
)
338 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
340 /* PR 17512: file: f057ec89. */
341 /* xgettext:c-format */
342 _bfd_error_handler (_("%pB: attempt to load strings from"
343 " a non-string section (number %d)"),
348 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
353 /* PR 24273: The string section's contents may have already
354 been loaded elsewhere, eg because a corrupt file has the
355 string section index in the ELF header pointing at a group
356 section. So be paranoid, and test that the last byte of
357 the section is zero. */
358 if (hdr
->sh_size
== 0 || hdr
->contents
[hdr
->sh_size
- 1] != 0)
362 if (strindex
>= hdr
->sh_size
)
364 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
366 /* xgettext:c-format */
367 (_("%pB: invalid string offset %u >= %" PRIu64
" for section `%s'"),
368 abfd
, strindex
, (uint64_t) hdr
->sh_size
,
369 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
371 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
375 return ((char *) hdr
->contents
) + strindex
;
378 /* Read and convert symbols to internal format.
379 SYMCOUNT specifies the number of symbols to read, starting from
380 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
381 are non-NULL, they are used to store the internal symbols, external
382 symbols, and symbol section index extensions, respectively.
383 Returns a pointer to the internal symbol buffer (malloced if necessary)
384 or NULL if there were no symbols or some kind of problem. */
387 bfd_elf_get_elf_syms (bfd
*ibfd
,
388 Elf_Internal_Shdr
*symtab_hdr
,
391 Elf_Internal_Sym
*intsym_buf
,
393 Elf_External_Sym_Shndx
*extshndx_buf
)
395 Elf_Internal_Shdr
*shndx_hdr
;
397 const bfd_byte
*esym
;
398 Elf_External_Sym_Shndx
*alloc_extshndx
;
399 Elf_External_Sym_Shndx
*shndx
;
400 Elf_Internal_Sym
*alloc_intsym
;
401 Elf_Internal_Sym
*isym
;
402 Elf_Internal_Sym
*isymend
;
403 const struct elf_backend_data
*bed
;
408 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
414 /* Normal syms might have section extension entries. */
416 if (elf_symtab_shndx_list (ibfd
) != NULL
)
418 elf_section_list
* entry
;
419 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
421 /* Find an index section that is linked to this symtab section. */
422 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
425 if (entry
->hdr
.sh_link
>= elf_numsections (ibfd
))
428 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
430 shndx_hdr
= & entry
->hdr
;
435 if (shndx_hdr
== NULL
)
437 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
438 /* Not really accurate, but this was how the old code used to work. */
439 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
440 /* Otherwise we do nothing. The assumption is that
441 the index table will not be needed. */
445 /* Read the symbols. */
447 alloc_extshndx
= NULL
;
449 bed
= get_elf_backend_data (ibfd
);
450 extsym_size
= bed
->s
->sizeof_sym
;
451 amt
= (bfd_size_type
) symcount
* extsym_size
;
452 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
453 if (extsym_buf
== NULL
)
455 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
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 amt
= (bfd_size_type
) symcount
* sizeof (Elf_External_Sym_Shndx
);
471 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
472 if (extshndx_buf
== NULL
)
474 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
475 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
476 extshndx_buf
= alloc_extshndx
;
478 if (extshndx_buf
== NULL
479 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
480 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
487 if (intsym_buf
== NULL
)
489 alloc_intsym
= (Elf_Internal_Sym
*)
490 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
491 intsym_buf
= alloc_intsym
;
492 if (intsym_buf
== NULL
)
496 /* Convert the symbols to internal form. */
497 isymend
= intsym_buf
+ symcount
;
498 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
499 shndx
= extshndx_buf
;
501 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
502 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
504 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
505 /* xgettext:c-format */
506 _bfd_error_handler (_("%pB symbol number %lu references"
507 " nonexistent SHT_SYMTAB_SHNDX section"),
508 ibfd
, (unsigned long) symoffset
);
509 if (alloc_intsym
!= NULL
)
516 if (alloc_ext
!= NULL
)
518 if (alloc_extshndx
!= NULL
)
519 free (alloc_extshndx
);
524 /* Look up a symbol name. */
526 bfd_elf_sym_name (bfd
*abfd
,
527 Elf_Internal_Shdr
*symtab_hdr
,
528 Elf_Internal_Sym
*isym
,
532 unsigned int iname
= isym
->st_name
;
533 unsigned int shindex
= symtab_hdr
->sh_link
;
535 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
536 /* Check for a bogus st_shndx to avoid crashing. */
537 && isym
->st_shndx
< elf_numsections (abfd
))
539 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
540 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
543 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
546 else if (sym_sec
&& *name
== '\0')
547 name
= bfd_section_name (sym_sec
);
552 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
553 sections. The first element is the flags, the rest are section
556 typedef union elf_internal_group
{
557 Elf_Internal_Shdr
*shdr
;
559 } Elf_Internal_Group
;
561 /* Return the name of the group signature symbol. Why isn't the
562 signature just a string? */
565 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
567 Elf_Internal_Shdr
*hdr
;
568 unsigned char esym
[sizeof (Elf64_External_Sym
)];
569 Elf_External_Sym_Shndx eshndx
;
570 Elf_Internal_Sym isym
;
572 /* First we need to ensure the symbol table is available. Make sure
573 that it is a symbol table section. */
574 if (ghdr
->sh_link
>= elf_numsections (abfd
))
576 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
577 if (hdr
->sh_type
!= SHT_SYMTAB
578 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
581 /* Go read the symbol. */
582 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
583 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
584 &isym
, esym
, &eshndx
) == NULL
)
587 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
590 /* Set next_in_group list pointer, and group name for NEWSECT. */
593 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
595 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
597 /* If num_group is zero, read in all SHT_GROUP sections. The count
598 is set to -1 if there are no SHT_GROUP sections. */
601 unsigned int i
, shnum
;
603 /* First count the number of groups. If we have a SHT_GROUP
604 section with just a flag word (ie. sh_size is 4), ignore it. */
605 shnum
= elf_numsections (abfd
);
608 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
609 ( (shdr)->sh_type == SHT_GROUP \
610 && (shdr)->sh_size >= minsize \
611 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
612 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
614 for (i
= 0; i
< shnum
; i
++)
616 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
618 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
624 num_group
= (unsigned) -1;
625 elf_tdata (abfd
)->num_group
= num_group
;
626 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
630 /* We keep a list of elf section headers for group sections,
631 so we can find them quickly. */
634 elf_tdata (abfd
)->num_group
= num_group
;
635 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
636 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
637 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
639 memset (elf_tdata (abfd
)->group_sect_ptr
, 0,
640 num_group
* sizeof (Elf_Internal_Shdr
*));
643 for (i
= 0; i
< shnum
; i
++)
645 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
647 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
650 Elf_Internal_Group
*dest
;
652 /* Make sure the group section has a BFD section
654 if (!bfd_section_from_shdr (abfd
, i
))
657 /* Add to list of sections. */
658 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
661 /* Read the raw contents. */
662 BFD_ASSERT (sizeof (*dest
) >= 4);
663 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
664 shdr
->contents
= (unsigned char *)
665 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
666 /* PR binutils/4110: Handle corrupt group headers. */
667 if (shdr
->contents
== NULL
)
670 /* xgettext:c-format */
671 (_("%pB: corrupt size field in group section"
672 " header: %#" PRIx64
),
673 abfd
, (uint64_t) shdr
->sh_size
);
674 bfd_set_error (bfd_error_bad_value
);
679 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
680 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
684 /* xgettext:c-format */
685 (_("%pB: invalid size field in group section"
686 " header: %#" PRIx64
""),
687 abfd
, (uint64_t) shdr
->sh_size
);
688 bfd_set_error (bfd_error_bad_value
);
690 /* PR 17510: If the group contents are even
691 partially corrupt, do not allow any of the
692 contents to be used. */
693 bfd_release (abfd
, shdr
->contents
);
694 shdr
->contents
= NULL
;
698 /* Translate raw contents, a flag word followed by an
699 array of elf section indices all in target byte order,
700 to the flag word followed by an array of elf section
702 src
= shdr
->contents
+ shdr
->sh_size
;
703 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
711 idx
= H_GET_32 (abfd
, src
);
712 if (src
== shdr
->contents
)
716 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
717 shdr
->bfd_section
->flags
718 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
723 dest
->shdr
= elf_elfsections (abfd
)[idx
];
724 /* PR binutils/23199: All sections in a
725 section group should be marked with
726 SHF_GROUP. But some tools generate
727 broken objects without SHF_GROUP. Fix
729 dest
->shdr
->sh_flags
|= SHF_GROUP
;
732 || dest
->shdr
->sh_type
== SHT_GROUP
)
735 (_("%pB: invalid entry in SHT_GROUP section [%u]"),
743 /* PR 17510: Corrupt binaries might contain invalid groups. */
744 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
746 elf_tdata (abfd
)->num_group
= num_group
;
748 /* If all groups are invalid then fail. */
751 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
752 elf_tdata (abfd
)->num_group
= num_group
= -1;
754 (_("%pB: no valid group sections found"), abfd
);
755 bfd_set_error (bfd_error_bad_value
);
761 if (num_group
!= (unsigned) -1)
763 unsigned int search_offset
= elf_tdata (abfd
)->group_search_offset
;
766 for (j
= 0; j
< num_group
; j
++)
768 /* Begin search from previous found group. */
769 unsigned i
= (j
+ search_offset
) % num_group
;
771 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
772 Elf_Internal_Group
*idx
;
778 idx
= (Elf_Internal_Group
*) shdr
->contents
;
779 if (idx
== NULL
|| shdr
->sh_size
< 4)
781 /* See PR 21957 for a reproducer. */
782 /* xgettext:c-format */
783 _bfd_error_handler (_("%pB: group section '%pA' has no contents"),
784 abfd
, shdr
->bfd_section
);
785 elf_tdata (abfd
)->group_sect_ptr
[i
] = NULL
;
786 bfd_set_error (bfd_error_bad_value
);
789 n_elt
= shdr
->sh_size
/ 4;
791 /* Look through this group's sections to see if current
792 section is a member. */
794 if ((++idx
)->shdr
== hdr
)
798 /* We are a member of this group. Go looking through
799 other members to see if any others are linked via
801 idx
= (Elf_Internal_Group
*) shdr
->contents
;
802 n_elt
= shdr
->sh_size
/ 4;
804 if ((++idx
)->shdr
!= NULL
805 && (s
= idx
->shdr
->bfd_section
) != NULL
806 && elf_next_in_group (s
) != NULL
)
810 /* Snarf the group name from other member, and
811 insert current section in circular list. */
812 elf_group_name (newsect
) = elf_group_name (s
);
813 elf_next_in_group (newsect
) = elf_next_in_group (s
);
814 elf_next_in_group (s
) = newsect
;
820 gname
= group_signature (abfd
, shdr
);
823 elf_group_name (newsect
) = gname
;
825 /* Start a circular list with one element. */
826 elf_next_in_group (newsect
) = newsect
;
829 /* If the group section has been created, point to the
831 if (shdr
->bfd_section
!= NULL
)
832 elf_next_in_group (shdr
->bfd_section
) = newsect
;
834 elf_tdata (abfd
)->group_search_offset
= i
;
841 if (elf_group_name (newsect
) == NULL
)
843 /* xgettext:c-format */
844 _bfd_error_handler (_("%pB: no group info for section '%pA'"),
852 _bfd_elf_setup_sections (bfd
*abfd
)
855 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
856 bfd_boolean result
= TRUE
;
859 /* Process SHF_LINK_ORDER. */
860 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
862 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
863 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
865 unsigned int elfsec
= this_hdr
->sh_link
;
866 /* FIXME: The old Intel compiler and old strip/objcopy may
867 not set the sh_link or sh_info fields. Hence we could
868 get the situation where elfsec is 0. */
871 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
872 if (bed
->link_order_error_handler
)
873 bed
->link_order_error_handler
874 /* xgettext:c-format */
875 (_("%pB: warning: sh_link not set for section `%pA'"),
880 asection
*linksec
= NULL
;
882 if (elfsec
< elf_numsections (abfd
))
884 this_hdr
= elf_elfsections (abfd
)[elfsec
];
885 linksec
= this_hdr
->bfd_section
;
889 Some strip/objcopy may leave an incorrect value in
890 sh_link. We don't want to proceed. */
894 /* xgettext:c-format */
895 (_("%pB: sh_link [%d] in section `%pA' is incorrect"),
896 s
->owner
, elfsec
, s
);
900 elf_linked_to_section (s
) = linksec
;
903 else if (this_hdr
->sh_type
== SHT_GROUP
904 && elf_next_in_group (s
) == NULL
)
907 /* xgettext:c-format */
908 (_("%pB: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
909 abfd
, elf_section_data (s
)->this_idx
);
914 /* Process section groups. */
915 if (num_group
== (unsigned) -1)
918 for (i
= 0; i
< num_group
; i
++)
920 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
921 Elf_Internal_Group
*idx
;
924 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
925 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
928 /* xgettext:c-format */
929 (_("%pB: section group entry number %u is corrupt"),
935 idx
= (Elf_Internal_Group
*) shdr
->contents
;
936 n_elt
= shdr
->sh_size
/ 4;
942 if (idx
->shdr
== NULL
)
944 else if (idx
->shdr
->bfd_section
)
945 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
946 else if (idx
->shdr
->sh_type
!= SHT_RELA
947 && idx
->shdr
->sh_type
!= SHT_REL
)
949 /* There are some unknown sections in the group. */
951 /* xgettext:c-format */
952 (_("%pB: unknown type [%#x] section `%s' in group [%pA]"),
955 bfd_elf_string_from_elf_section (abfd
,
956 (elf_elfheader (abfd
)
969 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
971 return elf_next_in_group (sec
) != NULL
;
975 bfd_elf_group_name (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
977 if (elf_sec_group (sec
) != NULL
)
978 return elf_group_name (sec
);
983 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
985 unsigned int len
= strlen (name
);
986 char *new_name
= bfd_alloc (abfd
, len
+ 2);
987 if (new_name
== NULL
)
991 memcpy (new_name
+ 2, name
+ 1, len
);
996 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
998 unsigned int len
= strlen (name
);
999 char *new_name
= bfd_alloc (abfd
, len
);
1000 if (new_name
== NULL
)
1003 memcpy (new_name
+ 1, name
+ 2, len
- 1);
1007 /* This a copy of lto_section defined in GCC (lto-streamer.h). */
1011 int16_t major_version
;
1012 int16_t minor_version
;
1013 unsigned char slim_object
;
1015 /* Flags is a private field that is not defined publicly. */
1019 /* Make a BFD section from an ELF section. We store a pointer to the
1020 BFD section in the bfd_section field of the header. */
1023 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
1024 Elf_Internal_Shdr
*hdr
,
1030 const struct elf_backend_data
*bed
;
1032 if (hdr
->bfd_section
!= NULL
)
1035 newsect
= bfd_make_section_anyway (abfd
, name
);
1036 if (newsect
== NULL
)
1039 hdr
->bfd_section
= newsect
;
1040 elf_section_data (newsect
)->this_hdr
= *hdr
;
1041 elf_section_data (newsect
)->this_idx
= shindex
;
1043 /* Always use the real type/flags. */
1044 elf_section_type (newsect
) = hdr
->sh_type
;
1045 elf_section_flags (newsect
) = hdr
->sh_flags
;
1047 newsect
->filepos
= hdr
->sh_offset
;
1049 if (!bfd_set_section_vma (newsect
, hdr
->sh_addr
)
1050 || !bfd_set_section_size (newsect
, hdr
->sh_size
)
1051 || !bfd_set_section_alignment (newsect
, bfd_log2 (hdr
->sh_addralign
)))
1054 flags
= SEC_NO_FLAGS
;
1055 if (hdr
->sh_type
!= SHT_NOBITS
)
1056 flags
|= SEC_HAS_CONTENTS
;
1057 if (hdr
->sh_type
== SHT_GROUP
)
1059 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1062 if (hdr
->sh_type
!= SHT_NOBITS
)
1065 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
1066 flags
|= SEC_READONLY
;
1067 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1069 else if ((flags
& SEC_LOAD
) != 0)
1071 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
1074 newsect
->entsize
= hdr
->sh_entsize
;
1076 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
1077 flags
|= SEC_STRINGS
;
1078 if (hdr
->sh_flags
& SHF_GROUP
)
1079 if (!setup_group (abfd
, hdr
, newsect
))
1081 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
1082 flags
|= SEC_THREAD_LOCAL
;
1083 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
1084 flags
|= SEC_EXCLUDE
;
1086 switch (elf_elfheader (abfd
)->e_ident
[EI_OSABI
])
1088 /* FIXME: We should not recognize SHF_GNU_MBIND for ELFOSABI_NONE,
1089 but binutils as of 2019-07-23 did not set the EI_OSABI header
1093 case ELFOSABI_FREEBSD
:
1094 if ((hdr
->sh_flags
& SHF_GNU_MBIND
) != 0)
1095 elf_tdata (abfd
)->has_gnu_osabi
|= elf_gnu_osabi_mbind
;
1099 if ((flags
& SEC_ALLOC
) == 0)
1101 /* The debugging sections appear to be recognized only by name,
1102 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1103 if (name
[0] == '.')
1105 if (strncmp (name
, ".debug", 6) == 0
1106 || strncmp (name
, ".gnu.linkonce.wi.", 17) == 0
1107 || strncmp (name
, ".zdebug", 7) == 0)
1108 flags
|= SEC_DEBUGGING
| SEC_ELF_OCTETS
;
1109 else if (strncmp (name
, GNU_BUILD_ATTRS_SECTION_NAME
, 21) == 0
1110 || strncmp (name
, ".note.gnu", 9) == 0)
1111 flags
|= SEC_ELF_OCTETS
;
1112 else if (strncmp (name
, ".line", 5) == 0
1113 || strncmp (name
, ".stab", 5) == 0
1114 || strcmp (name
, ".gdb_index") == 0)
1115 flags
|= SEC_DEBUGGING
;
1119 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1120 only link a single copy of the section. This is used to support
1121 g++. g++ will emit each template expansion in its own section.
1122 The symbols will be defined as weak, so that multiple definitions
1123 are permitted. The GNU linker extension is to actually discard
1124 all but one of the sections. */
1125 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1126 && elf_next_in_group (newsect
) == NULL
)
1127 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1129 bed
= get_elf_backend_data (abfd
);
1130 if (bed
->elf_backend_section_flags
)
1131 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1134 if (!bfd_set_section_flags (newsect
, flags
))
1137 /* We do not parse the PT_NOTE segments as we are interested even in the
1138 separate debug info files which may have the segments offsets corrupted.
1139 PT_NOTEs from the core files are currently not parsed using BFD. */
1140 if (hdr
->sh_type
== SHT_NOTE
)
1144 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1147 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1148 hdr
->sh_offset
, hdr
->sh_addralign
);
1152 if ((flags
& SEC_ALLOC
) != 0)
1154 Elf_Internal_Phdr
*phdr
;
1155 unsigned int i
, nload
;
1157 /* Some ELF linkers produce binaries with all the program header
1158 p_paddr fields zero. If we have such a binary with more than
1159 one PT_LOAD header, then leave the section lma equal to vma
1160 so that we don't create sections with overlapping lma. */
1161 phdr
= elf_tdata (abfd
)->phdr
;
1162 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1163 if (phdr
->p_paddr
!= 0)
1165 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1167 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1170 phdr
= elf_tdata (abfd
)->phdr
;
1171 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1173 if (((phdr
->p_type
== PT_LOAD
1174 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1175 || phdr
->p_type
== PT_TLS
)
1176 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1178 if ((flags
& SEC_LOAD
) == 0)
1179 newsect
->lma
= (phdr
->p_paddr
1180 + hdr
->sh_addr
- phdr
->p_vaddr
);
1182 /* We used to use the same adjustment for SEC_LOAD
1183 sections, but that doesn't work if the segment
1184 is packed with code from multiple VMAs.
1185 Instead we calculate the section LMA based on
1186 the segment LMA. It is assumed that the
1187 segment will contain sections with contiguous
1188 LMAs, even if the VMAs are not. */
1189 newsect
->lma
= (phdr
->p_paddr
1190 + hdr
->sh_offset
- phdr
->p_offset
);
1192 /* With contiguous segments, we can't tell from file
1193 offsets whether a section with zero size should
1194 be placed at the end of one segment or the
1195 beginning of the next. Decide based on vaddr. */
1196 if (hdr
->sh_addr
>= phdr
->p_vaddr
1197 && (hdr
->sh_addr
+ hdr
->sh_size
1198 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1204 /* Compress/decompress DWARF debug sections with names: .debug_* and
1205 .zdebug_*, after the section flags is set. */
1206 if ((flags
& SEC_DEBUGGING
)
1207 && ((name
[1] == 'd' && name
[6] == '_')
1208 || (name
[1] == 'z' && name
[7] == '_')))
1210 enum { nothing
, compress
, decompress
} action
= nothing
;
1211 int compression_header_size
;
1212 bfd_size_type uncompressed_size
;
1213 unsigned int uncompressed_align_power
;
1214 bfd_boolean compressed
1215 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1216 &compression_header_size
,
1218 &uncompressed_align_power
);
1221 /* Compressed section. Check if we should decompress. */
1222 if ((abfd
->flags
& BFD_DECOMPRESS
))
1223 action
= decompress
;
1226 /* Compress the uncompressed section or convert from/to .zdebug*
1227 section. Check if we should compress. */
1228 if (action
== nothing
)
1230 if (newsect
->size
!= 0
1231 && (abfd
->flags
& BFD_COMPRESS
)
1232 && compression_header_size
>= 0
1233 && uncompressed_size
> 0
1235 || ((compression_header_size
> 0)
1236 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1242 if (action
== compress
)
1244 if (!bfd_init_section_compress_status (abfd
, newsect
))
1247 /* xgettext:c-format */
1248 (_("%pB: unable to initialize compress status for section %s"),
1255 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1258 /* xgettext:c-format */
1259 (_("%pB: unable to initialize decompress status for section %s"),
1265 if (abfd
->is_linker_input
)
1268 && (action
== decompress
1269 || (action
== compress
1270 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1272 /* Convert section name from .zdebug_* to .debug_* so
1273 that linker will consider this section as a debug
1275 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1276 if (new_name
== NULL
)
1278 bfd_rename_section (newsect
, new_name
);
1282 /* For objdump, don't rename the section. For objcopy, delay
1283 section rename to elf_fake_sections. */
1284 newsect
->flags
|= SEC_ELF_RENAME
;
1287 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
1289 const char *lto_section_name
= ".gnu.lto_.lto.";
1290 if (strncmp (name
, lto_section_name
, strlen (lto_section_name
)) == 0)
1292 struct lto_section lsection
;
1293 if (bfd_get_section_contents (abfd
, newsect
, &lsection
, 0,
1294 sizeof (struct lto_section
)))
1295 abfd
->lto_slim_object
= lsection
.slim_object
;
1301 const char *const bfd_elf_section_type_names
[] =
1303 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1304 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1305 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1308 /* ELF relocs are against symbols. If we are producing relocatable
1309 output, and the reloc is against an external symbol, and nothing
1310 has given us any additional addend, the resulting reloc will also
1311 be against the same symbol. In such a case, we don't want to
1312 change anything about the way the reloc is handled, since it will
1313 all be done at final link time. Rather than put special case code
1314 into bfd_perform_relocation, all the reloc types use this howto
1315 function. It just short circuits the reloc if producing
1316 relocatable output against an external symbol. */
1318 bfd_reloc_status_type
1319 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1320 arelent
*reloc_entry
,
1322 void *data ATTRIBUTE_UNUSED
,
1323 asection
*input_section
,
1325 char **error_message ATTRIBUTE_UNUSED
)
1327 if (output_bfd
!= NULL
1328 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1329 && (! reloc_entry
->howto
->partial_inplace
1330 || reloc_entry
->addend
== 0))
1332 reloc_entry
->address
+= input_section
->output_offset
;
1333 return bfd_reloc_ok
;
1336 return bfd_reloc_continue
;
1339 /* Returns TRUE if section A matches section B.
1340 Names, addresses and links may be different, but everything else
1341 should be the same. */
1344 section_match (const Elf_Internal_Shdr
* a
,
1345 const Elf_Internal_Shdr
* b
)
1347 if (a
->sh_type
!= b
->sh_type
1348 || ((a
->sh_flags
^ b
->sh_flags
) & ~SHF_INFO_LINK
) != 0
1349 || a
->sh_addralign
!= b
->sh_addralign
1350 || a
->sh_entsize
!= b
->sh_entsize
)
1352 if (a
->sh_type
== SHT_SYMTAB
1353 || a
->sh_type
== SHT_STRTAB
)
1355 return a
->sh_size
== b
->sh_size
;
1358 /* Find a section in OBFD that has the same characteristics
1359 as IHEADER. Return the index of this section or SHN_UNDEF if
1360 none can be found. Check's section HINT first, as this is likely
1361 to be the correct section. */
1364 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1365 const unsigned int hint
)
1367 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1370 BFD_ASSERT (iheader
!= NULL
);
1372 /* See PR 20922 for a reproducer of the NULL test. */
1373 if (hint
< elf_numsections (obfd
)
1374 && oheaders
[hint
] != NULL
1375 && section_match (oheaders
[hint
], iheader
))
1378 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1380 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1382 if (oheader
== NULL
)
1384 if (section_match (oheader
, iheader
))
1385 /* FIXME: Do we care if there is a potential for
1386 multiple matches ? */
1393 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1394 Processor specific section, based upon a matching input section.
1395 Returns TRUE upon success, FALSE otherwise. */
1398 copy_special_section_fields (const bfd
*ibfd
,
1400 const Elf_Internal_Shdr
*iheader
,
1401 Elf_Internal_Shdr
*oheader
,
1402 const unsigned int secnum
)
1404 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1405 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1406 bfd_boolean changed
= FALSE
;
1407 unsigned int sh_link
;
1409 if (oheader
->sh_type
== SHT_NOBITS
)
1411 /* This is a feature for objcopy --only-keep-debug:
1412 When a section's type is changed to NOBITS, we preserve
1413 the sh_link and sh_info fields so that they can be
1414 matched up with the original.
1416 Note: Strictly speaking these assignments are wrong.
1417 The sh_link and sh_info fields should point to the
1418 relevent sections in the output BFD, which may not be in
1419 the same location as they were in the input BFD. But
1420 the whole point of this action is to preserve the
1421 original values of the sh_link and sh_info fields, so
1422 that they can be matched up with the section headers in
1423 the original file. So strictly speaking we may be
1424 creating an invalid ELF file, but it is only for a file
1425 that just contains debug info and only for sections
1426 without any contents. */
1427 if (oheader
->sh_link
== 0)
1428 oheader
->sh_link
= iheader
->sh_link
;
1429 if (oheader
->sh_info
== 0)
1430 oheader
->sh_info
= iheader
->sh_info
;
1434 /* Allow the target a chance to decide how these fields should be set. */
1435 if (bed
->elf_backend_copy_special_section_fields
!= NULL
1436 && bed
->elf_backend_copy_special_section_fields
1437 (ibfd
, obfd
, iheader
, oheader
))
1440 /* We have an iheader which might match oheader, and which has non-zero
1441 sh_info and/or sh_link fields. Attempt to follow those links and find
1442 the section in the output bfd which corresponds to the linked section
1443 in the input bfd. */
1444 if (iheader
->sh_link
!= SHN_UNDEF
)
1446 /* See PR 20931 for a reproducer. */
1447 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1450 /* xgettext:c-format */
1451 (_("%pB: invalid sh_link field (%d) in section number %d"),
1452 ibfd
, iheader
->sh_link
, secnum
);
1456 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1457 if (sh_link
!= SHN_UNDEF
)
1459 oheader
->sh_link
= sh_link
;
1463 /* FIXME: Should we install iheader->sh_link
1464 if we could not find a match ? */
1466 /* xgettext:c-format */
1467 (_("%pB: failed to find link section for section %d"), obfd
, secnum
);
1470 if (iheader
->sh_info
)
1472 /* The sh_info field can hold arbitrary information, but if the
1473 SHF_LINK_INFO flag is set then it should be interpreted as a
1475 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1477 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1479 if (sh_link
!= SHN_UNDEF
)
1480 oheader
->sh_flags
|= SHF_INFO_LINK
;
1483 /* No idea what it means - just copy it. */
1484 sh_link
= iheader
->sh_info
;
1486 if (sh_link
!= SHN_UNDEF
)
1488 oheader
->sh_info
= sh_link
;
1493 /* xgettext:c-format */
1494 (_("%pB: failed to find info section for section %d"), obfd
, secnum
);
1500 /* Copy the program header and other data from one object module to
1504 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1506 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1507 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1508 const struct elf_backend_data
*bed
;
1511 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1512 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1515 if (!elf_flags_init (obfd
))
1517 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1518 elf_flags_init (obfd
) = TRUE
;
1521 elf_gp (obfd
) = elf_gp (ibfd
);
1523 /* Also copy the EI_OSABI field. */
1524 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1525 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1527 /* If set, copy the EI_ABIVERSION field. */
1528 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1529 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1530 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1532 /* Copy object attributes. */
1533 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1535 if (iheaders
== NULL
|| oheaders
== NULL
)
1538 bed
= get_elf_backend_data (obfd
);
1540 /* Possibly copy other fields in the section header. */
1541 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1544 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1546 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1547 because of a special case need for generating separate debug info
1548 files. See below for more details. */
1550 || (oheader
->sh_type
!= SHT_NOBITS
1551 && oheader
->sh_type
< SHT_LOOS
))
1554 /* Ignore empty sections, and sections whose
1555 fields have already been initialised. */
1556 if (oheader
->sh_size
== 0
1557 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1560 /* Scan for the matching section in the input bfd.
1561 First we try for a direct mapping between the input and output sections. */
1562 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1564 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1566 if (iheader
== NULL
)
1569 if (oheader
->bfd_section
!= NULL
1570 && iheader
->bfd_section
!= NULL
1571 && iheader
->bfd_section
->output_section
!= NULL
1572 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1574 /* We have found a connection from the input section to the
1575 output section. Attempt to copy the header fields. If
1576 this fails then do not try any further sections - there
1577 should only be a one-to-one mapping between input and output. */
1578 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1579 j
= elf_numsections (ibfd
);
1584 if (j
< elf_numsections (ibfd
))
1587 /* That failed. So try to deduce the corresponding input section.
1588 Unfortunately we cannot compare names as the output string table
1589 is empty, so instead we check size, address and type. */
1590 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1592 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1594 if (iheader
== NULL
)
1597 /* Try matching fields in the input section's header.
1598 Since --only-keep-debug turns all non-debug sections into
1599 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1601 if ((oheader
->sh_type
== SHT_NOBITS
1602 || iheader
->sh_type
== oheader
->sh_type
)
1603 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1604 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1605 && iheader
->sh_addralign
== oheader
->sh_addralign
1606 && iheader
->sh_entsize
== oheader
->sh_entsize
1607 && iheader
->sh_size
== oheader
->sh_size
1608 && iheader
->sh_addr
== oheader
->sh_addr
1609 && (iheader
->sh_info
!= oheader
->sh_info
1610 || iheader
->sh_link
!= oheader
->sh_link
))
1612 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1617 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1619 /* Final attempt. Call the backend copy function
1620 with a NULL input section. */
1621 if (bed
->elf_backend_copy_special_section_fields
!= NULL
)
1622 bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
, NULL
, oheader
);
1630 get_segment_type (unsigned int p_type
)
1635 case PT_NULL
: pt
= "NULL"; break;
1636 case PT_LOAD
: pt
= "LOAD"; break;
1637 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1638 case PT_INTERP
: pt
= "INTERP"; break;
1639 case PT_NOTE
: pt
= "NOTE"; break;
1640 case PT_SHLIB
: pt
= "SHLIB"; break;
1641 case PT_PHDR
: pt
= "PHDR"; break;
1642 case PT_TLS
: pt
= "TLS"; break;
1643 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1644 case PT_GNU_STACK
: pt
= "STACK"; break;
1645 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1646 default: pt
= NULL
; break;
1651 /* Print out the program headers. */
1654 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1656 FILE *f
= (FILE *) farg
;
1657 Elf_Internal_Phdr
*p
;
1659 bfd_byte
*dynbuf
= NULL
;
1661 p
= elf_tdata (abfd
)->phdr
;
1666 fprintf (f
, _("\nProgram Header:\n"));
1667 c
= elf_elfheader (abfd
)->e_phnum
;
1668 for (i
= 0; i
< c
; i
++, p
++)
1670 const char *pt
= get_segment_type (p
->p_type
);
1675 sprintf (buf
, "0x%lx", p
->p_type
);
1678 fprintf (f
, "%8s off 0x", pt
);
1679 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1680 fprintf (f
, " vaddr 0x");
1681 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1682 fprintf (f
, " paddr 0x");
1683 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1684 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1685 fprintf (f
, " filesz 0x");
1686 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1687 fprintf (f
, " memsz 0x");
1688 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1689 fprintf (f
, " flags %c%c%c",
1690 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1691 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1692 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1693 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1694 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1699 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1702 unsigned int elfsec
;
1703 unsigned long shlink
;
1704 bfd_byte
*extdyn
, *extdynend
;
1706 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1708 fprintf (f
, _("\nDynamic Section:\n"));
1710 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1713 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1714 if (elfsec
== SHN_BAD
)
1716 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1718 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1719 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1722 /* PR 17512: file: 6f427532. */
1723 if (s
->size
< extdynsize
)
1725 extdynend
= extdyn
+ s
->size
;
1726 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1728 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1730 Elf_Internal_Dyn dyn
;
1731 const char *name
= "";
1733 bfd_boolean stringp
;
1734 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1736 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1738 if (dyn
.d_tag
== DT_NULL
)
1745 if (bed
->elf_backend_get_target_dtag
)
1746 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1748 if (!strcmp (name
, ""))
1750 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1755 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1756 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1757 case DT_PLTGOT
: name
= "PLTGOT"; break;
1758 case DT_HASH
: name
= "HASH"; break;
1759 case DT_STRTAB
: name
= "STRTAB"; break;
1760 case DT_SYMTAB
: name
= "SYMTAB"; break;
1761 case DT_RELA
: name
= "RELA"; break;
1762 case DT_RELASZ
: name
= "RELASZ"; break;
1763 case DT_RELAENT
: name
= "RELAENT"; break;
1764 case DT_STRSZ
: name
= "STRSZ"; break;
1765 case DT_SYMENT
: name
= "SYMENT"; break;
1766 case DT_INIT
: name
= "INIT"; break;
1767 case DT_FINI
: name
= "FINI"; break;
1768 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1769 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1770 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1771 case DT_REL
: name
= "REL"; break;
1772 case DT_RELSZ
: name
= "RELSZ"; break;
1773 case DT_RELENT
: name
= "RELENT"; break;
1774 case DT_PLTREL
: name
= "PLTREL"; break;
1775 case DT_DEBUG
: name
= "DEBUG"; break;
1776 case DT_TEXTREL
: name
= "TEXTREL"; break;
1777 case DT_JMPREL
: name
= "JMPREL"; break;
1778 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1779 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1780 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1781 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1782 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1783 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1784 case DT_FLAGS
: name
= "FLAGS"; break;
1785 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1786 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1787 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1788 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1789 case DT_MOVEENT
: name
= "MOVEENT"; break;
1790 case DT_MOVESZ
: name
= "MOVESZ"; break;
1791 case DT_FEATURE
: name
= "FEATURE"; break;
1792 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1793 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1794 case DT_SYMINENT
: name
= "SYMINENT"; break;
1795 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1796 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1797 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1798 case DT_PLTPAD
: name
= "PLTPAD"; break;
1799 case DT_MOVETAB
: name
= "MOVETAB"; break;
1800 case DT_SYMINFO
: name
= "SYMINFO"; break;
1801 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1802 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1803 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1804 case DT_VERSYM
: name
= "VERSYM"; break;
1805 case DT_VERDEF
: name
= "VERDEF"; break;
1806 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1807 case DT_VERNEED
: name
= "VERNEED"; break;
1808 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1809 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1810 case DT_USED
: name
= "USED"; break;
1811 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1812 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1815 fprintf (f
, " %-20s ", name
);
1819 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1824 unsigned int tagv
= dyn
.d_un
.d_val
;
1826 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1829 fprintf (f
, "%s", string
);
1838 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1839 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1841 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1845 if (elf_dynverdef (abfd
) != 0)
1847 Elf_Internal_Verdef
*t
;
1849 fprintf (f
, _("\nVersion definitions:\n"));
1850 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1852 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1853 t
->vd_flags
, t
->vd_hash
,
1854 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1855 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1857 Elf_Internal_Verdaux
*a
;
1860 for (a
= t
->vd_auxptr
->vda_nextptr
;
1864 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1870 if (elf_dynverref (abfd
) != 0)
1872 Elf_Internal_Verneed
*t
;
1874 fprintf (f
, _("\nVersion References:\n"));
1875 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1877 Elf_Internal_Vernaux
*a
;
1879 fprintf (f
, _(" required from %s:\n"),
1880 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1881 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1882 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1883 a
->vna_flags
, a
->vna_other
,
1884 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1896 /* Get version string. */
1899 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1900 bfd_boolean
*hidden
)
1902 const char *version_string
= NULL
;
1903 if (elf_dynversym (abfd
) != 0
1904 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1906 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1908 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1909 vernum
&= VERSYM_VERSION
;
1912 version_string
= "";
1913 else if (vernum
== 1
1914 && (vernum
> elf_tdata (abfd
)->cverdefs
1915 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1917 version_string
= "Base";
1918 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1920 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1923 Elf_Internal_Verneed
*t
;
1925 version_string
= _("<corrupt>");
1926 for (t
= elf_tdata (abfd
)->verref
;
1930 Elf_Internal_Vernaux
*a
;
1932 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1934 if (a
->vna_other
== vernum
)
1936 version_string
= a
->vna_nodename
;
1943 return version_string
;
1946 /* Display ELF-specific fields of a symbol. */
1949 bfd_elf_print_symbol (bfd
*abfd
,
1952 bfd_print_symbol_type how
)
1954 FILE *file
= (FILE *) filep
;
1957 case bfd_print_symbol_name
:
1958 fprintf (file
, "%s", symbol
->name
);
1960 case bfd_print_symbol_more
:
1961 fprintf (file
, "elf ");
1962 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1963 fprintf (file
, " %x", symbol
->flags
);
1965 case bfd_print_symbol_all
:
1967 const char *section_name
;
1968 const char *name
= NULL
;
1969 const struct elf_backend_data
*bed
;
1970 unsigned char st_other
;
1972 const char *version_string
;
1975 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1977 bed
= get_elf_backend_data (abfd
);
1978 if (bed
->elf_backend_print_symbol_all
)
1979 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1983 name
= symbol
->name
;
1984 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1987 fprintf (file
, " %s\t", section_name
);
1988 /* Print the "other" value for a symbol. For common symbols,
1989 we've already printed the size; now print the alignment.
1990 For other symbols, we have no specified alignment, and
1991 we've printed the address; now print the size. */
1992 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1993 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1995 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1996 bfd_fprintf_vma (abfd
, file
, val
);
1998 /* If we have version information, print it. */
1999 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
2005 fprintf (file
, " %-11s", version_string
);
2010 fprintf (file
, " (%s)", version_string
);
2011 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
2016 /* If the st_other field is not zero, print it. */
2017 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
2022 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
2023 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
2024 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
2026 /* Some other non-defined flags are also present, so print
2028 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
2031 fprintf (file
, " %s", name
);
2037 /* ELF .o/exec file reading */
2039 /* Create a new bfd section from an ELF section header. */
2042 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2044 Elf_Internal_Shdr
*hdr
;
2045 Elf_Internal_Ehdr
*ehdr
;
2046 const struct elf_backend_data
*bed
;
2048 bfd_boolean ret
= TRUE
;
2049 static bfd_boolean
* sections_being_created
= NULL
;
2050 static bfd
* sections_being_created_abfd
= NULL
;
2051 static unsigned int nesting
= 0;
2053 if (shindex
>= elf_numsections (abfd
))
2058 /* PR17512: A corrupt ELF binary might contain a recursive group of
2059 sections, with each the string indices pointing to the next in the
2060 loop. Detect this here, by refusing to load a section that we are
2061 already in the process of loading. We only trigger this test if
2062 we have nested at least three sections deep as normal ELF binaries
2063 can expect to recurse at least once.
2065 FIXME: It would be better if this array was attached to the bfd,
2066 rather than being held in a static pointer. */
2068 if (sections_being_created_abfd
!= abfd
)
2069 sections_being_created
= NULL
;
2070 if (sections_being_created
== NULL
)
2072 sections_being_created
= (bfd_boolean
*)
2073 bfd_zalloc2 (abfd
, elf_numsections (abfd
), sizeof (bfd_boolean
));
2074 sections_being_created_abfd
= abfd
;
2076 if (sections_being_created
[shindex
])
2079 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2082 sections_being_created
[shindex
] = TRUE
;
2085 hdr
= elf_elfsections (abfd
)[shindex
];
2086 ehdr
= elf_elfheader (abfd
);
2087 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2092 bed
= get_elf_backend_data (abfd
);
2093 switch (hdr
->sh_type
)
2096 /* Inactive section. Throw it away. */
2099 case SHT_PROGBITS
: /* Normal section with contents. */
2100 case SHT_NOBITS
: /* .bss section. */
2101 case SHT_HASH
: /* .hash section. */
2102 case SHT_NOTE
: /* .note section. */
2103 case SHT_INIT_ARRAY
: /* .init_array section. */
2104 case SHT_FINI_ARRAY
: /* .fini_array section. */
2105 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2106 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2107 case SHT_GNU_HASH
: /* .gnu.hash section. */
2108 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2111 case SHT_DYNAMIC
: /* Dynamic linking information. */
2112 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2115 if (hdr
->sh_link
> elf_numsections (abfd
))
2117 /* PR 10478: Accept Solaris binaries with a sh_link
2118 field set to SHN_BEFORE or SHN_AFTER. */
2119 switch (bfd_get_arch (abfd
))
2122 case bfd_arch_sparc
:
2123 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2124 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2126 /* Otherwise fall through. */
2131 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2133 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2135 Elf_Internal_Shdr
*dynsymhdr
;
2137 /* The shared libraries distributed with hpux11 have a bogus
2138 sh_link field for the ".dynamic" section. Find the
2139 string table for the ".dynsym" section instead. */
2140 if (elf_dynsymtab (abfd
) != 0)
2142 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2143 hdr
->sh_link
= dynsymhdr
->sh_link
;
2147 unsigned int i
, num_sec
;
2149 num_sec
= elf_numsections (abfd
);
2150 for (i
= 1; i
< num_sec
; i
++)
2152 dynsymhdr
= elf_elfsections (abfd
)[i
];
2153 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2155 hdr
->sh_link
= dynsymhdr
->sh_link
;
2163 case SHT_SYMTAB
: /* A symbol table. */
2164 if (elf_onesymtab (abfd
) == shindex
)
2167 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2170 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2172 if (hdr
->sh_size
!= 0)
2174 /* Some assemblers erroneously set sh_info to one with a
2175 zero sh_size. ld sees this as a global symbol count
2176 of (unsigned) -1. Fix it here. */
2181 /* PR 18854: A binary might contain more than one symbol table.
2182 Unusual, but possible. Warn, but continue. */
2183 if (elf_onesymtab (abfd
) != 0)
2186 /* xgettext:c-format */
2187 (_("%pB: warning: multiple symbol tables detected"
2188 " - ignoring the table in section %u"),
2192 elf_onesymtab (abfd
) = shindex
;
2193 elf_symtab_hdr (abfd
) = *hdr
;
2194 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2195 abfd
->flags
|= HAS_SYMS
;
2197 /* Sometimes a shared object will map in the symbol table. If
2198 SHF_ALLOC is set, and this is a shared object, then we also
2199 treat this section as a BFD section. We can not base the
2200 decision purely on SHF_ALLOC, because that flag is sometimes
2201 set in a relocatable object file, which would confuse the
2203 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2204 && (abfd
->flags
& DYNAMIC
) != 0
2205 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2209 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2210 can't read symbols without that section loaded as well. It
2211 is most likely specified by the next section header. */
2213 elf_section_list
* entry
;
2214 unsigned int i
, num_sec
;
2216 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2217 if (entry
->hdr
.sh_link
== shindex
)
2220 num_sec
= elf_numsections (abfd
);
2221 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2223 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2225 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2226 && hdr2
->sh_link
== shindex
)
2231 for (i
= 1; i
< shindex
; i
++)
2233 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2235 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2236 && hdr2
->sh_link
== shindex
)
2241 ret
= bfd_section_from_shdr (abfd
, i
);
2242 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2246 case SHT_DYNSYM
: /* A dynamic symbol table. */
2247 if (elf_dynsymtab (abfd
) == shindex
)
2250 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2253 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2255 if (hdr
->sh_size
!= 0)
2258 /* Some linkers erroneously set sh_info to one with a
2259 zero sh_size. ld sees this as a global symbol count
2260 of (unsigned) -1. Fix it here. */
2265 /* PR 18854: A binary might contain more than one dynamic symbol table.
2266 Unusual, but possible. Warn, but continue. */
2267 if (elf_dynsymtab (abfd
) != 0)
2270 /* xgettext:c-format */
2271 (_("%pB: warning: multiple dynamic symbol tables detected"
2272 " - ignoring the table in section %u"),
2276 elf_dynsymtab (abfd
) = shindex
;
2277 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2278 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2279 abfd
->flags
|= HAS_SYMS
;
2281 /* Besides being a symbol table, we also treat this as a regular
2282 section, so that objcopy can handle it. */
2283 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2286 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2288 elf_section_list
* entry
;
2290 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2291 if (entry
->ndx
== shindex
)
2294 entry
= bfd_alloc (abfd
, sizeof (*entry
));
2297 entry
->ndx
= shindex
;
2299 entry
->next
= elf_symtab_shndx_list (abfd
);
2300 elf_symtab_shndx_list (abfd
) = entry
;
2301 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2305 case SHT_STRTAB
: /* A string table. */
2306 if (hdr
->bfd_section
!= NULL
)
2309 if (ehdr
->e_shstrndx
== shindex
)
2311 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2312 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2316 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2319 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2320 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2324 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2327 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2328 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2329 elf_elfsections (abfd
)[shindex
] = hdr
;
2330 /* We also treat this as a regular section, so that objcopy
2332 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2337 /* If the string table isn't one of the above, then treat it as a
2338 regular section. We need to scan all the headers to be sure,
2339 just in case this strtab section appeared before the above. */
2340 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2342 unsigned int i
, num_sec
;
2344 num_sec
= elf_numsections (abfd
);
2345 for (i
= 1; i
< num_sec
; i
++)
2347 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2348 if (hdr2
->sh_link
== shindex
)
2350 /* Prevent endless recursion on broken objects. */
2353 if (! bfd_section_from_shdr (abfd
, i
))
2355 if (elf_onesymtab (abfd
) == i
)
2357 if (elf_dynsymtab (abfd
) == i
)
2358 goto dynsymtab_strtab
;
2362 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2367 /* *These* do a lot of work -- but build no sections! */
2369 asection
*target_sect
;
2370 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2371 unsigned int num_sec
= elf_numsections (abfd
);
2372 struct bfd_elf_section_data
*esdt
;
2375 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2376 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2379 /* Check for a bogus link to avoid crashing. */
2380 if (hdr
->sh_link
>= num_sec
)
2383 /* xgettext:c-format */
2384 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2385 abfd
, hdr
->sh_link
, name
, shindex
);
2386 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2391 /* For some incomprehensible reason Oracle distributes
2392 libraries for Solaris in which some of the objects have
2393 bogus sh_link fields. It would be nice if we could just
2394 reject them, but, unfortunately, some people need to use
2395 them. We scan through the section headers; if we find only
2396 one suitable symbol table, we clobber the sh_link to point
2397 to it. I hope this doesn't break anything.
2399 Don't do it on executable nor shared library. */
2400 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2401 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2402 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2408 for (scan
= 1; scan
< num_sec
; scan
++)
2410 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2411 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2422 hdr
->sh_link
= found
;
2425 /* Get the symbol table. */
2426 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2427 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2428 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2431 /* If this is an alloc section in an executable or shared
2432 library, or the reloc section does not use the main symbol
2433 table we don't treat it as a reloc section. BFD can't
2434 adequately represent such a section, so at least for now,
2435 we don't try. We just present it as a normal section. We
2436 also can't use it as a reloc section if it points to the
2437 null section, an invalid section, another reloc section, or
2438 its sh_link points to the null section. */
2439 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2440 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2441 || hdr
->sh_link
== SHN_UNDEF
2442 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2443 || hdr
->sh_info
== SHN_UNDEF
2444 || hdr
->sh_info
>= num_sec
2445 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2446 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2448 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2453 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2456 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2457 if (target_sect
== NULL
)
2460 esdt
= elf_section_data (target_sect
);
2461 if (hdr
->sh_type
== SHT_RELA
)
2462 p_hdr
= &esdt
->rela
.hdr
;
2464 p_hdr
= &esdt
->rel
.hdr
;
2466 /* PR 17512: file: 0b4f81b7.
2467 Also see PR 24456, for a file which deliberately has two reloc
2472 /* xgettext:c-format */
2473 (_("%pB: warning: multiple relocation sections for section %pA \
2474 found - ignoring all but the first"),
2478 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2483 elf_elfsections (abfd
)[shindex
] = hdr2
;
2484 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2485 * bed
->s
->int_rels_per_ext_rel
);
2486 target_sect
->flags
|= SEC_RELOC
;
2487 target_sect
->relocation
= NULL
;
2488 target_sect
->rel_filepos
= hdr
->sh_offset
;
2489 /* In the section to which the relocations apply, mark whether
2490 its relocations are of the REL or RELA variety. */
2491 if (hdr
->sh_size
!= 0)
2493 if (hdr
->sh_type
== SHT_RELA
)
2494 target_sect
->use_rela_p
= 1;
2496 abfd
->flags
|= HAS_RELOC
;
2500 case SHT_GNU_verdef
:
2501 elf_dynverdef (abfd
) = shindex
;
2502 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2503 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2506 case SHT_GNU_versym
:
2507 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2510 elf_dynversym (abfd
) = shindex
;
2511 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2512 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2515 case SHT_GNU_verneed
:
2516 elf_dynverref (abfd
) = shindex
;
2517 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2518 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2525 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2528 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2534 /* Possibly an attributes section. */
2535 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2536 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2538 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2540 _bfd_elf_parse_attributes (abfd
, hdr
);
2544 /* Check for any processor-specific section types. */
2545 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2548 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2550 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2551 /* FIXME: How to properly handle allocated section reserved
2552 for applications? */
2554 /* xgettext:c-format */
2555 (_("%pB: unknown type [%#x] section `%s'"),
2556 abfd
, hdr
->sh_type
, name
);
2559 /* Allow sections reserved for applications. */
2560 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2565 else if (hdr
->sh_type
>= SHT_LOPROC
2566 && hdr
->sh_type
<= SHT_HIPROC
)
2567 /* FIXME: We should handle this section. */
2569 /* xgettext:c-format */
2570 (_("%pB: unknown type [%#x] section `%s'"),
2571 abfd
, hdr
->sh_type
, name
);
2572 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2574 /* Unrecognised OS-specific sections. */
2575 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2576 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2577 required to correctly process the section and the file should
2578 be rejected with an error message. */
2580 /* xgettext:c-format */
2581 (_("%pB: unknown type [%#x] section `%s'"),
2582 abfd
, hdr
->sh_type
, name
);
2585 /* Otherwise it should be processed. */
2586 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2591 /* FIXME: We should handle this section. */
2593 /* xgettext:c-format */
2594 (_("%pB: unknown type [%#x] section `%s'"),
2595 abfd
, hdr
->sh_type
, name
);
2603 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2604 sections_being_created
[shindex
] = FALSE
;
2605 if (-- nesting
== 0)
2607 sections_being_created
= NULL
;
2608 sections_being_created_abfd
= abfd
;
2613 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2616 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2618 unsigned long r_symndx
)
2620 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2622 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2624 Elf_Internal_Shdr
*symtab_hdr
;
2625 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2626 Elf_External_Sym_Shndx eshndx
;
2628 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2629 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2630 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2633 if (cache
->abfd
!= abfd
)
2635 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2638 cache
->indx
[ent
] = r_symndx
;
2641 return &cache
->sym
[ent
];
2644 /* Given an ELF section number, retrieve the corresponding BFD
2648 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2650 if (sec_index
>= elf_numsections (abfd
))
2652 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2655 static const struct bfd_elf_special_section special_sections_b
[] =
2657 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2658 { NULL
, 0, 0, 0, 0 }
2661 static const struct bfd_elf_special_section special_sections_c
[] =
2663 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2664 { STRING_COMMA_LEN (".ctf"), 0, SHT_PROGBITS
, 0 },
2665 { NULL
, 0, 0, 0, 0 }
2668 static const struct bfd_elf_special_section special_sections_d
[] =
2670 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2671 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2672 /* There are more DWARF sections than these, but they needn't be added here
2673 unless you have to cope with broken compilers that don't emit section
2674 attributes or you want to help the user writing assembler. */
2675 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2676 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2677 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2678 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2679 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2680 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2681 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2682 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2683 { NULL
, 0, 0, 0, 0 }
2686 static const struct bfd_elf_special_section special_sections_f
[] =
2688 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2689 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2690 { NULL
, 0 , 0, 0, 0 }
2693 static const struct bfd_elf_special_section special_sections_g
[] =
2695 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2696 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2697 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2698 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2699 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2700 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2701 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2702 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2703 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2704 { NULL
, 0, 0, 0, 0 }
2707 static const struct bfd_elf_special_section special_sections_h
[] =
2709 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2710 { NULL
, 0, 0, 0, 0 }
2713 static const struct bfd_elf_special_section special_sections_i
[] =
2715 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2716 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2717 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2718 { NULL
, 0, 0, 0, 0 }
2721 static const struct bfd_elf_special_section special_sections_l
[] =
2723 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2724 { NULL
, 0, 0, 0, 0 }
2727 static const struct bfd_elf_special_section special_sections_n
[] =
2729 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2730 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2731 { NULL
, 0, 0, 0, 0 }
2734 static const struct bfd_elf_special_section special_sections_p
[] =
2736 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2737 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2738 { NULL
, 0, 0, 0, 0 }
2741 static const struct bfd_elf_special_section special_sections_r
[] =
2743 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2744 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2745 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2746 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2747 { NULL
, 0, 0, 0, 0 }
2750 static const struct bfd_elf_special_section special_sections_s
[] =
2752 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2753 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2754 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2755 /* See struct bfd_elf_special_section declaration for the semantics of
2756 this special case where .prefix_length != strlen (.prefix). */
2757 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2758 { NULL
, 0, 0, 0, 0 }
2761 static const struct bfd_elf_special_section special_sections_t
[] =
2763 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2764 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2765 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2766 { NULL
, 0, 0, 0, 0 }
2769 static const struct bfd_elf_special_section special_sections_z
[] =
2771 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2772 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2773 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2774 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2775 { NULL
, 0, 0, 0, 0 }
2778 static const struct bfd_elf_special_section
* const special_sections
[] =
2780 special_sections_b
, /* 'b' */
2781 special_sections_c
, /* 'c' */
2782 special_sections_d
, /* 'd' */
2784 special_sections_f
, /* 'f' */
2785 special_sections_g
, /* 'g' */
2786 special_sections_h
, /* 'h' */
2787 special_sections_i
, /* 'i' */
2790 special_sections_l
, /* 'l' */
2792 special_sections_n
, /* 'n' */
2794 special_sections_p
, /* 'p' */
2796 special_sections_r
, /* 'r' */
2797 special_sections_s
, /* 's' */
2798 special_sections_t
, /* 't' */
2804 special_sections_z
/* 'z' */
2807 const struct bfd_elf_special_section
*
2808 _bfd_elf_get_special_section (const char *name
,
2809 const struct bfd_elf_special_section
*spec
,
2815 len
= strlen (name
);
2817 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2820 int prefix_len
= spec
[i
].prefix_length
;
2822 if (len
< prefix_len
)
2824 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2827 suffix_len
= spec
[i
].suffix_length
;
2828 if (suffix_len
<= 0)
2830 if (name
[prefix_len
] != 0)
2832 if (suffix_len
== 0)
2834 if (name
[prefix_len
] != '.'
2835 && (suffix_len
== -2
2836 || (rela
&& spec
[i
].type
== SHT_REL
)))
2842 if (len
< prefix_len
+ suffix_len
)
2844 if (memcmp (name
+ len
- suffix_len
,
2845 spec
[i
].prefix
+ prefix_len
,
2855 const struct bfd_elf_special_section
*
2856 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2859 const struct bfd_elf_special_section
*spec
;
2860 const struct elf_backend_data
*bed
;
2862 /* See if this is one of the special sections. */
2863 if (sec
->name
== NULL
)
2866 bed
= get_elf_backend_data (abfd
);
2867 spec
= bed
->special_sections
;
2870 spec
= _bfd_elf_get_special_section (sec
->name
,
2871 bed
->special_sections
,
2877 if (sec
->name
[0] != '.')
2880 i
= sec
->name
[1] - 'b';
2881 if (i
< 0 || i
> 'z' - 'b')
2884 spec
= special_sections
[i
];
2889 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2893 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2895 struct bfd_elf_section_data
*sdata
;
2896 const struct elf_backend_data
*bed
;
2897 const struct bfd_elf_special_section
*ssect
;
2899 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2902 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2906 sec
->used_by_bfd
= sdata
;
2909 /* Indicate whether or not this section should use RELA relocations. */
2910 bed
= get_elf_backend_data (abfd
);
2911 sec
->use_rela_p
= bed
->default_use_rela_p
;
2913 /* When we read a file, we don't need to set ELF section type and
2914 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2915 anyway. We will set ELF section type and flags for all linker
2916 created sections. If user specifies BFD section flags, we will
2917 set ELF section type and flags based on BFD section flags in
2918 elf_fake_sections. Special handling for .init_array/.fini_array
2919 output sections since they may contain .ctors/.dtors input
2920 sections. We don't want _bfd_elf_init_private_section_data to
2921 copy ELF section type from .ctors/.dtors input sections. */
2922 if (abfd
->direction
!= read_direction
2923 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2925 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2928 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2929 || ssect
->type
== SHT_INIT_ARRAY
2930 || ssect
->type
== SHT_FINI_ARRAY
))
2932 elf_section_type (sec
) = ssect
->type
;
2933 elf_section_flags (sec
) = ssect
->attr
;
2937 return _bfd_generic_new_section_hook (abfd
, sec
);
2940 /* Create a new bfd section from an ELF program header.
2942 Since program segments have no names, we generate a synthetic name
2943 of the form segment<NUM>, where NUM is generally the index in the
2944 program header table. For segments that are split (see below) we
2945 generate the names segment<NUM>a and segment<NUM>b.
2947 Note that some program segments may have a file size that is different than
2948 (less than) the memory size. All this means is that at execution the
2949 system must allocate the amount of memory specified by the memory size,
2950 but only initialize it with the first "file size" bytes read from the
2951 file. This would occur for example, with program segments consisting
2952 of combined data+bss.
2954 To handle the above situation, this routine generates TWO bfd sections
2955 for the single program segment. The first has the length specified by
2956 the file size of the segment, and the second has the length specified
2957 by the difference between the two sizes. In effect, the segment is split
2958 into its initialized and uninitialized parts.
2963 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2964 Elf_Internal_Phdr
*hdr
,
2966 const char *type_name
)
2974 split
= ((hdr
->p_memsz
> 0)
2975 && (hdr
->p_filesz
> 0)
2976 && (hdr
->p_memsz
> hdr
->p_filesz
));
2978 if (hdr
->p_filesz
> 0)
2980 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2981 len
= strlen (namebuf
) + 1;
2982 name
= (char *) bfd_alloc (abfd
, len
);
2985 memcpy (name
, namebuf
, len
);
2986 newsect
= bfd_make_section (abfd
, name
);
2987 if (newsect
== NULL
)
2989 newsect
->vma
= hdr
->p_vaddr
;
2990 newsect
->lma
= hdr
->p_paddr
;
2991 newsect
->size
= hdr
->p_filesz
;
2992 newsect
->filepos
= hdr
->p_offset
;
2993 newsect
->flags
|= SEC_HAS_CONTENTS
;
2994 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2995 if (hdr
->p_type
== PT_LOAD
)
2997 newsect
->flags
|= SEC_ALLOC
;
2998 newsect
->flags
|= SEC_LOAD
;
2999 if (hdr
->p_flags
& PF_X
)
3001 /* FIXME: all we known is that it has execute PERMISSION,
3003 newsect
->flags
|= SEC_CODE
;
3006 if (!(hdr
->p_flags
& PF_W
))
3008 newsect
->flags
|= SEC_READONLY
;
3012 if (hdr
->p_memsz
> hdr
->p_filesz
)
3016 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
3017 len
= strlen (namebuf
) + 1;
3018 name
= (char *) bfd_alloc (abfd
, len
);
3021 memcpy (name
, namebuf
, len
);
3022 newsect
= bfd_make_section (abfd
, name
);
3023 if (newsect
== NULL
)
3025 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
3026 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
3027 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
3028 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
3029 align
= newsect
->vma
& -newsect
->vma
;
3030 if (align
== 0 || align
> hdr
->p_align
)
3031 align
= hdr
->p_align
;
3032 newsect
->alignment_power
= bfd_log2 (align
);
3033 if (hdr
->p_type
== PT_LOAD
)
3035 /* Hack for gdb. Segments that have not been modified do
3036 not have their contents written to a core file, on the
3037 assumption that a debugger can find the contents in the
3038 executable. We flag this case by setting the fake
3039 section size to zero. Note that "real" bss sections will
3040 always have their contents dumped to the core file. */
3041 if (bfd_get_format (abfd
) == bfd_core
)
3043 newsect
->flags
|= SEC_ALLOC
;
3044 if (hdr
->p_flags
& PF_X
)
3045 newsect
->flags
|= SEC_CODE
;
3047 if (!(hdr
->p_flags
& PF_W
))
3048 newsect
->flags
|= SEC_READONLY
;
3055 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3057 /* The return value is ignored. Build-ids are considered optional. */
3058 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3059 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3065 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3067 const struct elf_backend_data
*bed
;
3069 switch (hdr
->p_type
)
3072 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3075 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3077 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3078 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3082 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3085 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3088 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3090 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3096 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3099 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3101 case PT_GNU_EH_FRAME
:
3102 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3106 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3109 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3112 /* Check for any processor-specific program segment types. */
3113 bed
= get_elf_backend_data (abfd
);
3114 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3118 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3122 _bfd_elf_single_rel_hdr (asection
*sec
)
3124 if (elf_section_data (sec
)->rel
.hdr
)
3126 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3127 return elf_section_data (sec
)->rel
.hdr
;
3130 return elf_section_data (sec
)->rela
.hdr
;
3134 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3135 Elf_Internal_Shdr
*rel_hdr
,
3136 const char *sec_name
,
3137 bfd_boolean use_rela_p
)
3139 char *name
= (char *) bfd_alloc (abfd
,
3140 sizeof ".rela" + strlen (sec_name
));
3144 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3146 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3148 if (rel_hdr
->sh_name
== (unsigned int) -1)
3154 /* Allocate and initialize a section-header for a new reloc section,
3155 containing relocations against ASECT. It is stored in RELDATA. If
3156 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3160 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3161 struct bfd_elf_section_reloc_data
*reldata
,
3162 const char *sec_name
,
3163 bfd_boolean use_rela_p
,
3164 bfd_boolean delay_st_name_p
)
3166 Elf_Internal_Shdr
*rel_hdr
;
3167 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3169 BFD_ASSERT (reldata
->hdr
== NULL
);
3170 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3171 reldata
->hdr
= rel_hdr
;
3173 if (delay_st_name_p
)
3174 rel_hdr
->sh_name
= (unsigned int) -1;
3175 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3178 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3179 rel_hdr
->sh_entsize
= (use_rela_p
3180 ? bed
->s
->sizeof_rela
3181 : bed
->s
->sizeof_rel
);
3182 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3183 rel_hdr
->sh_flags
= 0;
3184 rel_hdr
->sh_addr
= 0;
3185 rel_hdr
->sh_size
= 0;
3186 rel_hdr
->sh_offset
= 0;
3191 /* Return the default section type based on the passed in section flags. */
3194 bfd_elf_get_default_section_type (flagword flags
)
3196 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3197 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3199 return SHT_PROGBITS
;
3202 struct fake_section_arg
3204 struct bfd_link_info
*link_info
;
3208 /* Set up an ELF internal section header for a section. */
3211 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3213 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3214 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3215 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3216 Elf_Internal_Shdr
*this_hdr
;
3217 unsigned int sh_type
;
3218 const char *name
= asect
->name
;
3219 bfd_boolean delay_st_name_p
= FALSE
;
3223 /* We already failed; just get out of the bfd_map_over_sections
3228 this_hdr
= &esd
->this_hdr
;
3232 /* ld: compress DWARF debug sections with names: .debug_*. */
3233 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3234 && (asect
->flags
& SEC_DEBUGGING
)
3238 /* Set SEC_ELF_COMPRESS to indicate this section should be
3240 asect
->flags
|= SEC_ELF_COMPRESS
;
3242 /* If this section will be compressed, delay adding section
3243 name to section name section after it is compressed in
3244 _bfd_elf_assign_file_positions_for_non_load. */
3245 delay_st_name_p
= TRUE
;
3248 else if ((asect
->flags
& SEC_ELF_RENAME
))
3250 /* objcopy: rename output DWARF debug section. */
3251 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3253 /* When we decompress or compress with SHF_COMPRESSED,
3254 convert section name from .zdebug_* to .debug_* if
3258 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3259 if (new_name
== NULL
)
3267 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3269 /* PR binutils/18087: Compression does not always make a
3270 section smaller. So only rename the section when
3271 compression has actually taken place. If input section
3272 name is .zdebug_*, we should never compress it again. */
3273 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3274 if (new_name
== NULL
)
3279 BFD_ASSERT (name
[1] != 'z');
3284 if (delay_st_name_p
)
3285 this_hdr
->sh_name
= (unsigned int) -1;
3289 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3291 if (this_hdr
->sh_name
== (unsigned int) -1)
3298 /* Don't clear sh_flags. Assembler may set additional bits. */
3300 if ((asect
->flags
& SEC_ALLOC
) != 0
3301 || asect
->user_set_vma
)
3302 this_hdr
->sh_addr
= asect
->vma
;
3304 this_hdr
->sh_addr
= 0;
3306 this_hdr
->sh_offset
= 0;
3307 this_hdr
->sh_size
= asect
->size
;
3308 this_hdr
->sh_link
= 0;
3309 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3310 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3313 /* xgettext:c-format */
3314 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3315 abfd
, asect
->alignment_power
, asect
);
3319 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
3320 /* The sh_entsize and sh_info fields may have been set already by
3321 copy_private_section_data. */
3323 this_hdr
->bfd_section
= asect
;
3324 this_hdr
->contents
= NULL
;
3326 /* If the section type is unspecified, we set it based on
3328 if ((asect
->flags
& SEC_GROUP
) != 0)
3329 sh_type
= SHT_GROUP
;
3331 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3333 if (this_hdr
->sh_type
== SHT_NULL
)
3334 this_hdr
->sh_type
= sh_type
;
3335 else if (this_hdr
->sh_type
== SHT_NOBITS
3336 && sh_type
== SHT_PROGBITS
3337 && (asect
->flags
& SEC_ALLOC
) != 0)
3339 /* Warn if we are changing a NOBITS section to PROGBITS, but
3340 allow the link to proceed. This can happen when users link
3341 non-bss input sections to bss output sections, or emit data
3342 to a bss output section via a linker script. */
3344 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3345 this_hdr
->sh_type
= sh_type
;
3348 switch (this_hdr
->sh_type
)
3359 case SHT_INIT_ARRAY
:
3360 case SHT_FINI_ARRAY
:
3361 case SHT_PREINIT_ARRAY
:
3362 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3366 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3370 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3374 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3378 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3379 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3383 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3384 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3387 case SHT_GNU_versym
:
3388 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3391 case SHT_GNU_verdef
:
3392 this_hdr
->sh_entsize
= 0;
3393 /* objcopy or strip will copy over sh_info, but may not set
3394 cverdefs. The linker will set cverdefs, but sh_info will be
3396 if (this_hdr
->sh_info
== 0)
3397 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3399 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3400 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3403 case SHT_GNU_verneed
:
3404 this_hdr
->sh_entsize
= 0;
3405 /* objcopy or strip will copy over sh_info, but may not set
3406 cverrefs. The linker will set cverrefs, but sh_info will be
3408 if (this_hdr
->sh_info
== 0)
3409 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3411 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3412 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3416 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3420 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3424 if ((asect
->flags
& SEC_ALLOC
) != 0)
3425 this_hdr
->sh_flags
|= SHF_ALLOC
;
3426 if ((asect
->flags
& SEC_READONLY
) == 0)
3427 this_hdr
->sh_flags
|= SHF_WRITE
;
3428 if ((asect
->flags
& SEC_CODE
) != 0)
3429 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3430 if ((asect
->flags
& SEC_MERGE
) != 0)
3432 this_hdr
->sh_flags
|= SHF_MERGE
;
3433 this_hdr
->sh_entsize
= asect
->entsize
;
3435 if ((asect
->flags
& SEC_STRINGS
) != 0)
3436 this_hdr
->sh_flags
|= SHF_STRINGS
;
3437 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3438 this_hdr
->sh_flags
|= SHF_GROUP
;
3439 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3441 this_hdr
->sh_flags
|= SHF_TLS
;
3442 if (asect
->size
== 0
3443 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3445 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3447 this_hdr
->sh_size
= 0;
3450 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3451 if (this_hdr
->sh_size
!= 0)
3452 this_hdr
->sh_type
= SHT_NOBITS
;
3456 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3457 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3459 /* If the section has relocs, set up a section header for the
3460 SHT_REL[A] section. If two relocation sections are required for
3461 this section, it is up to the processor-specific back-end to
3462 create the other. */
3463 if ((asect
->flags
& SEC_RELOC
) != 0)
3465 /* When doing a relocatable link, create both REL and RELA sections if
3468 /* Do the normal setup if we wouldn't create any sections here. */
3469 && esd
->rel
.count
+ esd
->rela
.count
> 0
3470 && (bfd_link_relocatable (arg
->link_info
)
3471 || arg
->link_info
->emitrelocations
))
3473 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3474 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3475 FALSE
, delay_st_name_p
))
3480 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3481 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3482 TRUE
, delay_st_name_p
))
3488 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3490 ? &esd
->rela
: &esd
->rel
),
3500 /* Check for processor-specific section types. */
3501 sh_type
= this_hdr
->sh_type
;
3502 if (bed
->elf_backend_fake_sections
3503 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3509 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3511 /* Don't change the header type from NOBITS if we are being
3512 called for objcopy --only-keep-debug. */
3513 this_hdr
->sh_type
= sh_type
;
3517 /* Fill in the contents of a SHT_GROUP section. Called from
3518 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3519 when ELF targets use the generic linker, ld. Called for ld -r
3520 from bfd_elf_final_link. */
3523 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3525 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3526 asection
*elt
, *first
;
3530 /* Ignore linker created group section. See elfNN_ia64_object_p in
3532 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3537 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3539 unsigned long symindx
= 0;
3541 /* elf_group_id will have been set up by objcopy and the
3543 if (elf_group_id (sec
) != NULL
)
3544 symindx
= elf_group_id (sec
)->udata
.i
;
3548 /* If called from the assembler, swap_out_syms will have set up
3549 elf_section_syms. */
3550 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3551 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3553 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3555 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3557 /* The ELF backend linker sets sh_info to -2 when the group
3558 signature symbol is global, and thus the index can't be
3559 set until all local symbols are output. */
3561 struct bfd_elf_section_data
*sec_data
;
3562 unsigned long symndx
;
3563 unsigned long extsymoff
;
3564 struct elf_link_hash_entry
*h
;
3566 /* The point of this little dance to the first SHF_GROUP section
3567 then back to the SHT_GROUP section is that this gets us to
3568 the SHT_GROUP in the input object. */
3569 igroup
= elf_sec_group (elf_next_in_group (sec
));
3570 sec_data
= elf_section_data (igroup
);
3571 symndx
= sec_data
->this_hdr
.sh_info
;
3573 if (!elf_bad_symtab (igroup
->owner
))
3575 Elf_Internal_Shdr
*symtab_hdr
;
3577 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3578 extsymoff
= symtab_hdr
->sh_info
;
3580 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3581 while (h
->root
.type
== bfd_link_hash_indirect
3582 || h
->root
.type
== bfd_link_hash_warning
)
3583 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3585 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3588 /* The contents won't be allocated for "ld -r" or objcopy. */
3590 if (sec
->contents
== NULL
)
3593 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3595 /* Arrange for the section to be written out. */
3596 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3597 if (sec
->contents
== NULL
)
3604 loc
= sec
->contents
+ sec
->size
;
3606 /* Get the pointer to the first section in the group that gas
3607 squirreled away here. objcopy arranges for this to be set to the
3608 start of the input section group. */
3609 first
= elt
= elf_next_in_group (sec
);
3611 /* First element is a flag word. Rest of section is elf section
3612 indices for all the sections of the group. Write them backwards
3613 just to keep the group in the same order as given in .section
3614 directives, not that it matters. */
3621 s
= s
->output_section
;
3623 && !bfd_is_abs_section (s
))
3625 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3626 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3628 if (elf_sec
->rel
.hdr
!= NULL
3630 || (input_elf_sec
->rel
.hdr
!= NULL
3631 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3633 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3635 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3637 if (elf_sec
->rela
.hdr
!= NULL
3639 || (input_elf_sec
->rela
.hdr
!= NULL
3640 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3642 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3644 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3647 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3649 elt
= elf_next_in_group (elt
);
3655 BFD_ASSERT (loc
== sec
->contents
);
3657 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3660 /* Given NAME, the name of a relocation section stripped of its
3661 .rel/.rela prefix, return the section in ABFD to which the
3662 relocations apply. */
3665 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3667 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3668 section likely apply to .got.plt or .got section. */
3669 if (get_elf_backend_data (abfd
)->want_got_plt
3670 && strcmp (name
, ".plt") == 0)
3675 sec
= bfd_get_section_by_name (abfd
, name
);
3681 return bfd_get_section_by_name (abfd
, name
);
3684 /* Return the section to which RELOC_SEC applies. */
3687 elf_get_reloc_section (asection
*reloc_sec
)
3692 const struct elf_backend_data
*bed
;
3694 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3695 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3698 /* We look up the section the relocs apply to by name. */
3699 name
= reloc_sec
->name
;
3700 if (strncmp (name
, ".rel", 4) != 0)
3703 if (type
== SHT_RELA
&& *name
++ != 'a')
3706 abfd
= reloc_sec
->owner
;
3707 bed
= get_elf_backend_data (abfd
);
3708 return bed
->get_reloc_section (abfd
, name
);
3711 /* Assign all ELF section numbers. The dummy first section is handled here
3712 too. The link/info pointers for the standard section types are filled
3713 in here too, while we're at it. */
3716 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3718 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3720 unsigned int section_number
;
3721 Elf_Internal_Shdr
**i_shdrp
;
3722 struct bfd_elf_section_data
*d
;
3723 bfd_boolean need_symtab
;
3727 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3729 /* SHT_GROUP sections are in relocatable files only. */
3730 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3732 size_t reloc_count
= 0;
3734 /* Put SHT_GROUP sections first. */
3735 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3737 d
= elf_section_data (sec
);
3739 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3741 if (sec
->flags
& SEC_LINKER_CREATED
)
3743 /* Remove the linker created SHT_GROUP sections. */
3744 bfd_section_list_remove (abfd
, sec
);
3745 abfd
->section_count
--;
3748 d
->this_idx
= section_number
++;
3751 /* Count relocations. */
3752 reloc_count
+= sec
->reloc_count
;
3755 /* Clear HAS_RELOC if there are no relocations. */
3756 if (reloc_count
== 0)
3757 abfd
->flags
&= ~HAS_RELOC
;
3760 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3762 d
= elf_section_data (sec
);
3764 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3765 d
->this_idx
= section_number
++;
3766 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3767 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3770 d
->rel
.idx
= section_number
++;
3771 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3772 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3779 d
->rela
.idx
= section_number
++;
3780 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3781 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3787 need_symtab
= (bfd_get_symcount (abfd
) > 0
3788 || (link_info
== NULL
3789 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3793 elf_onesymtab (abfd
) = section_number
++;
3794 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3795 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3797 elf_section_list
*entry
;
3799 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3801 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3802 entry
->ndx
= section_number
++;
3803 elf_symtab_shndx_list (abfd
) = entry
;
3805 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3806 ".symtab_shndx", FALSE
);
3807 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3810 elf_strtab_sec (abfd
) = section_number
++;
3811 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3814 elf_shstrtab_sec (abfd
) = section_number
++;
3815 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3816 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3818 if (section_number
>= SHN_LORESERVE
)
3820 /* xgettext:c-format */
3821 _bfd_error_handler (_("%pB: too many sections: %u"),
3822 abfd
, section_number
);
3826 elf_numsections (abfd
) = section_number
;
3827 elf_elfheader (abfd
)->e_shnum
= section_number
;
3829 /* Set up the list of section header pointers, in agreement with the
3831 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3832 sizeof (Elf_Internal_Shdr
*));
3833 if (i_shdrp
== NULL
)
3836 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3837 sizeof (Elf_Internal_Shdr
));
3838 if (i_shdrp
[0] == NULL
)
3840 bfd_release (abfd
, i_shdrp
);
3844 elf_elfsections (abfd
) = i_shdrp
;
3846 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3849 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3850 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3852 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3853 BFD_ASSERT (entry
!= NULL
);
3854 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3855 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3857 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3858 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3861 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3865 d
= elf_section_data (sec
);
3867 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3868 if (d
->rel
.idx
!= 0)
3869 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3870 if (d
->rela
.idx
!= 0)
3871 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3873 /* Fill in the sh_link and sh_info fields while we're at it. */
3875 /* sh_link of a reloc section is the section index of the symbol
3876 table. sh_info is the section index of the section to which
3877 the relocation entries apply. */
3878 if (d
->rel
.idx
!= 0)
3880 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3881 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3882 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3884 if (d
->rela
.idx
!= 0)
3886 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3887 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3888 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3891 /* We need to set up sh_link for SHF_LINK_ORDER. */
3892 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3894 s
= elf_linked_to_section (sec
);
3897 /* elf_linked_to_section points to the input section. */
3898 if (link_info
!= NULL
)
3900 /* Check discarded linkonce section. */
3901 if (discarded_section (s
))
3905 /* xgettext:c-format */
3906 (_("%pB: sh_link of section `%pA' points to"
3907 " discarded section `%pA' of `%pB'"),
3908 abfd
, d
->this_hdr
.bfd_section
,
3910 /* Point to the kept section if it has the same
3911 size as the discarded one. */
3912 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3915 bfd_set_error (bfd_error_bad_value
);
3921 s
= s
->output_section
;
3922 BFD_ASSERT (s
!= NULL
);
3926 /* Handle objcopy. */
3927 if (s
->output_section
== NULL
)
3930 /* xgettext:c-format */
3931 (_("%pB: sh_link of section `%pA' points to"
3932 " removed section `%pA' of `%pB'"),
3933 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3934 bfd_set_error (bfd_error_bad_value
);
3937 s
= s
->output_section
;
3939 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3944 The Intel C compiler generates SHT_IA_64_UNWIND with
3945 SHF_LINK_ORDER. But it doesn't set the sh_link or
3946 sh_info fields. Hence we could get the situation
3948 const struct elf_backend_data
*bed
3949 = get_elf_backend_data (abfd
);
3950 if (bed
->link_order_error_handler
)
3951 bed
->link_order_error_handler
3952 /* xgettext:c-format */
3953 (_("%pB: warning: sh_link not set for section `%pA'"),
3958 switch (d
->this_hdr
.sh_type
)
3962 /* A reloc section which we are treating as a normal BFD
3963 section. sh_link is the section index of the symbol
3964 table. sh_info is the section index of the section to
3965 which the relocation entries apply. We assume that an
3966 allocated reloc section uses the dynamic symbol table.
3967 FIXME: How can we be sure? */
3968 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3970 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3972 s
= elf_get_reloc_section (sec
);
3975 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3976 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3981 /* We assume that a section named .stab*str is a stabs
3982 string section. We look for a section with the same name
3983 but without the trailing ``str'', and set its sh_link
3984 field to point to this section. */
3985 if (CONST_STRNEQ (sec
->name
, ".stab")
3986 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3991 len
= strlen (sec
->name
);
3992 alc
= (char *) bfd_malloc (len
- 2);
3995 memcpy (alc
, sec
->name
, len
- 3);
3996 alc
[len
- 3] = '\0';
3997 s
= bfd_get_section_by_name (abfd
, alc
);
4001 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
4003 /* This is a .stab section. */
4004 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
4005 elf_section_data (s
)->this_hdr
.sh_entsize
4006 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
4013 case SHT_GNU_verneed
:
4014 case SHT_GNU_verdef
:
4015 /* sh_link is the section header index of the string table
4016 used for the dynamic entries, or the symbol table, or the
4018 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4020 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4023 case SHT_GNU_LIBLIST
:
4024 /* sh_link is the section header index of the prelink library
4025 list used for the dynamic entries, or the symbol table, or
4026 the version strings. */
4027 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
4028 ? ".dynstr" : ".gnu.libstr");
4030 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4035 case SHT_GNU_versym
:
4036 /* sh_link is the section header index of the symbol table
4037 this hash table or version table is for. */
4038 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4040 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4044 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
4048 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
4049 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
4050 debug section name from .debug_* to .zdebug_* if needed. */
4056 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4058 /* If the backend has a special mapping, use it. */
4059 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4060 if (bed
->elf_backend_sym_is_global
)
4061 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4063 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4064 || bfd_is_und_section (bfd_asymbol_section (sym
))
4065 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4068 /* Filter global symbols of ABFD to include in the import library. All
4069 SYMCOUNT symbols of ABFD can be examined from their pointers in
4070 SYMS. Pointers of symbols to keep should be stored contiguously at
4071 the beginning of that array.
4073 Returns the number of symbols to keep. */
4076 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4077 asymbol
**syms
, long symcount
)
4079 long src_count
, dst_count
= 0;
4081 for (src_count
= 0; src_count
< symcount
; src_count
++)
4083 asymbol
*sym
= syms
[src_count
];
4084 char *name
= (char *) bfd_asymbol_name (sym
);
4085 struct bfd_link_hash_entry
*h
;
4087 if (!sym_is_global (abfd
, sym
))
4090 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
4093 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4095 if (h
->linker_def
|| h
->ldscript_def
)
4098 syms
[dst_count
++] = sym
;
4101 syms
[dst_count
] = NULL
;
4106 /* Don't output section symbols for sections that are not going to be
4107 output, that are duplicates or there is no BFD section. */
4110 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4112 elf_symbol_type
*type_ptr
;
4117 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4120 if (sym
->section
== NULL
)
4123 type_ptr
= elf_symbol_from (abfd
, sym
);
4124 return ((type_ptr
!= NULL
4125 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4126 && bfd_is_abs_section (sym
->section
))
4127 || !(sym
->section
->owner
== abfd
4128 || (sym
->section
->output_section
!= NULL
4129 && sym
->section
->output_section
->owner
== abfd
4130 && sym
->section
->output_offset
== 0)
4131 || bfd_is_abs_section (sym
->section
)));
4134 /* Map symbol from it's internal number to the external number, moving
4135 all local symbols to be at the head of the list. */
4138 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4140 unsigned int symcount
= bfd_get_symcount (abfd
);
4141 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4142 asymbol
**sect_syms
;
4143 unsigned int num_locals
= 0;
4144 unsigned int num_globals
= 0;
4145 unsigned int num_locals2
= 0;
4146 unsigned int num_globals2
= 0;
4147 unsigned int max_index
= 0;
4153 fprintf (stderr
, "elf_map_symbols\n");
4157 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4159 if (max_index
< asect
->index
)
4160 max_index
= asect
->index
;
4164 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
4165 if (sect_syms
== NULL
)
4167 elf_section_syms (abfd
) = sect_syms
;
4168 elf_num_section_syms (abfd
) = max_index
;
4170 /* Init sect_syms entries for any section symbols we have already
4171 decided to output. */
4172 for (idx
= 0; idx
< symcount
; idx
++)
4174 asymbol
*sym
= syms
[idx
];
4176 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4178 && !ignore_section_sym (abfd
, sym
)
4179 && !bfd_is_abs_section (sym
->section
))
4181 asection
*sec
= sym
->section
;
4183 if (sec
->owner
!= abfd
)
4184 sec
= sec
->output_section
;
4186 sect_syms
[sec
->index
] = syms
[idx
];
4190 /* Classify all of the symbols. */
4191 for (idx
= 0; idx
< symcount
; idx
++)
4193 if (sym_is_global (abfd
, syms
[idx
]))
4195 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4199 /* We will be adding a section symbol for each normal BFD section. Most
4200 sections will already have a section symbol in outsymbols, but
4201 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4202 at least in that case. */
4203 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4205 if (sect_syms
[asect
->index
] == NULL
)
4207 if (!sym_is_global (abfd
, asect
->symbol
))
4214 /* Now sort the symbols so the local symbols are first. */
4215 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
4216 sizeof (asymbol
*));
4218 if (new_syms
== NULL
)
4221 for (idx
= 0; idx
< symcount
; idx
++)
4223 asymbol
*sym
= syms
[idx
];
4226 if (sym_is_global (abfd
, sym
))
4227 i
= num_locals
+ num_globals2
++;
4228 else if (!ignore_section_sym (abfd
, sym
))
4233 sym
->udata
.i
= i
+ 1;
4235 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4237 if (sect_syms
[asect
->index
] == NULL
)
4239 asymbol
*sym
= asect
->symbol
;
4242 sect_syms
[asect
->index
] = sym
;
4243 if (!sym_is_global (abfd
, sym
))
4246 i
= num_locals
+ num_globals2
++;
4248 sym
->udata
.i
= i
+ 1;
4252 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4254 *pnum_locals
= num_locals
;
4258 /* Align to the maximum file alignment that could be required for any
4259 ELF data structure. */
4261 static inline file_ptr
4262 align_file_position (file_ptr off
, int align
)
4264 return (off
+ align
- 1) & ~(align
- 1);
4267 /* Assign a file position to a section, optionally aligning to the
4268 required section alignment. */
4271 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4275 if (align
&& i_shdrp
->sh_addralign
> 1)
4276 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4277 i_shdrp
->sh_offset
= offset
;
4278 if (i_shdrp
->bfd_section
!= NULL
)
4279 i_shdrp
->bfd_section
->filepos
= offset
;
4280 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4281 offset
+= i_shdrp
->sh_size
;
4285 /* Compute the file positions we are going to put the sections at, and
4286 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4287 is not NULL, this is being called by the ELF backend linker. */
4290 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4291 struct bfd_link_info
*link_info
)
4293 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4294 struct fake_section_arg fsargs
;
4296 struct elf_strtab_hash
*strtab
= NULL
;
4297 Elf_Internal_Shdr
*shstrtab_hdr
;
4298 bfd_boolean need_symtab
;
4300 if (abfd
->output_has_begun
)
4303 /* Do any elf backend specific processing first. */
4304 if (bed
->elf_backend_begin_write_processing
)
4305 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4307 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4310 fsargs
.failed
= FALSE
;
4311 fsargs
.link_info
= link_info
;
4312 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4316 if (!assign_section_numbers (abfd
, link_info
))
4319 /* The backend linker builds symbol table information itself. */
4320 need_symtab
= (link_info
== NULL
4321 && (bfd_get_symcount (abfd
) > 0
4322 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4326 /* Non-zero if doing a relocatable link. */
4327 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4329 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
4334 if (link_info
== NULL
)
4336 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4341 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4342 /* sh_name was set in init_file_header. */
4343 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4344 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4345 shstrtab_hdr
->sh_addr
= 0;
4346 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4347 shstrtab_hdr
->sh_entsize
= 0;
4348 shstrtab_hdr
->sh_link
= 0;
4349 shstrtab_hdr
->sh_info
= 0;
4350 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4351 shstrtab_hdr
->sh_addralign
= 1;
4353 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4359 Elf_Internal_Shdr
*hdr
;
4361 off
= elf_next_file_pos (abfd
);
4363 hdr
= & elf_symtab_hdr (abfd
);
4364 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4366 if (elf_symtab_shndx_list (abfd
) != NULL
)
4368 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4369 if (hdr
->sh_size
!= 0)
4370 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4371 /* FIXME: What about other symtab_shndx sections in the list ? */
4374 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4375 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4377 elf_next_file_pos (abfd
) = off
;
4379 /* Now that we know where the .strtab section goes, write it
4381 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4382 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4384 _bfd_elf_strtab_free (strtab
);
4387 abfd
->output_has_begun
= TRUE
;
4392 /* Make an initial estimate of the size of the program header. If we
4393 get the number wrong here, we'll redo section placement. */
4395 static bfd_size_type
4396 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4400 const struct elf_backend_data
*bed
;
4402 /* Assume we will need exactly two PT_LOAD segments: one for text
4403 and one for data. */
4406 s
= bfd_get_section_by_name (abfd
, ".interp");
4407 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4409 /* If we have a loadable interpreter section, we need a
4410 PT_INTERP segment. In this case, assume we also need a
4411 PT_PHDR segment, although that may not be true for all
4416 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4418 /* We need a PT_DYNAMIC segment. */
4422 if (info
!= NULL
&& info
->relro
)
4424 /* We need a PT_GNU_RELRO segment. */
4428 if (elf_eh_frame_hdr (abfd
))
4430 /* We need a PT_GNU_EH_FRAME segment. */
4434 if (elf_stack_flags (abfd
))
4436 /* We need a PT_GNU_STACK segment. */
4440 s
= bfd_get_section_by_name (abfd
,
4441 NOTE_GNU_PROPERTY_SECTION_NAME
);
4442 if (s
!= NULL
&& s
->size
!= 0)
4444 /* We need a PT_GNU_PROPERTY segment. */
4448 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4450 if ((s
->flags
& SEC_LOAD
) != 0
4451 && elf_section_type (s
) == SHT_NOTE
)
4453 unsigned int alignment_power
;
4454 /* We need a PT_NOTE segment. */
4456 /* Try to create just one PT_NOTE segment for all adjacent
4457 loadable SHT_NOTE sections. gABI requires that within a
4458 PT_NOTE segment (and also inside of each SHT_NOTE section)
4459 each note should have the same alignment. So we check
4460 whether the sections are correctly aligned. */
4461 alignment_power
= s
->alignment_power
;
4462 while (s
->next
!= NULL
4463 && s
->next
->alignment_power
== alignment_power
4464 && (s
->next
->flags
& SEC_LOAD
) != 0
4465 && elf_section_type (s
->next
) == SHT_NOTE
)
4470 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4472 if (s
->flags
& SEC_THREAD_LOCAL
)
4474 /* We need a PT_TLS segment. */
4480 bed
= get_elf_backend_data (abfd
);
4482 if ((abfd
->flags
& D_PAGED
) != 0
4483 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4485 /* Add a PT_GNU_MBIND segment for each mbind section. */
4486 unsigned int page_align_power
= bfd_log2 (bed
->commonpagesize
);
4487 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4488 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4490 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4493 /* xgettext:c-format */
4494 (_("%pB: GNU_MBIND section `%pA' has invalid "
4495 "sh_info field: %d"),
4496 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4499 /* Align mbind section to page size. */
4500 if (s
->alignment_power
< page_align_power
)
4501 s
->alignment_power
= page_align_power
;
4506 /* Let the backend count up any program headers it might need. */
4507 if (bed
->elf_backend_additional_program_headers
)
4511 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4517 return segs
* bed
->s
->sizeof_phdr
;
4520 /* Find the segment that contains the output_section of section. */
4523 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4525 struct elf_segment_map
*m
;
4526 Elf_Internal_Phdr
*p
;
4528 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4534 for (i
= m
->count
- 1; i
>= 0; i
--)
4535 if (m
->sections
[i
] == section
)
4542 /* Create a mapping from a set of sections to a program segment. */
4544 static struct elf_segment_map
*
4545 make_mapping (bfd
*abfd
,
4546 asection
**sections
,
4551 struct elf_segment_map
*m
;
4556 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4557 amt
+= (to
- from
) * sizeof (asection
*);
4558 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4562 m
->p_type
= PT_LOAD
;
4563 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4564 m
->sections
[i
- from
] = *hdrpp
;
4565 m
->count
= to
- from
;
4567 if (from
== 0 && phdr
)
4569 /* Include the headers in the first PT_LOAD segment. */
4570 m
->includes_filehdr
= 1;
4571 m
->includes_phdrs
= 1;
4577 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4580 struct elf_segment_map
*
4581 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4583 struct elf_segment_map
*m
;
4585 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4586 sizeof (struct elf_segment_map
));
4590 m
->p_type
= PT_DYNAMIC
;
4592 m
->sections
[0] = dynsec
;
4597 /* Possibly add or remove segments from the segment map. */
4600 elf_modify_segment_map (bfd
*abfd
,
4601 struct bfd_link_info
*info
,
4602 bfd_boolean remove_empty_load
)
4604 struct elf_segment_map
**m
;
4605 const struct elf_backend_data
*bed
;
4607 /* The placement algorithm assumes that non allocated sections are
4608 not in PT_LOAD segments. We ensure this here by removing such
4609 sections from the segment map. We also remove excluded
4610 sections. Finally, any PT_LOAD segment without sections is
4612 m
= &elf_seg_map (abfd
);
4615 unsigned int i
, new_count
;
4617 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4619 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4620 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4621 || (*m
)->p_type
!= PT_LOAD
))
4623 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4627 (*m
)->count
= new_count
;
4629 if (remove_empty_load
4630 && (*m
)->p_type
== PT_LOAD
4632 && !(*m
)->includes_phdrs
)
4638 bed
= get_elf_backend_data (abfd
);
4639 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4641 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4648 #define IS_TBSS(s) \
4649 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4651 /* Set up a mapping from BFD sections to program segments. */
4654 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4657 struct elf_segment_map
*m
;
4658 asection
**sections
= NULL
;
4659 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4660 bfd_boolean no_user_phdrs
;
4662 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4665 info
->user_phdrs
= !no_user_phdrs
;
4667 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4671 struct elf_segment_map
*mfirst
;
4672 struct elf_segment_map
**pm
;
4675 unsigned int hdr_index
;
4676 bfd_vma maxpagesize
;
4678 bfd_boolean phdr_in_segment
;
4679 bfd_boolean writable
;
4680 bfd_boolean executable
;
4682 asection
*first_tls
= NULL
;
4683 asection
*first_mbind
= NULL
;
4684 asection
*dynsec
, *eh_frame_hdr
;
4686 bfd_vma addr_mask
, wrap_to
= 0;
4687 bfd_size_type phdr_size
;
4689 /* Select the allocated sections, and sort them. */
4691 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4692 sizeof (asection
*));
4693 if (sections
== NULL
)
4696 /* Calculate top address, avoiding undefined behaviour of shift
4697 left operator when shift count is equal to size of type
4699 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4700 addr_mask
= (addr_mask
<< 1) + 1;
4703 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4705 if ((s
->flags
& SEC_ALLOC
) != 0)
4707 /* target_index is unused until bfd_elf_final_link
4708 starts output of section symbols. Use it to make
4710 s
->target_index
= i
;
4713 /* A wrapping section potentially clashes with header. */
4714 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4715 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4718 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4721 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4723 phdr_size
= elf_program_header_size (abfd
);
4724 if (phdr_size
== (bfd_size_type
) -1)
4725 phdr_size
= get_program_header_size (abfd
, info
);
4726 phdr_size
+= bed
->s
->sizeof_ehdr
;
4727 maxpagesize
= bed
->maxpagesize
;
4728 if (maxpagesize
== 0)
4730 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4732 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4733 >= (phdr_size
& (maxpagesize
- 1))))
4734 /* For compatibility with old scripts that may not be using
4735 SIZEOF_HEADERS, add headers when it looks like space has
4736 been left for them. */
4737 phdr_in_segment
= TRUE
;
4739 /* Build the mapping. */
4743 /* If we have a .interp section, then create a PT_PHDR segment for
4744 the program headers and a PT_INTERP segment for the .interp
4746 s
= bfd_get_section_by_name (abfd
, ".interp");
4747 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4749 amt
= sizeof (struct elf_segment_map
);
4750 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4754 m
->p_type
= PT_PHDR
;
4756 m
->p_flags_valid
= 1;
4757 m
->includes_phdrs
= 1;
4758 phdr_in_segment
= TRUE
;
4762 amt
= sizeof (struct elf_segment_map
);
4763 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4767 m
->p_type
= PT_INTERP
;
4775 /* Look through the sections. We put sections in the same program
4776 segment when the start of the second section can be placed within
4777 a few bytes of the end of the first section. */
4783 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4785 && (dynsec
->flags
& SEC_LOAD
) == 0)
4788 if ((abfd
->flags
& D_PAGED
) == 0)
4789 phdr_in_segment
= FALSE
;
4791 /* Deal with -Ttext or something similar such that the first section
4792 is not adjacent to the program headers. This is an
4793 approximation, since at this point we don't know exactly how many
4794 program headers we will need. */
4795 if (phdr_in_segment
&& count
> 0)
4798 bfd_boolean separate_phdr
= FALSE
;
4800 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4802 && info
->separate_code
4803 && (sections
[0]->flags
& SEC_CODE
) != 0)
4805 /* If data sections should be separate from code and
4806 thus not executable, and the first section is
4807 executable then put the file and program headers in
4808 their own PT_LOAD. */
4809 separate_phdr
= TRUE
;
4810 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4811 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4813 /* The file and program headers are currently on the
4814 same page as the first section. Put them on the
4815 previous page if we can. */
4816 if (phdr_lma
>= maxpagesize
)
4817 phdr_lma
-= maxpagesize
;
4819 separate_phdr
= FALSE
;
4822 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4823 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4824 /* If file and program headers would be placed at the end
4825 of memory then it's probably better to omit them. */
4826 phdr_in_segment
= FALSE
;
4827 else if (phdr_lma
< wrap_to
)
4828 /* If a section wraps around to where we'll be placing
4829 file and program headers, then the headers will be
4831 phdr_in_segment
= FALSE
;
4832 else if (separate_phdr
)
4834 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4837 m
->p_paddr
= phdr_lma
;
4839 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4840 m
->p_paddr_valid
= 1;
4843 phdr_in_segment
= FALSE
;
4847 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4850 bfd_boolean new_segment
;
4854 /* See if this section and the last one will fit in the same
4857 if (last_hdr
== NULL
)
4859 /* If we don't have a segment yet, then we don't need a new
4860 one (we build the last one after this loop). */
4861 new_segment
= FALSE
;
4863 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4865 /* If this section has a different relation between the
4866 virtual address and the load address, then we need a new
4870 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4871 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4873 /* If this section has a load address that makes it overlap
4874 the previous section, then we need a new segment. */
4877 else if ((abfd
->flags
& D_PAGED
) != 0
4878 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4879 == (hdr
->lma
& -maxpagesize
)))
4881 /* If we are demand paged then we can't map two disk
4882 pages onto the same memory page. */
4883 new_segment
= FALSE
;
4885 /* In the next test we have to be careful when last_hdr->lma is close
4886 to the end of the address space. If the aligned address wraps
4887 around to the start of the address space, then there are no more
4888 pages left in memory and it is OK to assume that the current
4889 section can be included in the current segment. */
4890 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4891 + maxpagesize
> last_hdr
->lma
)
4892 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4893 + maxpagesize
<= hdr
->lma
))
4895 /* If putting this section in this segment would force us to
4896 skip a page in the segment, then we need a new segment. */
4899 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4900 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4902 /* We don't want to put a loaded section after a
4903 nonloaded (ie. bss style) section in the same segment
4904 as that will force the non-loaded section to be loaded.
4905 Consider .tbss sections as loaded for this purpose. */
4908 else if ((abfd
->flags
& D_PAGED
) == 0)
4910 /* If the file is not demand paged, which means that we
4911 don't require the sections to be correctly aligned in the
4912 file, then there is no other reason for a new segment. */
4913 new_segment
= FALSE
;
4915 else if (info
!= NULL
4916 && info
->separate_code
4917 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4922 && (hdr
->flags
& SEC_READONLY
) == 0)
4924 /* We don't want to put a writable section in a read only
4930 /* Otherwise, we can use the same segment. */
4931 new_segment
= FALSE
;
4934 /* Allow interested parties a chance to override our decision. */
4935 if (last_hdr
!= NULL
4937 && info
->callbacks
->override_segment_assignment
!= NULL
)
4939 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4945 if ((hdr
->flags
& SEC_READONLY
) == 0)
4947 if ((hdr
->flags
& SEC_CODE
) != 0)
4950 /* .tbss sections effectively have zero size. */
4951 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4955 /* We need a new program segment. We must create a new program
4956 header holding all the sections from hdr_index until hdr. */
4958 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4965 if ((hdr
->flags
& SEC_READONLY
) == 0)
4970 if ((hdr
->flags
& SEC_CODE
) == 0)
4976 /* .tbss sections effectively have zero size. */
4977 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4979 phdr_in_segment
= FALSE
;
4982 /* Create a final PT_LOAD program segment, but not if it's just
4984 if (last_hdr
!= NULL
4985 && (i
- hdr_index
!= 1
4986 || !IS_TBSS (last_hdr
)))
4988 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4996 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4999 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
5006 /* For each batch of consecutive loadable SHT_NOTE sections,
5007 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
5008 because if we link together nonloadable .note sections and
5009 loadable .note sections, we will generate two .note sections
5010 in the output file. */
5011 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5013 if ((s
->flags
& SEC_LOAD
) != 0
5014 && elf_section_type (s
) == SHT_NOTE
)
5017 unsigned int alignment_power
= s
->alignment_power
;
5020 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
5022 if (s2
->next
->alignment_power
== alignment_power
5023 && (s2
->next
->flags
& SEC_LOAD
) != 0
5024 && elf_section_type (s2
->next
) == SHT_NOTE
5025 && align_power (s2
->lma
+ s2
->size
,
5032 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5033 amt
+= count
* sizeof (asection
*);
5034 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5038 m
->p_type
= PT_NOTE
;
5042 m
->sections
[m
->count
- count
--] = s
;
5043 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5046 m
->sections
[m
->count
- 1] = s
;
5047 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5051 if (s
->flags
& SEC_THREAD_LOCAL
)
5057 if (first_mbind
== NULL
5058 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5062 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5065 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5066 amt
+= tls_count
* sizeof (asection
*);
5067 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5072 m
->count
= tls_count
;
5073 /* Mandated PF_R. */
5075 m
->p_flags_valid
= 1;
5077 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
5079 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5082 (_("%pB: TLS sections are not adjacent:"), abfd
);
5085 while (i
< (unsigned int) tls_count
)
5087 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5089 _bfd_error_handler (_(" TLS: %pA"), s
);
5093 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5096 bfd_set_error (bfd_error_bad_value
);
5108 && (abfd
->flags
& D_PAGED
) != 0
5109 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5110 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5111 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5112 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5114 /* Mandated PF_R. */
5115 unsigned long p_flags
= PF_R
;
5116 if ((s
->flags
& SEC_READONLY
) == 0)
5118 if ((s
->flags
& SEC_CODE
) != 0)
5121 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5122 m
= bfd_zalloc (abfd
, amt
);
5126 m
->p_type
= (PT_GNU_MBIND_LO
5127 + elf_section_data (s
)->this_hdr
.sh_info
);
5129 m
->p_flags_valid
= 1;
5131 m
->p_flags
= p_flags
;
5137 s
= bfd_get_section_by_name (abfd
,
5138 NOTE_GNU_PROPERTY_SECTION_NAME
);
5139 if (s
!= NULL
&& s
->size
!= 0)
5141 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5142 m
= bfd_zalloc (abfd
, amt
);
5146 m
->p_type
= PT_GNU_PROPERTY
;
5148 m
->p_flags_valid
= 1;
5155 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5157 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5158 if (eh_frame_hdr
!= NULL
5159 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5161 amt
= sizeof (struct elf_segment_map
);
5162 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5166 m
->p_type
= PT_GNU_EH_FRAME
;
5168 m
->sections
[0] = eh_frame_hdr
->output_section
;
5174 if (elf_stack_flags (abfd
))
5176 amt
= sizeof (struct elf_segment_map
);
5177 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5181 m
->p_type
= PT_GNU_STACK
;
5182 m
->p_flags
= elf_stack_flags (abfd
);
5183 m
->p_align
= bed
->stack_align
;
5184 m
->p_flags_valid
= 1;
5185 m
->p_align_valid
= m
->p_align
!= 0;
5186 if (info
->stacksize
> 0)
5188 m
->p_size
= info
->stacksize
;
5189 m
->p_size_valid
= 1;
5196 if (info
!= NULL
&& info
->relro
)
5198 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5200 if (m
->p_type
== PT_LOAD
5202 && m
->sections
[0]->vma
>= info
->relro_start
5203 && m
->sections
[0]->vma
< info
->relro_end
)
5206 while (--i
!= (unsigned) -1)
5207 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5208 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5211 if (i
!= (unsigned) -1)
5216 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5219 amt
= sizeof (struct elf_segment_map
);
5220 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5224 m
->p_type
= PT_GNU_RELRO
;
5231 elf_seg_map (abfd
) = mfirst
;
5234 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5237 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5239 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5244 if (sections
!= NULL
)
5249 /* Sort sections by address. */
5252 elf_sort_sections (const void *arg1
, const void *arg2
)
5254 const asection
*sec1
= *(const asection
**) arg1
;
5255 const asection
*sec2
= *(const asection
**) arg2
;
5256 bfd_size_type size1
, size2
;
5258 /* Sort by LMA first, since this is the address used to
5259 place the section into a segment. */
5260 if (sec1
->lma
< sec2
->lma
)
5262 else if (sec1
->lma
> sec2
->lma
)
5265 /* Then sort by VMA. Normally the LMA and the VMA will be
5266 the same, and this will do nothing. */
5267 if (sec1
->vma
< sec2
->vma
)
5269 else if (sec1
->vma
> sec2
->vma
)
5272 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5274 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5281 else if (TOEND (sec2
))
5286 /* Sort by size, to put zero sized sections
5287 before others at the same address. */
5289 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5290 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5297 return sec1
->target_index
- sec2
->target_index
;
5300 /* This qsort comparison functions sorts PT_LOAD segments first and
5301 by p_paddr, for assign_file_positions_for_load_sections. */
5304 elf_sort_segments (const void *arg1
, const void *arg2
)
5306 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5307 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5309 if (m1
->p_type
!= m2
->p_type
)
5311 if (m1
->p_type
== PT_NULL
)
5313 if (m2
->p_type
== PT_NULL
)
5315 return m1
->p_type
< m2
->p_type
? -1 : 1;
5317 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5318 return m1
->includes_filehdr
? -1 : 1;
5319 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5320 return m1
->no_sort_lma
? -1 : 1;
5321 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5325 if (m1
->p_paddr_valid
)
5327 else if (m1
->count
!= 0)
5328 lma1
= m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
;
5330 if (m2
->p_paddr_valid
)
5332 else if (m2
->count
!= 0)
5333 lma2
= m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
;
5335 return lma1
< lma2
? -1 : 1;
5337 if (m1
->idx
!= m2
->idx
)
5338 return m1
->idx
< m2
->idx
? -1 : 1;
5342 /* Ian Lance Taylor writes:
5344 We shouldn't be using % with a negative signed number. That's just
5345 not good. We have to make sure either that the number is not
5346 negative, or that the number has an unsigned type. When the types
5347 are all the same size they wind up as unsigned. When file_ptr is a
5348 larger signed type, the arithmetic winds up as signed long long,
5351 What we're trying to say here is something like ``increase OFF by
5352 the least amount that will cause it to be equal to the VMA modulo
5354 /* In other words, something like:
5356 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5357 off_offset = off % bed->maxpagesize;
5358 if (vma_offset < off_offset)
5359 adjustment = vma_offset + bed->maxpagesize - off_offset;
5361 adjustment = vma_offset - off_offset;
5363 which can be collapsed into the expression below. */
5366 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5368 /* PR binutils/16199: Handle an alignment of zero. */
5369 if (maxpagesize
== 0)
5371 return ((vma
- off
) % maxpagesize
);
5375 print_segment_map (const struct elf_segment_map
*m
)
5378 const char *pt
= get_segment_type (m
->p_type
);
5383 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5384 sprintf (buf
, "LOPROC+%7.7x",
5385 (unsigned int) (m
->p_type
- PT_LOPROC
));
5386 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5387 sprintf (buf
, "LOOS+%7.7x",
5388 (unsigned int) (m
->p_type
- PT_LOOS
));
5390 snprintf (buf
, sizeof (buf
), "%8.8x",
5391 (unsigned int) m
->p_type
);
5395 fprintf (stderr
, "%s:", pt
);
5396 for (j
= 0; j
< m
->count
; j
++)
5397 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5403 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5408 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5410 buf
= bfd_zmalloc (len
);
5413 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5418 /* Assign file positions to the sections based on the mapping from
5419 sections to segments. This function also sets up some fields in
5423 assign_file_positions_for_load_sections (bfd
*abfd
,
5424 struct bfd_link_info
*link_info
)
5426 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5427 struct elf_segment_map
*m
;
5428 struct elf_segment_map
*phdr_load_seg
;
5429 Elf_Internal_Phdr
*phdrs
;
5430 Elf_Internal_Phdr
*p
;
5432 bfd_size_type maxpagesize
;
5433 unsigned int alloc
, actual
;
5435 struct elf_segment_map
**sorted_seg_map
;
5437 if (link_info
== NULL
5438 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5442 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5447 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5448 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5452 /* PR binutils/12467. */
5453 elf_elfheader (abfd
)->e_phoff
= 0;
5454 elf_elfheader (abfd
)->e_phentsize
= 0;
5457 elf_elfheader (abfd
)->e_phnum
= alloc
;
5459 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5462 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5466 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5467 BFD_ASSERT (elf_program_header_size (abfd
)
5468 == actual
* bed
->s
->sizeof_phdr
);
5469 BFD_ASSERT (actual
>= alloc
);
5474 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5478 /* We're writing the size in elf_program_header_size (abfd),
5479 see assign_file_positions_except_relocs, so make sure we have
5480 that amount allocated, with trailing space cleared.
5481 The variable alloc contains the computed need, while
5482 elf_program_header_size (abfd) contains the size used for the
5484 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5485 where the layout is forced to according to a larger size in the
5486 last iterations for the testcase ld-elf/header. */
5487 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5488 + alloc
* sizeof (*sorted_seg_map
)));
5489 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5490 elf_tdata (abfd
)->phdr
= phdrs
;
5494 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5496 sorted_seg_map
[j
] = m
;
5497 /* If elf_segment_map is not from map_sections_to_segments, the
5498 sections may not be correctly ordered. NOTE: sorting should
5499 not be done to the PT_NOTE section of a corefile, which may
5500 contain several pseudo-sections artificially created by bfd.
5501 Sorting these pseudo-sections breaks things badly. */
5503 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5504 && m
->p_type
== PT_NOTE
))
5506 for (i
= 0; i
< m
->count
; i
++)
5507 m
->sections
[i
]->target_index
= i
;
5508 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5513 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5517 if ((abfd
->flags
& D_PAGED
) != 0)
5518 maxpagesize
= bed
->maxpagesize
;
5520 /* Sections must map to file offsets past the ELF file header. */
5521 off
= bed
->s
->sizeof_ehdr
;
5522 /* And if one of the PT_LOAD headers doesn't include the program
5523 headers then we'll be mapping program headers in the usual
5524 position after the ELF file header. */
5525 phdr_load_seg
= NULL
;
5526 for (j
= 0; j
< alloc
; j
++)
5528 m
= sorted_seg_map
[j
];
5529 if (m
->p_type
!= PT_LOAD
)
5531 if (m
->includes_phdrs
)
5537 if (phdr_load_seg
== NULL
)
5538 off
+= actual
* bed
->s
->sizeof_phdr
;
5540 for (j
= 0; j
< alloc
; j
++)
5544 bfd_boolean no_contents
;
5546 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5547 number of sections with contents contributing to both p_filesz
5548 and p_memsz, followed by a number of sections with no contents
5549 that just contribute to p_memsz. In this loop, OFF tracks next
5550 available file offset for PT_LOAD and PT_NOTE segments. */
5551 m
= sorted_seg_map
[j
];
5553 p
->p_type
= m
->p_type
;
5554 p
->p_flags
= m
->p_flags
;
5557 p
->p_vaddr
= m
->p_vaddr_offset
;
5559 p
->p_vaddr
= m
->sections
[0]->vma
+ m
->p_vaddr_offset
;
5561 if (m
->p_paddr_valid
)
5562 p
->p_paddr
= m
->p_paddr
;
5563 else if (m
->count
== 0)
5566 p
->p_paddr
= m
->sections
[0]->lma
+ m
->p_vaddr_offset
;
5568 if (p
->p_type
== PT_LOAD
5569 && (abfd
->flags
& D_PAGED
) != 0)
5571 /* p_align in demand paged PT_LOAD segments effectively stores
5572 the maximum page size. When copying an executable with
5573 objcopy, we set m->p_align from the input file. Use this
5574 value for maxpagesize rather than bed->maxpagesize, which
5575 may be different. Note that we use maxpagesize for PT_TLS
5576 segment alignment later in this function, so we are relying
5577 on at least one PT_LOAD segment appearing before a PT_TLS
5579 if (m
->p_align_valid
)
5580 maxpagesize
= m
->p_align
;
5582 p
->p_align
= maxpagesize
;
5584 else if (m
->p_align_valid
)
5585 p
->p_align
= m
->p_align
;
5586 else if (m
->count
== 0)
5587 p
->p_align
= 1 << bed
->s
->log_file_align
;
5589 if (m
== phdr_load_seg
)
5591 if (!m
->includes_filehdr
)
5593 off
+= actual
* bed
->s
->sizeof_phdr
;
5596 no_contents
= FALSE
;
5598 if (p
->p_type
== PT_LOAD
5601 bfd_size_type align
;
5602 unsigned int align_power
= 0;
5604 if (m
->p_align_valid
)
5608 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5610 unsigned int secalign
;
5612 secalign
= bfd_section_alignment (*secpp
);
5613 if (secalign
> align_power
)
5614 align_power
= secalign
;
5616 align
= (bfd_size_type
) 1 << align_power
;
5617 if (align
< maxpagesize
)
5618 align
= maxpagesize
;
5621 for (i
= 0; i
< m
->count
; i
++)
5622 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5623 /* If we aren't making room for this section, then
5624 it must be SHT_NOBITS regardless of what we've
5625 set via struct bfd_elf_special_section. */
5626 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5628 /* Find out whether this segment contains any loadable
5631 for (i
= 0; i
< m
->count
; i
++)
5632 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5634 no_contents
= FALSE
;
5638 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5640 /* Broken hardware and/or kernel require that files do not
5641 map the same page with different permissions on some hppa
5644 && (abfd
->flags
& D_PAGED
) != 0
5645 && bed
->no_page_alias
5646 && (off
& (maxpagesize
- 1)) != 0
5647 && (off
& -maxpagesize
) == ((off
+ off_adjust
) & -maxpagesize
))
5648 off_adjust
+= maxpagesize
;
5652 /* We shouldn't need to align the segment on disk since
5653 the segment doesn't need file space, but the gABI
5654 arguably requires the alignment and glibc ld.so
5655 checks it. So to comply with the alignment
5656 requirement but not waste file space, we adjust
5657 p_offset for just this segment. (OFF_ADJUST is
5658 subtracted from OFF later.) This may put p_offset
5659 past the end of file, but that shouldn't matter. */
5664 /* Make sure the .dynamic section is the first section in the
5665 PT_DYNAMIC segment. */
5666 else if (p
->p_type
== PT_DYNAMIC
5668 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5671 (_("%pB: The first section in the PT_DYNAMIC segment"
5672 " is not the .dynamic section"),
5674 bfd_set_error (bfd_error_bad_value
);
5677 /* Set the note section type to SHT_NOTE. */
5678 else if (p
->p_type
== PT_NOTE
)
5679 for (i
= 0; i
< m
->count
; i
++)
5680 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5682 if (m
->includes_filehdr
)
5684 if (!m
->p_flags_valid
)
5686 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5687 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5688 if (p
->p_type
== PT_LOAD
)
5692 if (p
->p_vaddr
< (bfd_vma
) off
5693 || (!m
->p_paddr_valid
5694 && p
->p_paddr
< (bfd_vma
) off
))
5697 (_("%pB: not enough room for program headers,"
5698 " try linking with -N"),
5700 bfd_set_error (bfd_error_bad_value
);
5704 if (!m
->p_paddr_valid
)
5708 else if (sorted_seg_map
[0]->includes_filehdr
)
5710 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5711 p
->p_vaddr
= filehdr
->p_vaddr
;
5712 if (!m
->p_paddr_valid
)
5713 p
->p_paddr
= filehdr
->p_paddr
;
5717 if (m
->includes_phdrs
)
5719 if (!m
->p_flags_valid
)
5721 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5722 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5723 if (!m
->includes_filehdr
)
5725 if (p
->p_type
== PT_LOAD
)
5727 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5730 p
->p_vaddr
-= off
- p
->p_offset
;
5731 if (!m
->p_paddr_valid
)
5732 p
->p_paddr
-= off
- p
->p_offset
;
5735 else if (phdr_load_seg
!= NULL
)
5737 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5738 bfd_vma phdr_off
= 0;
5739 if (phdr_load_seg
->includes_filehdr
)
5740 phdr_off
= bed
->s
->sizeof_ehdr
;
5741 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5742 if (!m
->p_paddr_valid
)
5743 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5744 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5747 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5751 if (p
->p_type
== PT_LOAD
5752 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5754 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5759 /* Put meaningless p_offset for PT_LOAD segments
5760 without file contents somewhere within the first
5761 page, in an attempt to not point past EOF. */
5762 bfd_size_type align
= maxpagesize
;
5763 if (align
< p
->p_align
)
5767 p
->p_offset
= off
% align
;
5774 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5776 p
->p_filesz
+= adjust
;
5777 p
->p_memsz
+= adjust
;
5781 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5782 maps. Set filepos for sections in PT_LOAD segments, and in
5783 core files, for sections in PT_NOTE segments.
5784 assign_file_positions_for_non_load_sections will set filepos
5785 for other sections and update p_filesz for other segments. */
5786 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5789 bfd_size_type align
;
5790 Elf_Internal_Shdr
*this_hdr
;
5793 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5794 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5796 if ((p
->p_type
== PT_LOAD
5797 || p
->p_type
== PT_TLS
)
5798 && (this_hdr
->sh_type
!= SHT_NOBITS
5799 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5800 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5801 || p
->p_type
== PT_TLS
))))
5803 bfd_vma p_start
= p
->p_paddr
;
5804 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5805 bfd_vma s_start
= sec
->lma
;
5806 bfd_vma adjust
= s_start
- p_end
;
5810 || p_end
< p_start
))
5813 /* xgettext:c-format */
5814 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5815 abfd
, sec
, (uint64_t) s_start
, (uint64_t) p_end
);
5819 p
->p_memsz
+= adjust
;
5821 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5823 if (p
->p_type
== PT_LOAD
)
5825 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5827 /* We have a PROGBITS section following NOBITS ones.
5828 Allocate file space for the NOBITS section(s) and
5830 adjust
= p
->p_memsz
- p
->p_filesz
;
5831 if (!write_zeros (abfd
, off
, adjust
))
5836 p
->p_filesz
+= adjust
;
5840 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5842 /* The section at i == 0 is the one that actually contains
5846 this_hdr
->sh_offset
= sec
->filepos
= off
;
5847 off
+= this_hdr
->sh_size
;
5848 p
->p_filesz
= this_hdr
->sh_size
;
5854 /* The rest are fake sections that shouldn't be written. */
5863 if (p
->p_type
== PT_LOAD
)
5865 this_hdr
->sh_offset
= sec
->filepos
= off
;
5866 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5867 off
+= this_hdr
->sh_size
;
5869 else if (this_hdr
->sh_type
== SHT_NOBITS
5870 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5871 && this_hdr
->sh_offset
== 0)
5873 /* This is a .tbss section that didn't get a PT_LOAD.
5874 (See _bfd_elf_map_sections_to_segments "Create a
5875 final PT_LOAD".) Set sh_offset to the value it
5876 would have if we had created a zero p_filesz and
5877 p_memsz PT_LOAD header for the section. This
5878 also makes the PT_TLS header have the same
5880 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5882 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5885 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5887 p
->p_filesz
+= this_hdr
->sh_size
;
5888 /* A load section without SHF_ALLOC is something like
5889 a note section in a PT_NOTE segment. These take
5890 file space but are not loaded into memory. */
5891 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5892 p
->p_memsz
+= this_hdr
->sh_size
;
5894 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5896 if (p
->p_type
== PT_TLS
)
5897 p
->p_memsz
+= this_hdr
->sh_size
;
5899 /* .tbss is special. It doesn't contribute to p_memsz of
5901 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5902 p
->p_memsz
+= this_hdr
->sh_size
;
5905 if (align
> p
->p_align
5906 && !m
->p_align_valid
5907 && (p
->p_type
!= PT_LOAD
5908 || (abfd
->flags
& D_PAGED
) == 0))
5912 if (!m
->p_flags_valid
)
5915 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5917 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5924 /* PR ld/20815 - Check that the program header segment, if
5925 present, will be loaded into memory. */
5926 if (p
->p_type
== PT_PHDR
5927 && phdr_load_seg
== NULL
5928 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5929 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5931 /* The fix for this error is usually to edit the linker script being
5932 used and set up the program headers manually. Either that or
5933 leave room for the headers at the start of the SECTIONS. */
5934 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5935 " by LOAD segment"),
5940 /* Check that all sections are in a PT_LOAD segment.
5941 Don't check funky gdb generated core files. */
5942 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5944 bfd_boolean check_vma
= TRUE
;
5946 for (i
= 1; i
< m
->count
; i
++)
5947 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5948 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5949 ->this_hdr
), p
) != 0
5950 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5951 ->this_hdr
), p
) != 0)
5953 /* Looks like we have overlays packed into the segment. */
5958 for (i
= 0; i
< m
->count
; i
++)
5960 Elf_Internal_Shdr
*this_hdr
;
5963 sec
= m
->sections
[i
];
5964 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5965 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5966 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5969 /* xgettext:c-format */
5970 (_("%pB: section `%pA' can't be allocated in segment %d"),
5972 print_segment_map (m
);
5978 elf_next_file_pos (abfd
) = off
;
5980 if (link_info
!= NULL
5981 && phdr_load_seg
!= NULL
5982 && phdr_load_seg
->includes_filehdr
)
5984 /* There is a segment that contains both the file headers and the
5985 program headers, so provide a symbol __ehdr_start pointing there.
5986 A program can use this to examine itself robustly. */
5988 struct elf_link_hash_entry
*hash
5989 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5990 FALSE
, FALSE
, TRUE
);
5991 /* If the symbol was referenced and not defined, define it. */
5993 && (hash
->root
.type
== bfd_link_hash_new
5994 || hash
->root
.type
== bfd_link_hash_undefined
5995 || hash
->root
.type
== bfd_link_hash_undefweak
5996 || hash
->root
.type
== bfd_link_hash_common
))
5999 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
;
6001 if (phdr_load_seg
->count
!= 0)
6002 /* The segment contains sections, so use the first one. */
6003 s
= phdr_load_seg
->sections
[0];
6005 /* Use the first (i.e. lowest-addressed) section in any segment. */
6006 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6007 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6015 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6016 hash
->root
.u
.def
.section
= s
;
6020 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6021 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6024 hash
->root
.type
= bfd_link_hash_defined
;
6025 hash
->def_regular
= 1;
6033 /* Determine if a bfd is a debuginfo file. Unfortunately there
6034 is no defined method for detecting such files, so we have to
6035 use heuristics instead. */
6038 is_debuginfo_file (bfd
*abfd
)
6040 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6043 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6044 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6045 Elf_Internal_Shdr
**headerp
;
6047 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6049 Elf_Internal_Shdr
*header
= * headerp
;
6051 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6052 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6053 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6054 && header
->sh_type
!= SHT_NOBITS
6055 && header
->sh_type
!= SHT_NOTE
)
6062 /* Assign file positions for the other sections, except for compressed debugging
6063 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6066 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6067 struct bfd_link_info
*link_info
)
6069 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6070 Elf_Internal_Shdr
**i_shdrpp
;
6071 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6072 Elf_Internal_Phdr
*phdrs
;
6073 Elf_Internal_Phdr
*p
;
6074 struct elf_segment_map
*m
;
6077 i_shdrpp
= elf_elfsections (abfd
);
6078 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6079 off
= elf_next_file_pos (abfd
);
6080 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6082 Elf_Internal_Shdr
*hdr
;
6085 if (hdr
->bfd_section
!= NULL
6086 && (hdr
->bfd_section
->filepos
!= 0
6087 || (hdr
->sh_type
== SHT_NOBITS
6088 && hdr
->contents
== NULL
)))
6089 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6090 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6092 if (hdr
->sh_size
!= 0
6093 /* PR 24717 - debuginfo files are known to be not strictly
6094 compliant with the ELF standard. In particular they often
6095 have .note.gnu.property sections that are outside of any
6096 loadable segment. This is not a problem for such files,
6097 so do not warn about them. */
6098 && ! is_debuginfo_file (abfd
))
6100 /* xgettext:c-format */
6101 (_("%pB: warning: allocated section `%s' not in segment"),
6103 (hdr
->bfd_section
== NULL
6105 : hdr
->bfd_section
->name
));
6106 /* We don't need to page align empty sections. */
6107 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6108 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6111 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6113 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6116 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6117 && hdr
->bfd_section
== NULL
)
6118 /* We don't know the offset of these sections yet: their size has
6119 not been decided. */
6120 || (hdr
->bfd_section
!= NULL
6121 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6122 || (bfd_section_is_ctf (hdr
->bfd_section
)
6123 && abfd
->is_linker_output
)))
6124 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6125 || (elf_symtab_shndx_list (abfd
) != NULL
6126 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6127 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6128 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6129 hdr
->sh_offset
= -1;
6131 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6133 elf_next_file_pos (abfd
) = off
;
6135 /* Now that we have set the section file positions, we can set up
6136 the file positions for the non PT_LOAD segments. */
6137 phdrs
= elf_tdata (abfd
)->phdr
;
6138 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6140 if (p
->p_type
== PT_GNU_RELRO
)
6145 if (link_info
!= NULL
)
6147 /* During linking the range of the RELRO segment is passed
6148 in link_info. Note that there may be padding between
6149 relro_start and the first RELRO section. */
6150 start
= link_info
->relro_start
;
6151 end
= link_info
->relro_end
;
6153 else if (m
->count
!= 0)
6155 if (!m
->p_size_valid
)
6157 start
= m
->sections
[0]->vma
;
6158 end
= start
+ m
->p_size
;
6169 struct elf_segment_map
*lm
;
6170 const Elf_Internal_Phdr
*lp
;
6173 /* Find a LOAD segment containing a section in the RELRO
6175 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6177 lm
= lm
->next
, lp
++)
6179 if (lp
->p_type
== PT_LOAD
6181 && (lm
->sections
[lm
->count
- 1]->vma
6182 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6183 ? lm
->sections
[lm
->count
- 1]->size
6185 && lm
->sections
[0]->vma
< end
)
6191 /* Find the section starting the RELRO segment. */
6192 for (i
= 0; i
< lm
->count
; i
++)
6194 asection
*s
= lm
->sections
[i
];
6203 p
->p_vaddr
= lm
->sections
[i
]->vma
;
6204 p
->p_paddr
= lm
->sections
[i
]->lma
;
6205 p
->p_offset
= lm
->sections
[i
]->filepos
;
6206 p
->p_memsz
= end
- p
->p_vaddr
;
6207 p
->p_filesz
= p
->p_memsz
;
6209 /* The RELRO segment typically ends a few bytes
6210 into .got.plt but other layouts are possible.
6211 In cases where the end does not match any
6212 loaded section (for instance is in file
6213 padding), trim p_filesz back to correspond to
6214 the end of loaded section contents. */
6215 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6216 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6218 /* Preserve the alignment and flags if they are
6219 valid. The gold linker generates RW/4 for
6220 the PT_GNU_RELRO section. It is better for
6221 objcopy/strip to honor these attributes
6222 otherwise gdb will choke when using separate
6224 if (!m
->p_align_valid
)
6226 if (!m
->p_flags_valid
)
6232 if (link_info
!= NULL
)
6235 memset (p
, 0, sizeof *p
);
6237 else if (p
->p_type
== PT_GNU_STACK
)
6239 if (m
->p_size_valid
)
6240 p
->p_memsz
= m
->p_size
;
6242 else if (m
->count
!= 0)
6246 if (p
->p_type
!= PT_LOAD
6247 && (p
->p_type
!= PT_NOTE
6248 || bfd_get_format (abfd
) != bfd_core
))
6250 /* A user specified segment layout may include a PHDR
6251 segment that overlaps with a LOAD segment... */
6252 if (p
->p_type
== PT_PHDR
)
6258 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6260 /* PR 17512: file: 2195325e. */
6262 (_("%pB: error: non-load segment %d includes file header "
6263 "and/or program header"),
6264 abfd
, (int) (p
- phdrs
));
6269 p
->p_offset
= m
->sections
[0]->filepos
;
6270 for (i
= m
->count
; i
-- != 0;)
6272 asection
*sect
= m
->sections
[i
];
6273 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6274 if (hdr
->sh_type
!= SHT_NOBITS
)
6276 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6288 static elf_section_list
*
6289 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6291 for (;list
!= NULL
; list
= list
->next
)
6297 /* Work out the file positions of all the sections. This is called by
6298 _bfd_elf_compute_section_file_positions. All the section sizes and
6299 VMAs must be known before this is called.
6301 Reloc sections come in two flavours: Those processed specially as
6302 "side-channel" data attached to a section to which they apply, and those that
6303 bfd doesn't process as relocations. The latter sort are stored in a normal
6304 bfd section by bfd_section_from_shdr. We don't consider the former sort
6305 here, unless they form part of the loadable image. Reloc sections not
6306 assigned here (and compressed debugging sections and CTF sections which
6307 nothing else in the file can rely upon) will be handled later by
6308 assign_file_positions_for_relocs.
6310 We also don't set the positions of the .symtab and .strtab here. */
6313 assign_file_positions_except_relocs (bfd
*abfd
,
6314 struct bfd_link_info
*link_info
)
6316 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6317 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6318 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6321 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6322 && bfd_get_format (abfd
) != bfd_core
)
6324 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6325 unsigned int num_sec
= elf_numsections (abfd
);
6326 Elf_Internal_Shdr
**hdrpp
;
6330 /* Start after the ELF header. */
6331 off
= i_ehdrp
->e_ehsize
;
6333 /* We are not creating an executable, which means that we are
6334 not creating a program header, and that the actual order of
6335 the sections in the file is unimportant. */
6336 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6338 Elf_Internal_Shdr
*hdr
;
6341 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6342 && hdr
->bfd_section
== NULL
)
6343 /* Do not assign offsets for these sections yet: we don't know
6345 || (hdr
->bfd_section
!= NULL
6346 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6347 || (bfd_section_is_ctf (hdr
->bfd_section
)
6348 && abfd
->is_linker_output
)))
6349 || i
== elf_onesymtab (abfd
)
6350 || (elf_symtab_shndx_list (abfd
) != NULL
6351 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6352 || i
== elf_strtab_sec (abfd
)
6353 || i
== elf_shstrtab_sec (abfd
))
6355 hdr
->sh_offset
= -1;
6358 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6361 elf_next_file_pos (abfd
) = off
;
6362 elf_program_header_size (abfd
) = 0;
6366 /* Assign file positions for the loaded sections based on the
6367 assignment of sections to segments. */
6368 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6371 /* And for non-load sections. */
6372 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6376 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6379 /* Write out the program headers. */
6380 alloc
= i_ehdrp
->e_phnum
;
6383 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6384 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6392 _bfd_elf_init_file_header (bfd
*abfd
,
6393 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6395 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6396 struct elf_strtab_hash
*shstrtab
;
6397 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6399 i_ehdrp
= elf_elfheader (abfd
);
6401 shstrtab
= _bfd_elf_strtab_init ();
6402 if (shstrtab
== NULL
)
6405 elf_shstrtab (abfd
) = shstrtab
;
6407 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6408 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6409 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6410 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6412 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6413 i_ehdrp
->e_ident
[EI_DATA
] =
6414 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6415 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6417 if ((abfd
->flags
& DYNAMIC
) != 0)
6418 i_ehdrp
->e_type
= ET_DYN
;
6419 else if ((abfd
->flags
& EXEC_P
) != 0)
6420 i_ehdrp
->e_type
= ET_EXEC
;
6421 else if (bfd_get_format (abfd
) == bfd_core
)
6422 i_ehdrp
->e_type
= ET_CORE
;
6424 i_ehdrp
->e_type
= ET_REL
;
6426 switch (bfd_get_arch (abfd
))
6428 case bfd_arch_unknown
:
6429 i_ehdrp
->e_machine
= EM_NONE
;
6432 /* There used to be a long list of cases here, each one setting
6433 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6434 in the corresponding bfd definition. To avoid duplication,
6435 the switch was removed. Machines that need special handling
6436 can generally do it in elf_backend_final_write_processing(),
6437 unless they need the information earlier than the final write.
6438 Such need can generally be supplied by replacing the tests for
6439 e_machine with the conditions used to determine it. */
6441 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6444 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6445 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6447 /* No program header, for now. */
6448 i_ehdrp
->e_phoff
= 0;
6449 i_ehdrp
->e_phentsize
= 0;
6450 i_ehdrp
->e_phnum
= 0;
6452 /* Each bfd section is section header entry. */
6453 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6454 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6456 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6457 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6458 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6459 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6460 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6461 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6462 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6463 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6464 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6470 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6472 FIXME: We used to have code here to sort the PT_LOAD segments into
6473 ascending order, as per the ELF spec. But this breaks some programs,
6474 including the Linux kernel. But really either the spec should be
6475 changed or the programs updated. */
6478 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6480 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6482 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6483 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6484 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6485 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6486 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6488 /* Find the lowest p_vaddr in PT_LOAD segments. */
6489 bfd_vma p_vaddr
= (bfd_vma
) -1;
6490 for (; segment
< end_segment
; segment
++)
6491 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6492 p_vaddr
= segment
->p_vaddr
;
6494 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6495 segments is non-zero. */
6497 i_ehdrp
->e_type
= ET_EXEC
;
6502 /* Assign file positions for all the reloc sections which are not part
6503 of the loadable file image, and the file position of section headers. */
6506 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6509 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6510 Elf_Internal_Shdr
*shdrp
;
6511 Elf_Internal_Ehdr
*i_ehdrp
;
6512 const struct elf_backend_data
*bed
;
6514 off
= elf_next_file_pos (abfd
);
6516 shdrpp
= elf_elfsections (abfd
);
6517 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6518 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6521 if (shdrp
->sh_offset
== -1)
6523 asection
*sec
= shdrp
->bfd_section
;
6524 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6525 || shdrp
->sh_type
== SHT_RELA
);
6526 bfd_boolean is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6529 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6531 if (!is_rel
&& !is_ctf
)
6533 const char *name
= sec
->name
;
6534 struct bfd_elf_section_data
*d
;
6536 /* Compress DWARF debug sections. */
6537 if (!bfd_compress_section (abfd
, sec
,
6541 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6542 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6544 /* If section is compressed with zlib-gnu, convert
6545 section name from .debug_* to .zdebug_*. */
6547 = convert_debug_to_zdebug (abfd
, name
);
6548 if (new_name
== NULL
)
6552 /* Add section name to section name section. */
6553 if (shdrp
->sh_name
!= (unsigned int) -1)
6556 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6558 d
= elf_section_data (sec
);
6560 /* Add reloc section name to section name section. */
6562 && !_bfd_elf_set_reloc_sh_name (abfd
,
6567 && !_bfd_elf_set_reloc_sh_name (abfd
,
6572 /* Update section size and contents. */
6573 shdrp
->sh_size
= sec
->size
;
6574 shdrp
->contents
= sec
->contents
;
6575 shdrp
->bfd_section
->contents
= NULL
;
6579 /* Update section size and contents. */
6580 shdrp
->sh_size
= sec
->size
;
6581 shdrp
->contents
= sec
->contents
;
6584 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6591 /* Place section name section after DWARF debug sections have been
6593 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6594 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6595 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6596 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6598 /* Place the section headers. */
6599 i_ehdrp
= elf_elfheader (abfd
);
6600 bed
= get_elf_backend_data (abfd
);
6601 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6602 i_ehdrp
->e_shoff
= off
;
6603 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6604 elf_next_file_pos (abfd
) = off
;
6610 _bfd_elf_write_object_contents (bfd
*abfd
)
6612 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6613 Elf_Internal_Shdr
**i_shdrp
;
6615 unsigned int count
, num_sec
;
6616 struct elf_obj_tdata
*t
;
6618 if (! abfd
->output_has_begun
6619 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6621 /* Do not rewrite ELF data when the BFD has been opened for update.
6622 abfd->output_has_begun was set to TRUE on opening, so creation of new
6623 sections, and modification of existing section sizes was restricted.
6624 This means the ELF header, program headers and section headers can't have
6626 If the contents of any sections has been modified, then those changes have
6627 already been written to the BFD. */
6628 else if (abfd
->direction
== both_direction
)
6630 BFD_ASSERT (abfd
->output_has_begun
);
6634 i_shdrp
= elf_elfsections (abfd
);
6637 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6641 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6644 /* After writing the headers, we need to write the sections too... */
6645 num_sec
= elf_numsections (abfd
);
6646 for (count
= 1; count
< num_sec
; count
++)
6648 i_shdrp
[count
]->sh_name
6649 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6650 i_shdrp
[count
]->sh_name
);
6651 if (bed
->elf_backend_section_processing
)
6652 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6654 if (i_shdrp
[count
]->contents
)
6656 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6658 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6659 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6664 /* Write out the section header names. */
6665 t
= elf_tdata (abfd
);
6666 if (elf_shstrtab (abfd
) != NULL
6667 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6668 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6671 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6674 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6677 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6678 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6679 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6685 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6687 /* Hopefully this can be done just like an object file. */
6688 return _bfd_elf_write_object_contents (abfd
);
6691 /* Given a section, search the header to find them. */
6694 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6696 const struct elf_backend_data
*bed
;
6697 unsigned int sec_index
;
6699 if (elf_section_data (asect
) != NULL
6700 && elf_section_data (asect
)->this_idx
!= 0)
6701 return elf_section_data (asect
)->this_idx
;
6703 if (bfd_is_abs_section (asect
))
6704 sec_index
= SHN_ABS
;
6705 else if (bfd_is_com_section (asect
))
6706 sec_index
= SHN_COMMON
;
6707 else if (bfd_is_und_section (asect
))
6708 sec_index
= SHN_UNDEF
;
6710 sec_index
= SHN_BAD
;
6712 bed
= get_elf_backend_data (abfd
);
6713 if (bed
->elf_backend_section_from_bfd_section
)
6715 int retval
= sec_index
;
6717 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6721 if (sec_index
== SHN_BAD
)
6722 bfd_set_error (bfd_error_nonrepresentable_section
);
6727 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6731 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6733 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6735 flagword flags
= asym_ptr
->flags
;
6737 /* When gas creates relocations against local labels, it creates its
6738 own symbol for the section, but does put the symbol into the
6739 symbol chain, so udata is 0. When the linker is generating
6740 relocatable output, this section symbol may be for one of the
6741 input sections rather than the output section. */
6742 if (asym_ptr
->udata
.i
== 0
6743 && (flags
& BSF_SECTION_SYM
)
6744 && asym_ptr
->section
)
6749 sec
= asym_ptr
->section
;
6750 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6751 sec
= sec
->output_section
;
6752 if (sec
->owner
== abfd
6753 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6754 && elf_section_syms (abfd
)[indx
] != NULL
)
6755 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6758 idx
= asym_ptr
->udata
.i
;
6762 /* This case can occur when using --strip-symbol on a symbol
6763 which is used in a relocation entry. */
6765 /* xgettext:c-format */
6766 (_("%pB: symbol `%s' required but not present"),
6767 abfd
, bfd_asymbol_name (asym_ptr
));
6768 bfd_set_error (bfd_error_no_symbols
);
6775 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6776 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6784 /* Rewrite program header information. */
6787 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6789 Elf_Internal_Ehdr
*iehdr
;
6790 struct elf_segment_map
*map
;
6791 struct elf_segment_map
*map_first
;
6792 struct elf_segment_map
**pointer_to_map
;
6793 Elf_Internal_Phdr
*segment
;
6796 unsigned int num_segments
;
6797 bfd_boolean phdr_included
= FALSE
;
6798 bfd_boolean p_paddr_valid
;
6799 bfd_vma maxpagesize
;
6800 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6801 unsigned int phdr_adjust_num
= 0;
6802 const struct elf_backend_data
*bed
;
6804 bed
= get_elf_backend_data (ibfd
);
6805 iehdr
= elf_elfheader (ibfd
);
6808 pointer_to_map
= &map_first
;
6810 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6811 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6813 /* Returns the end address of the segment + 1. */
6814 #define SEGMENT_END(segment, start) \
6815 (start + (segment->p_memsz > segment->p_filesz \
6816 ? segment->p_memsz : segment->p_filesz))
6818 #define SECTION_SIZE(section, segment) \
6819 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6820 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6821 ? section->size : 0)
6823 /* Returns TRUE if the given section is contained within
6824 the given segment. VMA addresses are compared. */
6825 #define IS_CONTAINED_BY_VMA(section, segment) \
6826 (section->vma >= segment->p_vaddr \
6827 && (section->vma + SECTION_SIZE (section, segment) \
6828 <= (SEGMENT_END (segment, segment->p_vaddr))))
6830 /* Returns TRUE if the given section is contained within
6831 the given segment. LMA addresses are compared. */
6832 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6833 (section->lma >= base \
6834 && (section->lma + SECTION_SIZE (section, segment) >= section->lma) \
6835 && (section->lma + SECTION_SIZE (section, segment) \
6836 <= SEGMENT_END (segment, base)))
6838 /* Handle PT_NOTE segment. */
6839 #define IS_NOTE(p, s) \
6840 (p->p_type == PT_NOTE \
6841 && elf_section_type (s) == SHT_NOTE \
6842 && (bfd_vma) s->filepos >= p->p_offset \
6843 && ((bfd_vma) s->filepos + s->size \
6844 <= p->p_offset + p->p_filesz))
6846 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6848 #define IS_COREFILE_NOTE(p, s) \
6850 && bfd_get_format (ibfd) == bfd_core \
6854 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6855 linker, which generates a PT_INTERP section with p_vaddr and
6856 p_memsz set to 0. */
6857 #define IS_SOLARIS_PT_INTERP(p, s) \
6859 && p->p_paddr == 0 \
6860 && p->p_memsz == 0 \
6861 && p->p_filesz > 0 \
6862 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6864 && (bfd_vma) s->filepos >= p->p_offset \
6865 && ((bfd_vma) s->filepos + s->size \
6866 <= p->p_offset + p->p_filesz))
6868 /* Decide if the given section should be included in the given segment.
6869 A section will be included if:
6870 1. It is within the address space of the segment -- we use the LMA
6871 if that is set for the segment and the VMA otherwise,
6872 2. It is an allocated section or a NOTE section in a PT_NOTE
6874 3. There is an output section associated with it,
6875 4. The section has not already been allocated to a previous segment.
6876 5. PT_GNU_STACK segments do not include any sections.
6877 6. PT_TLS segment includes only SHF_TLS sections.
6878 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6879 8. PT_DYNAMIC should not contain empty sections at the beginning
6880 (with the possible exception of .dynamic). */
6881 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6882 ((((segment->p_paddr \
6883 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6884 : IS_CONTAINED_BY_VMA (section, segment)) \
6885 && (section->flags & SEC_ALLOC) != 0) \
6886 || IS_NOTE (segment, section)) \
6887 && segment->p_type != PT_GNU_STACK \
6888 && (segment->p_type != PT_TLS \
6889 || (section->flags & SEC_THREAD_LOCAL)) \
6890 && (segment->p_type == PT_LOAD \
6891 || segment->p_type == PT_TLS \
6892 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6893 && (segment->p_type != PT_DYNAMIC \
6894 || SECTION_SIZE (section, segment) > 0 \
6895 || (segment->p_paddr \
6896 ? segment->p_paddr != section->lma \
6897 : segment->p_vaddr != section->vma) \
6898 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6899 && (segment->p_type != PT_LOAD || !section->segment_mark))
6901 /* If the output section of a section in the input segment is NULL,
6902 it is removed from the corresponding output segment. */
6903 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6904 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6905 && section->output_section != NULL)
6907 /* Returns TRUE iff seg1 starts after the end of seg2. */
6908 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6909 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6911 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6912 their VMA address ranges and their LMA address ranges overlap.
6913 It is possible to have overlapping VMA ranges without overlapping LMA
6914 ranges. RedBoot images for example can have both .data and .bss mapped
6915 to the same VMA range, but with the .data section mapped to a different
6917 #define SEGMENT_OVERLAPS(seg1, seg2) \
6918 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6919 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6920 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6921 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6923 /* Initialise the segment mark field. */
6924 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6925 section
->segment_mark
= FALSE
;
6927 /* The Solaris linker creates program headers in which all the
6928 p_paddr fields are zero. When we try to objcopy or strip such a
6929 file, we get confused. Check for this case, and if we find it
6930 don't set the p_paddr_valid fields. */
6931 p_paddr_valid
= FALSE
;
6932 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6935 if (segment
->p_paddr
!= 0)
6937 p_paddr_valid
= TRUE
;
6941 /* Scan through the segments specified in the program header
6942 of the input BFD. For this first scan we look for overlaps
6943 in the loadable segments. These can be created by weird
6944 parameters to objcopy. Also, fix some solaris weirdness. */
6945 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6950 Elf_Internal_Phdr
*segment2
;
6952 if (segment
->p_type
== PT_INTERP
)
6953 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6954 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6956 /* Mininal change so that the normal section to segment
6957 assignment code will work. */
6958 segment
->p_vaddr
= section
->vma
;
6962 if (segment
->p_type
!= PT_LOAD
)
6964 /* Remove PT_GNU_RELRO segment. */
6965 if (segment
->p_type
== PT_GNU_RELRO
)
6966 segment
->p_type
= PT_NULL
;
6970 /* Determine if this segment overlaps any previous segments. */
6971 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6973 bfd_signed_vma extra_length
;
6975 if (segment2
->p_type
!= PT_LOAD
6976 || !SEGMENT_OVERLAPS (segment
, segment2
))
6979 /* Merge the two segments together. */
6980 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6982 /* Extend SEGMENT2 to include SEGMENT and then delete
6984 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6985 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6987 if (extra_length
> 0)
6989 segment2
->p_memsz
+= extra_length
;
6990 segment2
->p_filesz
+= extra_length
;
6993 segment
->p_type
= PT_NULL
;
6995 /* Since we have deleted P we must restart the outer loop. */
6997 segment
= elf_tdata (ibfd
)->phdr
;
7002 /* Extend SEGMENT to include SEGMENT2 and then delete
7004 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
7005 - SEGMENT_END (segment
, segment
->p_vaddr
));
7007 if (extra_length
> 0)
7009 segment
->p_memsz
+= extra_length
;
7010 segment
->p_filesz
+= extra_length
;
7013 segment2
->p_type
= PT_NULL
;
7018 /* The second scan attempts to assign sections to segments. */
7019 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7023 unsigned int section_count
;
7024 asection
**sections
;
7025 asection
*output_section
;
7027 asection
*matching_lma
;
7028 asection
*suggested_lma
;
7031 asection
*first_section
;
7033 if (segment
->p_type
== PT_NULL
)
7036 first_section
= NULL
;
7037 /* Compute how many sections might be placed into this segment. */
7038 for (section
= ibfd
->sections
, section_count
= 0;
7040 section
= section
->next
)
7042 /* Find the first section in the input segment, which may be
7043 removed from the corresponding output segment. */
7044 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
7046 if (first_section
== NULL
)
7047 first_section
= section
;
7048 if (section
->output_section
!= NULL
)
7053 /* Allocate a segment map big enough to contain
7054 all of the sections we have selected. */
7055 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7056 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7057 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7061 /* Initialise the fields of the segment map. Default to
7062 using the physical address of the segment in the input BFD. */
7064 map
->p_type
= segment
->p_type
;
7065 map
->p_flags
= segment
->p_flags
;
7066 map
->p_flags_valid
= 1;
7068 /* If the first section in the input segment is removed, there is
7069 no need to preserve segment physical address in the corresponding
7071 if (!first_section
|| first_section
->output_section
!= NULL
)
7073 map
->p_paddr
= segment
->p_paddr
;
7074 map
->p_paddr_valid
= p_paddr_valid
;
7077 /* Determine if this segment contains the ELF file header
7078 and if it contains the program headers themselves. */
7079 map
->includes_filehdr
= (segment
->p_offset
== 0
7080 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7081 map
->includes_phdrs
= 0;
7083 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7085 map
->includes_phdrs
=
7086 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7087 && (segment
->p_offset
+ segment
->p_filesz
7088 >= ((bfd_vma
) iehdr
->e_phoff
7089 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7091 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7092 phdr_included
= TRUE
;
7095 if (section_count
== 0)
7097 /* Special segments, such as the PT_PHDR segment, may contain
7098 no sections, but ordinary, loadable segments should contain
7099 something. They are allowed by the ELF spec however, so only
7100 a warning is produced.
7101 There is however the valid use case of embedded systems which
7102 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7103 flash memory with zeros. No warning is shown for that case. */
7104 if (segment
->p_type
== PT_LOAD
7105 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7106 /* xgettext:c-format */
7108 (_("%pB: warning: empty loadable segment detected"
7109 " at vaddr=%#" PRIx64
", is this intentional?"),
7110 ibfd
, (uint64_t) segment
->p_vaddr
);
7112 map
->p_vaddr_offset
= segment
->p_vaddr
;
7114 *pointer_to_map
= map
;
7115 pointer_to_map
= &map
->next
;
7120 /* Now scan the sections in the input BFD again and attempt
7121 to add their corresponding output sections to the segment map.
7122 The problem here is how to handle an output section which has
7123 been moved (ie had its LMA changed). There are four possibilities:
7125 1. None of the sections have been moved.
7126 In this case we can continue to use the segment LMA from the
7129 2. All of the sections have been moved by the same amount.
7130 In this case we can change the segment's LMA to match the LMA
7131 of the first section.
7133 3. Some of the sections have been moved, others have not.
7134 In this case those sections which have not been moved can be
7135 placed in the current segment which will have to have its size,
7136 and possibly its LMA changed, and a new segment or segments will
7137 have to be created to contain the other sections.
7139 4. The sections have been moved, but not by the same amount.
7140 In this case we can change the segment's LMA to match the LMA
7141 of the first section and we will have to create a new segment
7142 or segments to contain the other sections.
7144 In order to save time, we allocate an array to hold the section
7145 pointers that we are interested in. As these sections get assigned
7146 to a segment, they are removed from this array. */
7148 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
7149 if (sections
== NULL
)
7152 /* Step One: Scan for segment vs section LMA conflicts.
7153 Also add the sections to the section array allocated above.
7154 Also add the sections to the current segment. In the common
7155 case, where the sections have not been moved, this means that
7156 we have completely filled the segment, and there is nothing
7159 matching_lma
= NULL
;
7160 suggested_lma
= NULL
;
7162 for (section
= first_section
, j
= 0;
7164 section
= section
->next
)
7166 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
7168 output_section
= section
->output_section
;
7170 sections
[j
++] = section
;
7172 /* The Solaris native linker always sets p_paddr to 0.
7173 We try to catch that case here, and set it to the
7174 correct value. Note - some backends require that
7175 p_paddr be left as zero. */
7177 && segment
->p_vaddr
!= 0
7178 && !bed
->want_p_paddr_set_to_zero
7180 && output_section
->lma
!= 0
7181 && (align_power (segment
->p_vaddr
7182 + (map
->includes_filehdr
7183 ? iehdr
->e_ehsize
: 0)
7184 + (map
->includes_phdrs
7185 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7187 output_section
->alignment_power
)
7188 == output_section
->vma
))
7189 map
->p_paddr
= segment
->p_vaddr
;
7191 /* Match up the physical address of the segment with the
7192 LMA address of the output section. */
7193 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7194 || IS_COREFILE_NOTE (segment
, section
)
7195 || (bed
->want_p_paddr_set_to_zero
7196 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
7198 if (matching_lma
== NULL
7199 || output_section
->lma
< matching_lma
->lma
)
7200 matching_lma
= output_section
;
7202 /* We assume that if the section fits within the segment
7203 then it does not overlap any other section within that
7205 map
->sections
[isec
++] = output_section
;
7207 else if (suggested_lma
== NULL
)
7208 suggested_lma
= output_section
;
7210 if (j
== section_count
)
7215 BFD_ASSERT (j
== section_count
);
7217 /* Step Two: Adjust the physical address of the current segment,
7219 if (isec
== section_count
)
7221 /* All of the sections fitted within the segment as currently
7222 specified. This is the default case. Add the segment to
7223 the list of built segments and carry on to process the next
7224 program header in the input BFD. */
7225 map
->count
= section_count
;
7226 *pointer_to_map
= map
;
7227 pointer_to_map
= &map
->next
;
7230 && !bed
->want_p_paddr_set_to_zero
)
7232 bfd_vma hdr_size
= 0;
7233 if (map
->includes_filehdr
)
7234 hdr_size
= iehdr
->e_ehsize
;
7235 if (map
->includes_phdrs
)
7236 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7238 /* Account for padding before the first section in the
7240 map
->p_vaddr_offset
= map
->p_paddr
+ hdr_size
- matching_lma
->lma
;
7248 /* Change the current segment's physical address to match
7249 the LMA of the first section that fitted, or if no
7250 section fitted, the first section. */
7251 if (matching_lma
== NULL
)
7252 matching_lma
= suggested_lma
;
7254 map
->p_paddr
= matching_lma
->lma
;
7256 /* Offset the segment physical address from the lma
7257 to allow for space taken up by elf headers. */
7258 if (map
->includes_phdrs
)
7260 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7262 /* iehdr->e_phnum is just an estimate of the number
7263 of program headers that we will need. Make a note
7264 here of the number we used and the segment we chose
7265 to hold these headers, so that we can adjust the
7266 offset when we know the correct value. */
7267 phdr_adjust_num
= iehdr
->e_phnum
;
7268 phdr_adjust_seg
= map
;
7271 if (map
->includes_filehdr
)
7273 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7274 map
->p_paddr
-= iehdr
->e_ehsize
;
7275 /* We've subtracted off the size of headers from the
7276 first section lma, but there may have been some
7277 alignment padding before that section too. Try to
7278 account for that by adjusting the segment lma down to
7279 the same alignment. */
7280 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7281 align
= segment
->p_align
;
7282 map
->p_paddr
&= -align
;
7286 /* Step Three: Loop over the sections again, this time assigning
7287 those that fit to the current segment and removing them from the
7288 sections array; but making sure not to leave large gaps. Once all
7289 possible sections have been assigned to the current segment it is
7290 added to the list of built segments and if sections still remain
7291 to be assigned, a new segment is constructed before repeating
7297 suggested_lma
= NULL
;
7299 /* Fill the current segment with sections that fit. */
7300 for (j
= 0; j
< section_count
; j
++)
7302 section
= sections
[j
];
7304 if (section
== NULL
)
7307 output_section
= section
->output_section
;
7309 BFD_ASSERT (output_section
!= NULL
);
7311 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7312 || IS_COREFILE_NOTE (segment
, section
))
7314 if (map
->count
== 0)
7316 /* If the first section in a segment does not start at
7317 the beginning of the segment, then something is
7319 if (align_power (map
->p_paddr
7320 + (map
->includes_filehdr
7321 ? iehdr
->e_ehsize
: 0)
7322 + (map
->includes_phdrs
7323 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7325 output_section
->alignment_power
)
7326 != output_section
->lma
)
7333 prev_sec
= map
->sections
[map
->count
- 1];
7335 /* If the gap between the end of the previous section
7336 and the start of this section is more than
7337 maxpagesize then we need to start a new segment. */
7338 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7340 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7341 || (prev_sec
->lma
+ prev_sec
->size
7342 > output_section
->lma
))
7344 if (suggested_lma
== NULL
)
7345 suggested_lma
= output_section
;
7351 map
->sections
[map
->count
++] = output_section
;
7354 if (segment
->p_type
== PT_LOAD
)
7355 section
->segment_mark
= TRUE
;
7357 else if (suggested_lma
== NULL
)
7358 suggested_lma
= output_section
;
7361 /* PR 23932. A corrupt input file may contain sections that cannot
7362 be assigned to any segment - because for example they have a
7363 negative size - or segments that do not contain any sections.
7364 But there are also valid reasons why a segment can be empty.
7365 So allow a count of zero. */
7367 /* Add the current segment to the list of built segments. */
7368 *pointer_to_map
= map
;
7369 pointer_to_map
= &map
->next
;
7371 if (isec
< section_count
)
7373 /* We still have not allocated all of the sections to
7374 segments. Create a new segment here, initialise it
7375 and carry on looping. */
7376 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7377 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7378 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7385 /* Initialise the fields of the segment map. Set the physical
7386 physical address to the LMA of the first section that has
7387 not yet been assigned. */
7389 map
->p_type
= segment
->p_type
;
7390 map
->p_flags
= segment
->p_flags
;
7391 map
->p_flags_valid
= 1;
7392 map
->p_paddr
= suggested_lma
->lma
;
7393 map
->p_paddr_valid
= p_paddr_valid
;
7394 map
->includes_filehdr
= 0;
7395 map
->includes_phdrs
= 0;
7400 bfd_set_error (bfd_error_sorry
);
7404 while (isec
< section_count
);
7409 elf_seg_map (obfd
) = map_first
;
7411 /* If we had to estimate the number of program headers that were
7412 going to be needed, then check our estimate now and adjust
7413 the offset if necessary. */
7414 if (phdr_adjust_seg
!= NULL
)
7418 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7421 if (count
> phdr_adjust_num
)
7422 phdr_adjust_seg
->p_paddr
7423 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7425 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7426 if (map
->p_type
== PT_PHDR
)
7429 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7430 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7437 #undef IS_CONTAINED_BY_VMA
7438 #undef IS_CONTAINED_BY_LMA
7440 #undef IS_COREFILE_NOTE
7441 #undef IS_SOLARIS_PT_INTERP
7442 #undef IS_SECTION_IN_INPUT_SEGMENT
7443 #undef INCLUDE_SECTION_IN_SEGMENT
7444 #undef SEGMENT_AFTER_SEGMENT
7445 #undef SEGMENT_OVERLAPS
7449 /* Copy ELF program header information. */
7452 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7454 Elf_Internal_Ehdr
*iehdr
;
7455 struct elf_segment_map
*map
;
7456 struct elf_segment_map
*map_first
;
7457 struct elf_segment_map
**pointer_to_map
;
7458 Elf_Internal_Phdr
*segment
;
7460 unsigned int num_segments
;
7461 bfd_boolean phdr_included
= FALSE
;
7462 bfd_boolean p_paddr_valid
;
7464 iehdr
= elf_elfheader (ibfd
);
7467 pointer_to_map
= &map_first
;
7469 /* If all the segment p_paddr fields are zero, don't set
7470 map->p_paddr_valid. */
7471 p_paddr_valid
= FALSE
;
7472 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7473 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7476 if (segment
->p_paddr
!= 0)
7478 p_paddr_valid
= TRUE
;
7482 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7487 unsigned int section_count
;
7489 Elf_Internal_Shdr
*this_hdr
;
7490 asection
*first_section
= NULL
;
7491 asection
*lowest_section
;
7493 /* Compute how many sections are in this segment. */
7494 for (section
= ibfd
->sections
, section_count
= 0;
7496 section
= section
->next
)
7498 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7499 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7501 if (first_section
== NULL
)
7502 first_section
= section
;
7507 /* Allocate a segment map big enough to contain
7508 all of the sections we have selected. */
7509 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7510 amt
+= section_count
* sizeof (asection
*);
7511 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7515 /* Initialize the fields of the output segment map with the
7518 map
->p_type
= segment
->p_type
;
7519 map
->p_flags
= segment
->p_flags
;
7520 map
->p_flags_valid
= 1;
7521 map
->p_paddr
= segment
->p_paddr
;
7522 map
->p_paddr_valid
= p_paddr_valid
;
7523 map
->p_align
= segment
->p_align
;
7524 map
->p_align_valid
= 1;
7525 map
->p_vaddr_offset
= 0;
7527 if (map
->p_type
== PT_GNU_RELRO
7528 || map
->p_type
== PT_GNU_STACK
)
7530 /* The PT_GNU_RELRO segment may contain the first a few
7531 bytes in the .got.plt section even if the whole .got.plt
7532 section isn't in the PT_GNU_RELRO segment. We won't
7533 change the size of the PT_GNU_RELRO segment.
7534 Similarly, PT_GNU_STACK size is significant on uclinux
7536 map
->p_size
= segment
->p_memsz
;
7537 map
->p_size_valid
= 1;
7540 /* Determine if this segment contains the ELF file header
7541 and if it contains the program headers themselves. */
7542 map
->includes_filehdr
= (segment
->p_offset
== 0
7543 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7545 map
->includes_phdrs
= 0;
7546 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7548 map
->includes_phdrs
=
7549 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7550 && (segment
->p_offset
+ segment
->p_filesz
7551 >= ((bfd_vma
) iehdr
->e_phoff
7552 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7554 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7555 phdr_included
= TRUE
;
7558 lowest_section
= NULL
;
7559 if (section_count
!= 0)
7561 unsigned int isec
= 0;
7563 for (section
= first_section
;
7565 section
= section
->next
)
7567 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7568 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7570 map
->sections
[isec
++] = section
->output_section
;
7571 if ((section
->flags
& SEC_ALLOC
) != 0)
7575 if (lowest_section
== NULL
7576 || section
->lma
< lowest_section
->lma
)
7577 lowest_section
= section
;
7579 /* Section lmas are set up from PT_LOAD header
7580 p_paddr in _bfd_elf_make_section_from_shdr.
7581 If this header has a p_paddr that disagrees
7582 with the section lma, flag the p_paddr as
7584 if ((section
->flags
& SEC_LOAD
) != 0)
7585 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7587 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7588 if (section
->lma
- segment
->p_paddr
!= seg_off
)
7589 map
->p_paddr_valid
= FALSE
;
7591 if (isec
== section_count
)
7597 if (section_count
== 0)
7598 map
->p_vaddr_offset
= segment
->p_vaddr
;
7599 else if (map
->p_paddr_valid
)
7601 /* Account for padding before the first section in the segment. */
7602 bfd_vma hdr_size
= 0;
7603 if (map
->includes_filehdr
)
7604 hdr_size
= iehdr
->e_ehsize
;
7605 if (map
->includes_phdrs
)
7606 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7608 map
->p_vaddr_offset
= (map
->p_paddr
+ hdr_size
7609 - (lowest_section
? lowest_section
->lma
: 0));
7612 map
->count
= section_count
;
7613 *pointer_to_map
= map
;
7614 pointer_to_map
= &map
->next
;
7617 elf_seg_map (obfd
) = map_first
;
7621 /* Copy private BFD data. This copies or rewrites ELF program header
7625 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7627 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7628 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7631 if (elf_tdata (ibfd
)->phdr
== NULL
)
7634 if (ibfd
->xvec
== obfd
->xvec
)
7636 /* Check to see if any sections in the input BFD
7637 covered by ELF program header have changed. */
7638 Elf_Internal_Phdr
*segment
;
7639 asection
*section
, *osec
;
7640 unsigned int i
, num_segments
;
7641 Elf_Internal_Shdr
*this_hdr
;
7642 const struct elf_backend_data
*bed
;
7644 bed
= get_elf_backend_data (ibfd
);
7646 /* Regenerate the segment map if p_paddr is set to 0. */
7647 if (bed
->want_p_paddr_set_to_zero
)
7650 /* Initialize the segment mark field. */
7651 for (section
= obfd
->sections
; section
!= NULL
;
7652 section
= section
->next
)
7653 section
->segment_mark
= FALSE
;
7655 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7656 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7660 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7661 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7662 which severly confuses things, so always regenerate the segment
7663 map in this case. */
7664 if (segment
->p_paddr
== 0
7665 && segment
->p_memsz
== 0
7666 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7669 for (section
= ibfd
->sections
;
7670 section
!= NULL
; section
= section
->next
)
7672 /* We mark the output section so that we know it comes
7673 from the input BFD. */
7674 osec
= section
->output_section
;
7676 osec
->segment_mark
= TRUE
;
7678 /* Check if this section is covered by the segment. */
7679 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7680 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7682 /* FIXME: Check if its output section is changed or
7683 removed. What else do we need to check? */
7685 || section
->flags
!= osec
->flags
7686 || section
->lma
!= osec
->lma
7687 || section
->vma
!= osec
->vma
7688 || section
->size
!= osec
->size
7689 || section
->rawsize
!= osec
->rawsize
7690 || section
->alignment_power
!= osec
->alignment_power
)
7696 /* Check to see if any output section do not come from the
7698 for (section
= obfd
->sections
; section
!= NULL
;
7699 section
= section
->next
)
7701 if (!section
->segment_mark
)
7704 section
->segment_mark
= FALSE
;
7707 return copy_elf_program_header (ibfd
, obfd
);
7711 if (ibfd
->xvec
== obfd
->xvec
)
7713 /* When rewriting program header, set the output maxpagesize to
7714 the maximum alignment of input PT_LOAD segments. */
7715 Elf_Internal_Phdr
*segment
;
7717 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7718 bfd_vma maxpagesize
= 0;
7720 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7723 if (segment
->p_type
== PT_LOAD
7724 && maxpagesize
< segment
->p_align
)
7726 /* PR 17512: file: f17299af. */
7727 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7728 /* xgettext:c-format */
7729 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7730 PRIx64
" is too large"),
7731 ibfd
, (uint64_t) segment
->p_align
);
7733 maxpagesize
= segment
->p_align
;
7736 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7737 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7740 return rewrite_elf_program_header (ibfd
, obfd
);
7743 /* Initialize private output section information from input section. */
7746 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7750 struct bfd_link_info
*link_info
)
7753 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7754 bfd_boolean final_link
= (link_info
!= NULL
7755 && !bfd_link_relocatable (link_info
));
7757 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7758 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7761 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7763 /* For objcopy and relocatable link, don't copy the output ELF
7764 section type from input if the output BFD section flags have been
7765 set to something different. For a final link allow some flags
7766 that the linker clears to differ. */
7767 if (elf_section_type (osec
) == SHT_NULL
7768 && (osec
->flags
== isec
->flags
7770 && ((osec
->flags
^ isec
->flags
)
7771 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7772 elf_section_type (osec
) = elf_section_type (isec
);
7774 /* FIXME: Is this correct for all OS/PROC specific flags? */
7775 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7776 & (SHF_MASKOS
| SHF_MASKPROC
));
7778 /* Copy sh_info from input for mbind section. */
7779 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7780 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7781 elf_section_data (osec
)->this_hdr
.sh_info
7782 = elf_section_data (isec
)->this_hdr
.sh_info
;
7784 /* Set things up for objcopy and relocatable link. The output
7785 SHT_GROUP section will have its elf_next_in_group pointing back
7786 to the input group members. Ignore linker created group section.
7787 See elfNN_ia64_object_p in elfxx-ia64.c. */
7788 if ((link_info
== NULL
7789 || !link_info
->resolve_section_groups
)
7790 && (elf_sec_group (isec
) == NULL
7791 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7793 if (elf_section_flags (isec
) & SHF_GROUP
)
7794 elf_section_flags (osec
) |= SHF_GROUP
;
7795 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7796 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7799 /* If not decompress, preserve SHF_COMPRESSED. */
7800 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7801 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7804 ihdr
= &elf_section_data (isec
)->this_hdr
;
7806 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7807 don't use the output section of the linked-to section since it
7808 may be NULL at this point. */
7809 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7811 ohdr
= &elf_section_data (osec
)->this_hdr
;
7812 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7813 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7816 osec
->use_rela_p
= isec
->use_rela_p
;
7821 /* Copy private section information. This copies over the entsize
7822 field, and sometimes the info field. */
7825 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7830 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7832 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7833 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7836 ihdr
= &elf_section_data (isec
)->this_hdr
;
7837 ohdr
= &elf_section_data (osec
)->this_hdr
;
7839 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7841 if (ihdr
->sh_type
== SHT_SYMTAB
7842 || ihdr
->sh_type
== SHT_DYNSYM
7843 || ihdr
->sh_type
== SHT_GNU_verneed
7844 || ihdr
->sh_type
== SHT_GNU_verdef
)
7845 ohdr
->sh_info
= ihdr
->sh_info
;
7847 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7851 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7852 necessary if we are removing either the SHT_GROUP section or any of
7853 the group member sections. DISCARDED is the value that a section's
7854 output_section has if the section will be discarded, NULL when this
7855 function is called from objcopy, bfd_abs_section_ptr when called
7859 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7863 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7864 if (elf_section_type (isec
) == SHT_GROUP
)
7866 asection
*first
= elf_next_in_group (isec
);
7867 asection
*s
= first
;
7868 bfd_size_type removed
= 0;
7872 /* If this member section is being output but the
7873 SHT_GROUP section is not, then clear the group info
7874 set up by _bfd_elf_copy_private_section_data. */
7875 if (s
->output_section
!= discarded
7876 && isec
->output_section
== discarded
)
7878 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7879 elf_group_name (s
->output_section
) = NULL
;
7881 /* Conversely, if the member section is not being output
7882 but the SHT_GROUP section is, then adjust its size. */
7883 else if (s
->output_section
== discarded
7884 && isec
->output_section
!= discarded
)
7886 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7888 if (elf_sec
->rel
.hdr
!= NULL
7889 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7891 if (elf_sec
->rela
.hdr
!= NULL
7892 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7895 s
= elf_next_in_group (s
);
7901 if (discarded
!= NULL
)
7903 /* If we've been called for ld -r, then we need to
7904 adjust the input section size. */
7905 if (isec
->rawsize
== 0)
7906 isec
->rawsize
= isec
->size
;
7907 isec
->size
= isec
->rawsize
- removed
;
7908 if (isec
->size
<= 4)
7911 isec
->flags
|= SEC_EXCLUDE
;
7916 /* Adjust the output section size when called from
7918 isec
->output_section
->size
-= removed
;
7919 if (isec
->output_section
->size
<= 4)
7921 isec
->output_section
->size
= 0;
7922 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7931 /* Copy private header information. */
7934 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7936 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7937 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7940 /* Copy over private BFD data if it has not already been copied.
7941 This must be done here, rather than in the copy_private_bfd_data
7942 entry point, because the latter is called after the section
7943 contents have been set, which means that the program headers have
7944 already been worked out. */
7945 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7947 if (! copy_private_bfd_data (ibfd
, obfd
))
7951 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7954 /* Copy private symbol information. If this symbol is in a section
7955 which we did not map into a BFD section, try to map the section
7956 index correctly. We use special macro definitions for the mapped
7957 section indices; these definitions are interpreted by the
7958 swap_out_syms function. */
7960 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7961 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7962 #define MAP_STRTAB (SHN_HIOS + 3)
7963 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7964 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7967 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7972 elf_symbol_type
*isym
, *osym
;
7974 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7975 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7978 isym
= elf_symbol_from (ibfd
, isymarg
);
7979 osym
= elf_symbol_from (obfd
, osymarg
);
7982 && isym
->internal_elf_sym
.st_shndx
!= 0
7984 && bfd_is_abs_section (isym
->symbol
.section
))
7988 shndx
= isym
->internal_elf_sym
.st_shndx
;
7989 if (shndx
== elf_onesymtab (ibfd
))
7990 shndx
= MAP_ONESYMTAB
;
7991 else if (shndx
== elf_dynsymtab (ibfd
))
7992 shndx
= MAP_DYNSYMTAB
;
7993 else if (shndx
== elf_strtab_sec (ibfd
))
7995 else if (shndx
== elf_shstrtab_sec (ibfd
))
7996 shndx
= MAP_SHSTRTAB
;
7997 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
7998 shndx
= MAP_SYM_SHNDX
;
7999 osym
->internal_elf_sym
.st_shndx
= shndx
;
8005 /* Swap out the symbols. */
8008 swap_out_syms (bfd
*abfd
,
8009 struct elf_strtab_hash
**sttp
,
8012 const struct elf_backend_data
*bed
;
8015 struct elf_strtab_hash
*stt
;
8016 Elf_Internal_Shdr
*symtab_hdr
;
8017 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8018 Elf_Internal_Shdr
*symstrtab_hdr
;
8019 struct elf_sym_strtab
*symstrtab
;
8020 bfd_byte
*outbound_syms
;
8021 bfd_byte
*outbound_shndx
;
8022 unsigned long outbound_syms_index
;
8023 unsigned long outbound_shndx_index
;
8025 unsigned int num_locals
;
8027 bfd_boolean name_local_sections
;
8029 if (!elf_map_symbols (abfd
, &num_locals
))
8032 /* Dump out the symtabs. */
8033 stt
= _bfd_elf_strtab_init ();
8037 bed
= get_elf_backend_data (abfd
);
8038 symcount
= bfd_get_symcount (abfd
);
8039 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8040 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8041 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8042 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8043 symtab_hdr
->sh_info
= num_locals
+ 1;
8044 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8046 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8047 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8049 /* Allocate buffer to swap out the .strtab section. */
8050 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc2 (symcount
+ 1,
8051 sizeof (*symstrtab
));
8052 if (symstrtab
== NULL
)
8054 _bfd_elf_strtab_free (stt
);
8058 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
8059 bed
->s
->sizeof_sym
);
8060 if (outbound_syms
== NULL
)
8063 _bfd_elf_strtab_free (stt
);
8067 symtab_hdr
->contents
= outbound_syms
;
8068 outbound_syms_index
= 0;
8070 outbound_shndx
= NULL
;
8071 outbound_shndx_index
= 0;
8073 if (elf_symtab_shndx_list (abfd
))
8075 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8076 if (symtab_shndx_hdr
->sh_name
!= 0)
8078 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
8079 outbound_shndx
= (bfd_byte
*)
8080 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
8081 if (outbound_shndx
== NULL
)
8084 symtab_shndx_hdr
->contents
= outbound_shndx
;
8085 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8086 symtab_shndx_hdr
->sh_size
= amt
;
8087 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8088 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8090 /* FIXME: What about any other headers in the list ? */
8093 /* Now generate the data (for "contents"). */
8095 /* Fill in zeroth symbol and swap it out. */
8096 Elf_Internal_Sym sym
;
8102 sym
.st_shndx
= SHN_UNDEF
;
8103 sym
.st_target_internal
= 0;
8104 symstrtab
[0].sym
= sym
;
8105 symstrtab
[0].dest_index
= outbound_syms_index
;
8106 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8107 outbound_syms_index
++;
8108 if (outbound_shndx
!= NULL
)
8109 outbound_shndx_index
++;
8113 = (bed
->elf_backend_name_local_section_symbols
8114 && bed
->elf_backend_name_local_section_symbols (abfd
));
8116 syms
= bfd_get_outsymbols (abfd
);
8117 for (idx
= 0; idx
< symcount
;)
8119 Elf_Internal_Sym sym
;
8120 bfd_vma value
= syms
[idx
]->value
;
8121 elf_symbol_type
*type_ptr
;
8122 flagword flags
= syms
[idx
]->flags
;
8125 if (!name_local_sections
8126 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8128 /* Local section symbols have no name. */
8129 sym
.st_name
= (unsigned long) -1;
8133 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8134 to get the final offset for st_name. */
8136 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8138 if (sym
.st_name
== (unsigned long) -1)
8142 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
8144 if ((flags
& BSF_SECTION_SYM
) == 0
8145 && bfd_is_com_section (syms
[idx
]->section
))
8147 /* ELF common symbols put the alignment into the `value' field,
8148 and the size into the `size' field. This is backwards from
8149 how BFD handles it, so reverse it here. */
8150 sym
.st_size
= value
;
8151 if (type_ptr
== NULL
8152 || type_ptr
->internal_elf_sym
.st_value
== 0)
8153 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8155 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8156 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8157 (abfd
, syms
[idx
]->section
);
8161 asection
*sec
= syms
[idx
]->section
;
8164 if (sec
->output_section
)
8166 value
+= sec
->output_offset
;
8167 sec
= sec
->output_section
;
8170 /* Don't add in the section vma for relocatable output. */
8171 if (! relocatable_p
)
8173 sym
.st_value
= value
;
8174 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8176 if (bfd_is_abs_section (sec
)
8178 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8180 /* This symbol is in a real ELF section which we did
8181 not create as a BFD section. Undo the mapping done
8182 by copy_private_symbol_data. */
8183 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8187 shndx
= elf_onesymtab (abfd
);
8190 shndx
= elf_dynsymtab (abfd
);
8193 shndx
= elf_strtab_sec (abfd
);
8196 shndx
= elf_shstrtab_sec (abfd
);
8199 if (elf_symtab_shndx_list (abfd
))
8200 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8209 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8211 if (shndx
== SHN_BAD
)
8215 /* Writing this would be a hell of a lot easier if
8216 we had some decent documentation on bfd, and
8217 knew what to expect of the library, and what to
8218 demand of applications. For example, it
8219 appears that `objcopy' might not set the
8220 section of a symbol to be a section that is
8221 actually in the output file. */
8222 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8224 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8225 if (shndx
== SHN_BAD
)
8227 /* xgettext:c-format */
8229 (_("unable to find equivalent output section"
8230 " for symbol '%s' from section '%s'"),
8231 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8233 bfd_set_error (bfd_error_invalid_operation
);
8239 sym
.st_shndx
= shndx
;
8242 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8244 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8245 type
= STT_GNU_IFUNC
;
8246 else if ((flags
& BSF_FUNCTION
) != 0)
8248 else if ((flags
& BSF_OBJECT
) != 0)
8250 else if ((flags
& BSF_RELC
) != 0)
8252 else if ((flags
& BSF_SRELC
) != 0)
8257 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8260 /* Processor-specific types. */
8261 if (type_ptr
!= NULL
8262 && bed
->elf_backend_get_symbol_type
)
8263 type
= ((*bed
->elf_backend_get_symbol_type
)
8264 (&type_ptr
->internal_elf_sym
, type
));
8266 if (flags
& BSF_SECTION_SYM
)
8268 if (flags
& BSF_GLOBAL
)
8269 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8271 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8273 else if (bfd_is_com_section (syms
[idx
]->section
))
8275 if (type
!= STT_TLS
)
8277 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8278 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8279 ? STT_COMMON
: STT_OBJECT
);
8281 type
= ((flags
& BSF_ELF_COMMON
) != 0
8282 ? STT_COMMON
: STT_OBJECT
);
8284 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8286 else if (bfd_is_und_section (syms
[idx
]->section
))
8287 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8291 else if (flags
& BSF_FILE
)
8292 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8295 int bind
= STB_LOCAL
;
8297 if (flags
& BSF_LOCAL
)
8299 else if (flags
& BSF_GNU_UNIQUE
)
8300 bind
= STB_GNU_UNIQUE
;
8301 else if (flags
& BSF_WEAK
)
8303 else if (flags
& BSF_GLOBAL
)
8306 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8309 if (type_ptr
!= NULL
)
8311 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8312 sym
.st_target_internal
8313 = type_ptr
->internal_elf_sym
.st_target_internal
;
8318 sym
.st_target_internal
= 0;
8322 symstrtab
[idx
].sym
= sym
;
8323 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8324 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8326 outbound_syms_index
++;
8327 if (outbound_shndx
!= NULL
)
8328 outbound_shndx_index
++;
8331 /* Finalize the .strtab section. */
8332 _bfd_elf_strtab_finalize (stt
);
8334 /* Swap out the .strtab section. */
8335 for (idx
= 0; idx
<= symcount
; idx
++)
8337 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8338 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8339 elfsym
->sym
.st_name
= 0;
8341 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8342 elfsym
->sym
.st_name
);
8343 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8345 + (elfsym
->dest_index
8346 * bed
->s
->sizeof_sym
)),
8348 + (elfsym
->destshndx_index
8349 * sizeof (Elf_External_Sym_Shndx
))));
8354 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8355 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8356 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8357 symstrtab_hdr
->sh_addr
= 0;
8358 symstrtab_hdr
->sh_entsize
= 0;
8359 symstrtab_hdr
->sh_link
= 0;
8360 symstrtab_hdr
->sh_info
= 0;
8361 symstrtab_hdr
->sh_addralign
= 1;
8366 /* Return the number of bytes required to hold the symtab vector.
8368 Note that we base it on the count plus 1, since we will null terminate
8369 the vector allocated based on this size. However, the ELF symbol table
8370 always has a dummy entry as symbol #0, so it ends up even. */
8373 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8375 bfd_size_type symcount
;
8377 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8379 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8380 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8382 bfd_set_error (bfd_error_file_too_big
);
8385 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8387 symtab_size
-= sizeof (asymbol
*);
8393 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8395 bfd_size_type symcount
;
8397 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8399 if (elf_dynsymtab (abfd
) == 0)
8401 bfd_set_error (bfd_error_invalid_operation
);
8405 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8406 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8408 bfd_set_error (bfd_error_file_too_big
);
8411 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8413 symtab_size
-= sizeof (asymbol
*);
8419 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
8422 #if SIZEOF_LONG == SIZEOF_INT
8423 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8425 bfd_set_error (bfd_error_file_too_big
);
8429 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8432 /* Canonicalize the relocs. */
8435 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8442 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8444 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
8447 tblptr
= section
->relocation
;
8448 for (i
= 0; i
< section
->reloc_count
; i
++)
8449 *relptr
++ = tblptr
++;
8453 return section
->reloc_count
;
8457 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8459 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8460 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
8463 abfd
->symcount
= symcount
;
8468 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8469 asymbol
**allocation
)
8471 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8472 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
8475 abfd
->dynsymcount
= symcount
;
8479 /* Return the size required for the dynamic reloc entries. Any loadable
8480 section that was actually installed in the BFD, and has type SHT_REL
8481 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8482 dynamic reloc section. */
8485 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8487 bfd_size_type count
;
8490 if (elf_dynsymtab (abfd
) == 0)
8492 bfd_set_error (bfd_error_invalid_operation
);
8497 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8498 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8499 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8500 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8502 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8503 if (count
> LONG_MAX
/ sizeof (arelent
*))
8505 bfd_set_error (bfd_error_file_too_big
);
8509 return count
* sizeof (arelent
*);
8512 /* Canonicalize the dynamic relocation entries. Note that we return the
8513 dynamic relocations as a single block, although they are actually
8514 associated with particular sections; the interface, which was
8515 designed for SunOS style shared libraries, expects that there is only
8516 one set of dynamic relocs. Any loadable section that was actually
8517 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8518 dynamic symbol table, is considered to be a dynamic reloc section. */
8521 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8525 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8529 if (elf_dynsymtab (abfd
) == 0)
8531 bfd_set_error (bfd_error_invalid_operation
);
8535 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8537 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8539 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8540 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8541 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8546 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8548 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8550 for (i
= 0; i
< count
; i
++)
8561 /* Read in the version information. */
8564 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8566 bfd_byte
*contents
= NULL
;
8567 unsigned int freeidx
= 0;
8569 if (elf_dynverref (abfd
) != 0)
8571 Elf_Internal_Shdr
*hdr
;
8572 Elf_External_Verneed
*everneed
;
8573 Elf_Internal_Verneed
*iverneed
;
8575 bfd_byte
*contents_end
;
8577 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8579 if (hdr
->sh_info
== 0
8580 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8582 error_return_bad_verref
:
8584 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8585 bfd_set_error (bfd_error_bad_value
);
8586 error_return_verref
:
8587 elf_tdata (abfd
)->verref
= NULL
;
8588 elf_tdata (abfd
)->cverrefs
= 0;
8592 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8593 if (filesize
> 0 && filesize
< hdr
->sh_size
)
8595 /* PR 24708: Avoid attempts to allocate a ridiculous amount
8597 bfd_set_error (bfd_error_no_memory
);
8599 /* xgettext:c-format */
8600 (_("error: %pB version reference section is too large (%#" PRIx64
" bytes)"),
8601 abfd
, (uint64_t) hdr
->sh_size
);
8602 goto error_return_verref
;
8604 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8605 if (contents
== NULL
)
8606 goto error_return_verref
;
8608 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8609 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8610 goto error_return_verref
;
8612 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
8613 bfd_alloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
8615 if (elf_tdata (abfd
)->verref
== NULL
)
8616 goto error_return_verref
;
8618 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8619 == sizeof (Elf_External_Vernaux
));
8620 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8621 everneed
= (Elf_External_Verneed
*) contents
;
8622 iverneed
= elf_tdata (abfd
)->verref
;
8623 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8625 Elf_External_Vernaux
*evernaux
;
8626 Elf_Internal_Vernaux
*ivernaux
;
8629 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8631 iverneed
->vn_bfd
= abfd
;
8633 iverneed
->vn_filename
=
8634 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8636 if (iverneed
->vn_filename
== NULL
)
8637 goto error_return_bad_verref
;
8639 if (iverneed
->vn_cnt
== 0)
8640 iverneed
->vn_auxptr
= NULL
;
8643 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8644 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
8645 sizeof (Elf_Internal_Vernaux
));
8646 if (iverneed
->vn_auxptr
== NULL
)
8647 goto error_return_verref
;
8650 if (iverneed
->vn_aux
8651 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8652 goto error_return_bad_verref
;
8654 evernaux
= ((Elf_External_Vernaux
*)
8655 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8656 ivernaux
= iverneed
->vn_auxptr
;
8657 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8659 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8661 ivernaux
->vna_nodename
=
8662 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8663 ivernaux
->vna_name
);
8664 if (ivernaux
->vna_nodename
== NULL
)
8665 goto error_return_bad_verref
;
8667 if (ivernaux
->vna_other
> freeidx
)
8668 freeidx
= ivernaux
->vna_other
;
8670 ivernaux
->vna_nextptr
= NULL
;
8671 if (ivernaux
->vna_next
== 0)
8673 iverneed
->vn_cnt
= j
+ 1;
8676 if (j
+ 1 < iverneed
->vn_cnt
)
8677 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8679 if (ivernaux
->vna_next
8680 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8681 goto error_return_bad_verref
;
8683 evernaux
= ((Elf_External_Vernaux
*)
8684 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8687 iverneed
->vn_nextref
= NULL
;
8688 if (iverneed
->vn_next
== 0)
8690 if (i
+ 1 < hdr
->sh_info
)
8691 iverneed
->vn_nextref
= iverneed
+ 1;
8693 if (iverneed
->vn_next
8694 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8695 goto error_return_bad_verref
;
8697 everneed
= ((Elf_External_Verneed
*)
8698 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8700 elf_tdata (abfd
)->cverrefs
= i
;
8706 if (elf_dynverdef (abfd
) != 0)
8708 Elf_Internal_Shdr
*hdr
;
8709 Elf_External_Verdef
*everdef
;
8710 Elf_Internal_Verdef
*iverdef
;
8711 Elf_Internal_Verdef
*iverdefarr
;
8712 Elf_Internal_Verdef iverdefmem
;
8714 unsigned int maxidx
;
8715 bfd_byte
*contents_end_def
, *contents_end_aux
;
8717 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8719 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8721 error_return_bad_verdef
:
8723 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8724 bfd_set_error (bfd_error_bad_value
);
8725 error_return_verdef
:
8726 elf_tdata (abfd
)->verdef
= NULL
;
8727 elf_tdata (abfd
)->cverdefs
= 0;
8731 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8732 if (contents
== NULL
)
8733 goto error_return_verdef
;
8734 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8735 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8736 goto error_return_verdef
;
8738 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8739 >= sizeof (Elf_External_Verdaux
));
8740 contents_end_def
= contents
+ hdr
->sh_size
8741 - sizeof (Elf_External_Verdef
);
8742 contents_end_aux
= contents
+ hdr
->sh_size
8743 - sizeof (Elf_External_Verdaux
);
8745 /* We know the number of entries in the section but not the maximum
8746 index. Therefore we have to run through all entries and find
8748 everdef
= (Elf_External_Verdef
*) contents
;
8750 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8752 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8754 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8755 goto error_return_bad_verdef
;
8756 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8757 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8759 if (iverdefmem
.vd_next
== 0)
8762 if (iverdefmem
.vd_next
8763 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8764 goto error_return_bad_verdef
;
8766 everdef
= ((Elf_External_Verdef
*)
8767 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8770 if (default_imported_symver
)
8772 if (freeidx
> maxidx
)
8778 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8779 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
8780 if (elf_tdata (abfd
)->verdef
== NULL
)
8781 goto error_return_verdef
;
8783 elf_tdata (abfd
)->cverdefs
= maxidx
;
8785 everdef
= (Elf_External_Verdef
*) contents
;
8786 iverdefarr
= elf_tdata (abfd
)->verdef
;
8787 for (i
= 0; i
< hdr
->sh_info
; i
++)
8789 Elf_External_Verdaux
*everdaux
;
8790 Elf_Internal_Verdaux
*iverdaux
;
8793 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8795 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8796 goto error_return_bad_verdef
;
8798 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8799 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8801 iverdef
->vd_bfd
= abfd
;
8803 if (iverdef
->vd_cnt
== 0)
8804 iverdef
->vd_auxptr
= NULL
;
8807 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8808 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
8809 sizeof (Elf_Internal_Verdaux
));
8810 if (iverdef
->vd_auxptr
== NULL
)
8811 goto error_return_verdef
;
8815 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8816 goto error_return_bad_verdef
;
8818 everdaux
= ((Elf_External_Verdaux
*)
8819 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8820 iverdaux
= iverdef
->vd_auxptr
;
8821 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8823 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8825 iverdaux
->vda_nodename
=
8826 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8827 iverdaux
->vda_name
);
8828 if (iverdaux
->vda_nodename
== NULL
)
8829 goto error_return_bad_verdef
;
8831 iverdaux
->vda_nextptr
= NULL
;
8832 if (iverdaux
->vda_next
== 0)
8834 iverdef
->vd_cnt
= j
+ 1;
8837 if (j
+ 1 < iverdef
->vd_cnt
)
8838 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8840 if (iverdaux
->vda_next
8841 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8842 goto error_return_bad_verdef
;
8844 everdaux
= ((Elf_External_Verdaux
*)
8845 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8848 iverdef
->vd_nodename
= NULL
;
8849 if (iverdef
->vd_cnt
)
8850 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8852 iverdef
->vd_nextdef
= NULL
;
8853 if (iverdef
->vd_next
== 0)
8855 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8856 iverdef
->vd_nextdef
= iverdef
+ 1;
8858 everdef
= ((Elf_External_Verdef
*)
8859 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8865 else if (default_imported_symver
)
8872 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8873 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8874 if (elf_tdata (abfd
)->verdef
== NULL
)
8877 elf_tdata (abfd
)->cverdefs
= freeidx
;
8880 /* Create a default version based on the soname. */
8881 if (default_imported_symver
)
8883 Elf_Internal_Verdef
*iverdef
;
8884 Elf_Internal_Verdaux
*iverdaux
;
8886 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8888 iverdef
->vd_version
= VER_DEF_CURRENT
;
8889 iverdef
->vd_flags
= 0;
8890 iverdef
->vd_ndx
= freeidx
;
8891 iverdef
->vd_cnt
= 1;
8893 iverdef
->vd_bfd
= abfd
;
8895 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8896 if (iverdef
->vd_nodename
== NULL
)
8897 goto error_return_verdef
;
8898 iverdef
->vd_nextdef
= NULL
;
8899 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8900 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8901 if (iverdef
->vd_auxptr
== NULL
)
8902 goto error_return_verdef
;
8904 iverdaux
= iverdef
->vd_auxptr
;
8905 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8911 if (contents
!= NULL
)
8917 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8919 elf_symbol_type
*newsym
;
8921 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
8924 newsym
->symbol
.the_bfd
= abfd
;
8925 return &newsym
->symbol
;
8929 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8933 bfd_symbol_info (symbol
, ret
);
8936 /* Return whether a symbol name implies a local symbol. Most targets
8937 use this function for the is_local_label_name entry point, but some
8941 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8944 /* Normal local symbols start with ``.L''. */
8945 if (name
[0] == '.' && name
[1] == 'L')
8948 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8949 DWARF debugging symbols starting with ``..''. */
8950 if (name
[0] == '.' && name
[1] == '.')
8953 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8954 emitting DWARF debugging output. I suspect this is actually a
8955 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8956 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8957 underscore to be emitted on some ELF targets). For ease of use,
8958 we treat such symbols as local. */
8959 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8962 /* Treat assembler generated fake symbols, dollar local labels and
8963 forward-backward labels (aka local labels) as locals.
8964 These labels have the form:
8966 L0^A.* (fake symbols)
8968 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8970 Versions which start with .L will have already been matched above,
8971 so we only need to match the rest. */
8972 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8974 bfd_boolean ret
= FALSE
;
8978 for (p
= name
+ 2; (c
= *p
); p
++)
8980 if (c
== 1 || c
== 2)
8982 if (c
== 1 && p
== name
+ 2)
8983 /* A fake symbol. */
8986 /* FIXME: We are being paranoid here and treating symbols like
8987 L0^Bfoo as if there were non-local, on the grounds that the
8988 assembler will never generate them. But can any symbol
8989 containing an ASCII value in the range 1-31 ever be anything
8990 other than some kind of local ? */
9007 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9008 asymbol
*symbol ATTRIBUTE_UNUSED
)
9015 _bfd_elf_set_arch_mach (bfd
*abfd
,
9016 enum bfd_architecture arch
,
9017 unsigned long machine
)
9019 /* If this isn't the right architecture for this backend, and this
9020 isn't the generic backend, fail. */
9021 if (arch
!= get_elf_backend_data (abfd
)->arch
9022 && arch
!= bfd_arch_unknown
9023 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9026 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9029 /* Find the nearest line to a particular section and offset,
9030 for error reporting. */
9033 _bfd_elf_find_nearest_line (bfd
*abfd
,
9037 const char **filename_ptr
,
9038 const char **functionname_ptr
,
9039 unsigned int *line_ptr
,
9040 unsigned int *discriminator_ptr
)
9044 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9045 filename_ptr
, functionname_ptr
,
9046 line_ptr
, discriminator_ptr
,
9047 dwarf_debug_sections
,
9048 &elf_tdata (abfd
)->dwarf2_find_line_info
))
9051 if (_bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9052 filename_ptr
, functionname_ptr
, line_ptr
))
9054 if (!*functionname_ptr
)
9055 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9056 *filename_ptr
? NULL
: filename_ptr
,
9061 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9062 &found
, filename_ptr
,
9063 functionname_ptr
, line_ptr
,
9064 &elf_tdata (abfd
)->line_info
))
9066 if (found
&& (*functionname_ptr
|| *line_ptr
))
9069 if (symbols
== NULL
)
9072 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9073 filename_ptr
, functionname_ptr
))
9080 /* Find the line for a symbol. */
9083 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9084 const char **filename_ptr
, unsigned int *line_ptr
)
9086 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9087 filename_ptr
, NULL
, line_ptr
, NULL
,
9088 dwarf_debug_sections
,
9089 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9092 /* After a call to bfd_find_nearest_line, successive calls to
9093 bfd_find_inliner_info can be used to get source information about
9094 each level of function inlining that terminated at the address
9095 passed to bfd_find_nearest_line. Currently this is only supported
9096 for DWARF2 with appropriate DWARF3 extensions. */
9099 _bfd_elf_find_inliner_info (bfd
*abfd
,
9100 const char **filename_ptr
,
9101 const char **functionname_ptr
,
9102 unsigned int *line_ptr
)
9105 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9106 functionname_ptr
, line_ptr
,
9107 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9112 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9114 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9115 int ret
= bed
->s
->sizeof_ehdr
;
9117 if (!bfd_link_relocatable (info
))
9119 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9121 if (phdr_size
== (bfd_size_type
) -1)
9123 struct elf_segment_map
*m
;
9126 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9127 phdr_size
+= bed
->s
->sizeof_phdr
;
9130 phdr_size
= get_program_header_size (abfd
, info
);
9133 elf_program_header_size (abfd
) = phdr_size
;
9141 _bfd_elf_set_section_contents (bfd
*abfd
,
9143 const void *location
,
9145 bfd_size_type count
)
9147 Elf_Internal_Shdr
*hdr
;
9150 if (! abfd
->output_has_begun
9151 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9157 hdr
= &elf_section_data (section
)->this_hdr
;
9158 if (hdr
->sh_offset
== (file_ptr
) -1)
9160 if (bfd_section_is_ctf (section
))
9161 /* Nothing to do with this section: the contents are generated
9165 /* We must compress this section. Write output to the buffer. */
9166 unsigned char *contents
= hdr
->contents
;
9167 if ((offset
+ count
) > hdr
->sh_size
9168 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
9169 || contents
== NULL
)
9171 memcpy (contents
+ offset
, location
, count
);
9174 pos
= hdr
->sh_offset
+ offset
;
9175 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9176 || bfd_bwrite (location
, count
, abfd
) != count
)
9183 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9184 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9185 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9191 /* Try to convert a non-ELF reloc into an ELF one. */
9194 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9196 /* Check whether we really have an ELF howto. */
9198 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9200 bfd_reloc_code_real_type code
;
9201 reloc_howto_type
*howto
;
9203 /* Alien reloc: Try to determine its type to replace it with an
9204 equivalent ELF reloc. */
9206 if (areloc
->howto
->pc_relative
)
9208 switch (areloc
->howto
->bitsize
)
9211 code
= BFD_RELOC_8_PCREL
;
9214 code
= BFD_RELOC_12_PCREL
;
9217 code
= BFD_RELOC_16_PCREL
;
9220 code
= BFD_RELOC_24_PCREL
;
9223 code
= BFD_RELOC_32_PCREL
;
9226 code
= BFD_RELOC_64_PCREL
;
9232 howto
= bfd_reloc_type_lookup (abfd
, code
);
9234 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9236 if (howto
->pcrel_offset
)
9237 areloc
->addend
+= areloc
->address
;
9239 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9244 switch (areloc
->howto
->bitsize
)
9250 code
= BFD_RELOC_14
;
9253 code
= BFD_RELOC_16
;
9256 code
= BFD_RELOC_26
;
9259 code
= BFD_RELOC_32
;
9262 code
= BFD_RELOC_64
;
9268 howto
= bfd_reloc_type_lookup (abfd
, code
);
9272 areloc
->howto
= howto
;
9280 /* xgettext:c-format */
9281 _bfd_error_handler (_("%pB: %s unsupported"),
9282 abfd
, areloc
->howto
->name
);
9283 bfd_set_error (bfd_error_sorry
);
9288 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9290 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9291 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
9293 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9294 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9295 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9298 return _bfd_generic_close_and_cleanup (abfd
);
9301 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9302 in the relocation's offset. Thus we cannot allow any sort of sanity
9303 range-checking to interfere. There is nothing else to do in processing
9306 bfd_reloc_status_type
9307 _bfd_elf_rel_vtable_reloc_fn
9308 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9309 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9310 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9311 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9313 return bfd_reloc_ok
;
9316 /* Elf core file support. Much of this only works on native
9317 toolchains, since we rely on knowing the
9318 machine-dependent procfs structure in order to pick
9319 out details about the corefile. */
9321 #ifdef HAVE_SYS_PROCFS_H
9322 /* Needed for new procfs interface on sparc-solaris. */
9323 # define _STRUCTURED_PROC 1
9324 # include <sys/procfs.h>
9327 /* Return a PID that identifies a "thread" for threaded cores, or the
9328 PID of the main process for non-threaded cores. */
9331 elfcore_make_pid (bfd
*abfd
)
9335 pid
= elf_tdata (abfd
)->core
->lwpid
;
9337 pid
= elf_tdata (abfd
)->core
->pid
;
9342 /* If there isn't a section called NAME, make one, using
9343 data from SECT. Note, this function will generate a
9344 reference to NAME, so you shouldn't deallocate or
9348 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9352 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9355 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9359 sect2
->size
= sect
->size
;
9360 sect2
->filepos
= sect
->filepos
;
9361 sect2
->alignment_power
= sect
->alignment_power
;
9365 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9366 actually creates up to two pseudosections:
9367 - For the single-threaded case, a section named NAME, unless
9368 such a section already exists.
9369 - For the multi-threaded case, a section named "NAME/PID", where
9370 PID is elfcore_make_pid (abfd).
9371 Both pseudosections have identical contents. */
9373 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9379 char *threaded_name
;
9383 /* Build the section name. */
9385 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9386 len
= strlen (buf
) + 1;
9387 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9388 if (threaded_name
== NULL
)
9390 memcpy (threaded_name
, buf
, len
);
9392 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9397 sect
->filepos
= filepos
;
9398 sect
->alignment_power
= 2;
9400 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9404 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9407 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9413 sect
->size
= note
->descsz
- offs
;
9414 sect
->filepos
= note
->descpos
+ offs
;
9415 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9420 /* prstatus_t exists on:
9422 linux 2.[01] + glibc
9426 #if defined (HAVE_PRSTATUS_T)
9429 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9434 if (note
->descsz
== sizeof (prstatus_t
))
9438 size
= sizeof (prstat
.pr_reg
);
9439 offset
= offsetof (prstatus_t
, pr_reg
);
9440 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9442 /* Do not overwrite the core signal if it
9443 has already been set by another thread. */
9444 if (elf_tdata (abfd
)->core
->signal
== 0)
9445 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9446 if (elf_tdata (abfd
)->core
->pid
== 0)
9447 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9449 /* pr_who exists on:
9452 pr_who doesn't exist on:
9455 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9456 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9458 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9461 #if defined (HAVE_PRSTATUS32_T)
9462 else if (note
->descsz
== sizeof (prstatus32_t
))
9464 /* 64-bit host, 32-bit corefile */
9465 prstatus32_t prstat
;
9467 size
= sizeof (prstat
.pr_reg
);
9468 offset
= offsetof (prstatus32_t
, pr_reg
);
9469 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9471 /* Do not overwrite the core signal if it
9472 has already been set by another thread. */
9473 if (elf_tdata (abfd
)->core
->signal
== 0)
9474 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9475 if (elf_tdata (abfd
)->core
->pid
== 0)
9476 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9478 /* pr_who exists on:
9481 pr_who doesn't exist on:
9484 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9485 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9487 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9490 #endif /* HAVE_PRSTATUS32_T */
9493 /* Fail - we don't know how to handle any other
9494 note size (ie. data object type). */
9498 /* Make a ".reg/999" section and a ".reg" section. */
9499 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9500 size
, note
->descpos
+ offset
);
9502 #endif /* defined (HAVE_PRSTATUS_T) */
9504 /* Create a pseudosection containing the exact contents of NOTE. */
9506 elfcore_make_note_pseudosection (bfd
*abfd
,
9508 Elf_Internal_Note
*note
)
9510 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9511 note
->descsz
, note
->descpos
);
9514 /* There isn't a consistent prfpregset_t across platforms,
9515 but it doesn't matter, because we don't have to pick this
9516 data structure apart. */
9519 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9521 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9524 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9525 type of NT_PRXFPREG. Just include the whole note's contents
9529 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9531 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9534 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9535 with a note type of NT_X86_XSTATE. Just include the whole note's
9536 contents literally. */
9539 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9541 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9545 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9547 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9551 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9553 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9557 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9559 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9563 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9565 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9569 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9571 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9575 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9577 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9581 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9583 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9587 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9589 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9593 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9595 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9599 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9601 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9605 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9607 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9611 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9613 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9617 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9619 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9623 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9625 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9629 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9631 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9635 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9637 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9641 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9643 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9647 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9649 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9653 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9655 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9659 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9661 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9665 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9667 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9671 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9673 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9677 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9679 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9683 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9685 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9689 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9691 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9695 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9697 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9701 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9703 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9707 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9709 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9713 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9715 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9719 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9721 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9725 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9727 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9731 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9733 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9737 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9739 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9743 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9745 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9748 #if defined (HAVE_PRPSINFO_T)
9749 typedef prpsinfo_t elfcore_psinfo_t
;
9750 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9751 typedef prpsinfo32_t elfcore_psinfo32_t
;
9755 #if defined (HAVE_PSINFO_T)
9756 typedef psinfo_t elfcore_psinfo_t
;
9757 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9758 typedef psinfo32_t elfcore_psinfo32_t
;
9762 /* return a malloc'ed copy of a string at START which is at
9763 most MAX bytes long, possibly without a terminating '\0'.
9764 the copy will always have a terminating '\0'. */
9767 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9770 char *end
= (char *) memchr (start
, '\0', max
);
9778 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9782 memcpy (dups
, start
, len
);
9788 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9790 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9792 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9794 elfcore_psinfo_t psinfo
;
9796 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9798 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9799 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9801 elf_tdata (abfd
)->core
->program
9802 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9803 sizeof (psinfo
.pr_fname
));
9805 elf_tdata (abfd
)->core
->command
9806 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9807 sizeof (psinfo
.pr_psargs
));
9809 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9810 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9812 /* 64-bit host, 32-bit corefile */
9813 elfcore_psinfo32_t psinfo
;
9815 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9817 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9818 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9820 elf_tdata (abfd
)->core
->program
9821 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9822 sizeof (psinfo
.pr_fname
));
9824 elf_tdata (abfd
)->core
->command
9825 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9826 sizeof (psinfo
.pr_psargs
));
9832 /* Fail - we don't know how to handle any other
9833 note size (ie. data object type). */
9837 /* Note that for some reason, a spurious space is tacked
9838 onto the end of the args in some (at least one anyway)
9839 implementations, so strip it off if it exists. */
9842 char *command
= elf_tdata (abfd
)->core
->command
;
9843 int n
= strlen (command
);
9845 if (0 < n
&& command
[n
- 1] == ' ')
9846 command
[n
- 1] = '\0';
9851 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9853 #if defined (HAVE_PSTATUS_T)
9855 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9857 if (note
->descsz
== sizeof (pstatus_t
)
9858 #if defined (HAVE_PXSTATUS_T)
9859 || note
->descsz
== sizeof (pxstatus_t
)
9865 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9867 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9869 #if defined (HAVE_PSTATUS32_T)
9870 else if (note
->descsz
== sizeof (pstatus32_t
))
9872 /* 64-bit host, 32-bit corefile */
9875 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9877 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9880 /* Could grab some more details from the "representative"
9881 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9882 NT_LWPSTATUS note, presumably. */
9886 #endif /* defined (HAVE_PSTATUS_T) */
9888 #if defined (HAVE_LWPSTATUS_T)
9890 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9892 lwpstatus_t lwpstat
;
9898 if (note
->descsz
!= sizeof (lwpstat
)
9899 #if defined (HAVE_LWPXSTATUS_T)
9900 && note
->descsz
!= sizeof (lwpxstatus_t
)
9905 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
9907 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
9908 /* Do not overwrite the core signal if it has already been set by
9910 if (elf_tdata (abfd
)->core
->signal
== 0)
9911 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
9913 /* Make a ".reg/999" section. */
9915 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
9916 len
= strlen (buf
) + 1;
9917 name
= bfd_alloc (abfd
, len
);
9920 memcpy (name
, buf
, len
);
9922 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9926 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9927 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
9928 sect
->filepos
= note
->descpos
9929 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
9932 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9933 sect
->size
= sizeof (lwpstat
.pr_reg
);
9934 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
9937 sect
->alignment_power
= 2;
9939 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9942 /* Make a ".reg2/999" section */
9944 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
9945 len
= strlen (buf
) + 1;
9946 name
= bfd_alloc (abfd
, len
);
9949 memcpy (name
, buf
, len
);
9951 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9955 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9956 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
9957 sect
->filepos
= note
->descpos
9958 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
9961 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9962 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9963 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9966 sect
->alignment_power
= 2;
9968 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9970 #endif /* defined (HAVE_LWPSTATUS_T) */
9973 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9980 int is_active_thread
;
9983 if (note
->descsz
< 728)
9986 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9989 type
= bfd_get_32 (abfd
, note
->descdata
);
9993 case 1 /* NOTE_INFO_PROCESS */:
9994 /* FIXME: need to add ->core->command. */
9995 /* process_info.pid */
9996 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9997 /* process_info.signal */
9998 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
10001 case 2 /* NOTE_INFO_THREAD */:
10002 /* Make a ".reg/999" section. */
10003 /* thread_info.tid */
10004 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
10006 len
= strlen (buf
) + 1;
10007 name
= (char *) bfd_alloc (abfd
, len
);
10011 memcpy (name
, buf
, len
);
10013 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10017 /* sizeof (thread_info.thread_context) */
10019 /* offsetof (thread_info.thread_context) */
10020 sect
->filepos
= note
->descpos
+ 12;
10021 sect
->alignment_power
= 2;
10023 /* thread_info.is_active_thread */
10024 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10026 if (is_active_thread
)
10027 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10031 case 3 /* NOTE_INFO_MODULE */:
10032 /* Make a ".module/xxxxxxxx" section. */
10033 /* module_info.base_address */
10034 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10035 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10037 len
= strlen (buf
) + 1;
10038 name
= (char *) bfd_alloc (abfd
, len
);
10042 memcpy (name
, buf
, len
);
10044 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10049 sect
->size
= note
->descsz
;
10050 sect
->filepos
= note
->descpos
;
10051 sect
->alignment_power
= 2;
10062 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10064 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10066 switch (note
->type
)
10072 if (bed
->elf_backend_grok_prstatus
)
10073 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10075 #if defined (HAVE_PRSTATUS_T)
10076 return elfcore_grok_prstatus (abfd
, note
);
10081 #if defined (HAVE_PSTATUS_T)
10083 return elfcore_grok_pstatus (abfd
, note
);
10086 #if defined (HAVE_LWPSTATUS_T)
10088 return elfcore_grok_lwpstatus (abfd
, note
);
10091 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10092 return elfcore_grok_prfpreg (abfd
, note
);
10094 case NT_WIN32PSTATUS
:
10095 return elfcore_grok_win32pstatus (abfd
, note
);
10097 case NT_PRXFPREG
: /* Linux SSE extension */
10098 if (note
->namesz
== 6
10099 && strcmp (note
->namedata
, "LINUX") == 0)
10100 return elfcore_grok_prxfpreg (abfd
, note
);
10104 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10105 if (note
->namesz
== 6
10106 && strcmp (note
->namedata
, "LINUX") == 0)
10107 return elfcore_grok_xstatereg (abfd
, note
);
10112 if (note
->namesz
== 6
10113 && strcmp (note
->namedata
, "LINUX") == 0)
10114 return elfcore_grok_ppc_vmx (abfd
, note
);
10119 if (note
->namesz
== 6
10120 && strcmp (note
->namedata
, "LINUX") == 0)
10121 return elfcore_grok_ppc_vsx (abfd
, note
);
10126 if (note
->namesz
== 6
10127 && strcmp (note
->namedata
, "LINUX") == 0)
10128 return elfcore_grok_ppc_tar (abfd
, note
);
10133 if (note
->namesz
== 6
10134 && strcmp (note
->namedata
, "LINUX") == 0)
10135 return elfcore_grok_ppc_ppr (abfd
, note
);
10140 if (note
->namesz
== 6
10141 && strcmp (note
->namedata
, "LINUX") == 0)
10142 return elfcore_grok_ppc_dscr (abfd
, note
);
10147 if (note
->namesz
== 6
10148 && strcmp (note
->namedata
, "LINUX") == 0)
10149 return elfcore_grok_ppc_ebb (abfd
, note
);
10154 if (note
->namesz
== 6
10155 && strcmp (note
->namedata
, "LINUX") == 0)
10156 return elfcore_grok_ppc_pmu (abfd
, note
);
10160 case NT_PPC_TM_CGPR
:
10161 if (note
->namesz
== 6
10162 && strcmp (note
->namedata
, "LINUX") == 0)
10163 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10167 case NT_PPC_TM_CFPR
:
10168 if (note
->namesz
== 6
10169 && strcmp (note
->namedata
, "LINUX") == 0)
10170 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10174 case NT_PPC_TM_CVMX
:
10175 if (note
->namesz
== 6
10176 && strcmp (note
->namedata
, "LINUX") == 0)
10177 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10181 case NT_PPC_TM_CVSX
:
10182 if (note
->namesz
== 6
10183 && strcmp (note
->namedata
, "LINUX") == 0)
10184 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10188 case NT_PPC_TM_SPR
:
10189 if (note
->namesz
== 6
10190 && strcmp (note
->namedata
, "LINUX") == 0)
10191 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10195 case NT_PPC_TM_CTAR
:
10196 if (note
->namesz
== 6
10197 && strcmp (note
->namedata
, "LINUX") == 0)
10198 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10202 case NT_PPC_TM_CPPR
:
10203 if (note
->namesz
== 6
10204 && strcmp (note
->namedata
, "LINUX") == 0)
10205 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10209 case NT_PPC_TM_CDSCR
:
10210 if (note
->namesz
== 6
10211 && strcmp (note
->namedata
, "LINUX") == 0)
10212 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10216 case NT_S390_HIGH_GPRS
:
10217 if (note
->namesz
== 6
10218 && strcmp (note
->namedata
, "LINUX") == 0)
10219 return elfcore_grok_s390_high_gprs (abfd
, note
);
10223 case NT_S390_TIMER
:
10224 if (note
->namesz
== 6
10225 && strcmp (note
->namedata
, "LINUX") == 0)
10226 return elfcore_grok_s390_timer (abfd
, note
);
10230 case NT_S390_TODCMP
:
10231 if (note
->namesz
== 6
10232 && strcmp (note
->namedata
, "LINUX") == 0)
10233 return elfcore_grok_s390_todcmp (abfd
, note
);
10237 case NT_S390_TODPREG
:
10238 if (note
->namesz
== 6
10239 && strcmp (note
->namedata
, "LINUX") == 0)
10240 return elfcore_grok_s390_todpreg (abfd
, note
);
10245 if (note
->namesz
== 6
10246 && strcmp (note
->namedata
, "LINUX") == 0)
10247 return elfcore_grok_s390_ctrs (abfd
, note
);
10251 case NT_S390_PREFIX
:
10252 if (note
->namesz
== 6
10253 && strcmp (note
->namedata
, "LINUX") == 0)
10254 return elfcore_grok_s390_prefix (abfd
, note
);
10258 case NT_S390_LAST_BREAK
:
10259 if (note
->namesz
== 6
10260 && strcmp (note
->namedata
, "LINUX") == 0)
10261 return elfcore_grok_s390_last_break (abfd
, note
);
10265 case NT_S390_SYSTEM_CALL
:
10266 if (note
->namesz
== 6
10267 && strcmp (note
->namedata
, "LINUX") == 0)
10268 return elfcore_grok_s390_system_call (abfd
, note
);
10273 if (note
->namesz
== 6
10274 && strcmp (note
->namedata
, "LINUX") == 0)
10275 return elfcore_grok_s390_tdb (abfd
, note
);
10279 case NT_S390_VXRS_LOW
:
10280 if (note
->namesz
== 6
10281 && strcmp (note
->namedata
, "LINUX") == 0)
10282 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10286 case NT_S390_VXRS_HIGH
:
10287 if (note
->namesz
== 6
10288 && strcmp (note
->namedata
, "LINUX") == 0)
10289 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10293 case NT_S390_GS_CB
:
10294 if (note
->namesz
== 6
10295 && strcmp (note
->namedata
, "LINUX") == 0)
10296 return elfcore_grok_s390_gs_cb (abfd
, note
);
10300 case NT_S390_GS_BC
:
10301 if (note
->namesz
== 6
10302 && strcmp (note
->namedata
, "LINUX") == 0)
10303 return elfcore_grok_s390_gs_bc (abfd
, note
);
10308 if (note
->namesz
== 6
10309 && strcmp (note
->namedata
, "LINUX") == 0)
10310 return elfcore_grok_arm_vfp (abfd
, note
);
10315 if (note
->namesz
== 6
10316 && strcmp (note
->namedata
, "LINUX") == 0)
10317 return elfcore_grok_aarch_tls (abfd
, note
);
10321 case NT_ARM_HW_BREAK
:
10322 if (note
->namesz
== 6
10323 && strcmp (note
->namedata
, "LINUX") == 0)
10324 return elfcore_grok_aarch_hw_break (abfd
, note
);
10328 case NT_ARM_HW_WATCH
:
10329 if (note
->namesz
== 6
10330 && strcmp (note
->namedata
, "LINUX") == 0)
10331 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10336 if (note
->namesz
== 6
10337 && strcmp (note
->namedata
, "LINUX") == 0)
10338 return elfcore_grok_aarch_sve (abfd
, note
);
10342 case NT_ARM_PAC_MASK
:
10343 if (note
->namesz
== 6
10344 && strcmp (note
->namedata
, "LINUX") == 0)
10345 return elfcore_grok_aarch_pauth (abfd
, note
);
10351 if (bed
->elf_backend_grok_psinfo
)
10352 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10354 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10355 return elfcore_grok_psinfo (abfd
, note
);
10361 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10364 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10368 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10375 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10377 struct bfd_build_id
* build_id
;
10379 if (note
->descsz
== 0)
10382 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10383 if (build_id
== NULL
)
10386 build_id
->size
= note
->descsz
;
10387 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10388 abfd
->build_id
= build_id
;
10394 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10396 switch (note
->type
)
10401 case NT_GNU_PROPERTY_TYPE_0
:
10402 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10404 case NT_GNU_BUILD_ID
:
10405 return elfobj_grok_gnu_build_id (abfd
, note
);
10410 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10412 struct sdt_note
*cur
=
10413 (struct sdt_note
*) bfd_alloc (abfd
,
10414 sizeof (struct sdt_note
) + note
->descsz
);
10416 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10417 cur
->size
= (bfd_size_type
) note
->descsz
;
10418 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10420 elf_tdata (abfd
)->sdt_note_head
= cur
;
10426 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10428 switch (note
->type
)
10431 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10439 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10443 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10446 if (note
->descsz
< 108)
10451 if (note
->descsz
< 120)
10459 /* Check for version 1 in pr_version. */
10460 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10465 /* Skip over pr_psinfosz. */
10466 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10470 offset
+= 4; /* Padding before pr_psinfosz. */
10474 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10475 elf_tdata (abfd
)->core
->program
10476 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10479 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10480 elf_tdata (abfd
)->core
->command
10481 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10484 /* Padding before pr_pid. */
10487 /* The pr_pid field was added in version "1a". */
10488 if (note
->descsz
< offset
+ 4)
10491 elf_tdata (abfd
)->core
->pid
10492 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10498 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10504 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10505 Also compute minimum size of this note. */
10506 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10510 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10514 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10515 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10522 if (note
->descsz
< min_size
)
10525 /* Check for version 1 in pr_version. */
10526 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10529 /* Extract size of pr_reg from pr_gregsetsz. */
10530 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10531 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10533 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10538 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10542 /* Skip over pr_osreldate. */
10545 /* Read signal from pr_cursig. */
10546 if (elf_tdata (abfd
)->core
->signal
== 0)
10547 elf_tdata (abfd
)->core
->signal
10548 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10551 /* Read TID from pr_pid. */
10552 elf_tdata (abfd
)->core
->lwpid
10553 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10556 /* Padding before pr_reg. */
10557 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10560 /* Make sure that there is enough data remaining in the note. */
10561 if ((note
->descsz
- offset
) < size
)
10564 /* Make a ".reg/999" section and a ".reg" section. */
10565 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10566 size
, note
->descpos
+ offset
);
10570 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10572 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10574 switch (note
->type
)
10577 if (bed
->elf_backend_grok_freebsd_prstatus
)
10578 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10580 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10583 return elfcore_grok_prfpreg (abfd
, note
);
10586 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10588 case NT_FREEBSD_THRMISC
:
10589 if (note
->namesz
== 8)
10590 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10594 case NT_FREEBSD_PROCSTAT_PROC
:
10595 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10598 case NT_FREEBSD_PROCSTAT_FILES
:
10599 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10602 case NT_FREEBSD_PROCSTAT_VMMAP
:
10603 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10606 case NT_FREEBSD_PROCSTAT_AUXV
:
10607 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10609 case NT_X86_XSTATE
:
10610 if (note
->namesz
== 8)
10611 return elfcore_grok_xstatereg (abfd
, note
);
10615 case NT_FREEBSD_PTLWPINFO
:
10616 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10620 return elfcore_grok_arm_vfp (abfd
, note
);
10628 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10632 cp
= strchr (note
->namedata
, '@');
10635 *lwpidp
= atoi(cp
+ 1);
10642 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10644 if (note
->descsz
<= 0x7c + 31)
10647 /* Signal number at offset 0x08. */
10648 elf_tdata (abfd
)->core
->signal
10649 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10651 /* Process ID at offset 0x50. */
10652 elf_tdata (abfd
)->core
->pid
10653 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10655 /* Command name at 0x7c (max 32 bytes, including nul). */
10656 elf_tdata (abfd
)->core
->command
10657 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10659 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10664 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10668 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10669 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10671 switch (note
->type
)
10673 case NT_NETBSDCORE_PROCINFO
:
10674 /* NetBSD-specific core "procinfo". Note that we expect to
10675 find this note before any of the others, which is fine,
10676 since the kernel writes this note out first when it
10677 creates a core file. */
10678 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10679 #ifdef NT_NETBSDCORE_AUXV
10680 case NT_NETBSDCORE_AUXV
:
10681 /* NetBSD-specific Elf Auxiliary Vector data. */
10682 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10688 /* As of March 2017 there are no other machine-independent notes
10689 defined for NetBSD core files. If the note type is less
10690 than the start of the machine-dependent note types, we don't
10693 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10697 switch (bfd_get_arch (abfd
))
10699 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10700 PT_GETFPREGS == mach+2. */
10702 case bfd_arch_alpha
:
10703 case bfd_arch_sparc
:
10704 switch (note
->type
)
10706 case NT_NETBSDCORE_FIRSTMACH
+0:
10707 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10709 case NT_NETBSDCORE_FIRSTMACH
+2:
10710 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10716 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10717 There's also old PT___GETREGS40 == mach + 1 for old reg
10718 structure which lacks GBR. */
10721 switch (note
->type
)
10723 case NT_NETBSDCORE_FIRSTMACH
+3:
10724 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10726 case NT_NETBSDCORE_FIRSTMACH
+5:
10727 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10733 /* On all other arch's, PT_GETREGS == mach+1 and
10734 PT_GETFPREGS == mach+3. */
10737 switch (note
->type
)
10739 case NT_NETBSDCORE_FIRSTMACH
+1:
10740 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10742 case NT_NETBSDCORE_FIRSTMACH
+3:
10743 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10753 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10755 if (note
->descsz
<= 0x48 + 31)
10758 /* Signal number at offset 0x08. */
10759 elf_tdata (abfd
)->core
->signal
10760 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10762 /* Process ID at offset 0x20. */
10763 elf_tdata (abfd
)->core
->pid
10764 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
10766 /* Command name at 0x48 (max 32 bytes, including nul). */
10767 elf_tdata (abfd
)->core
->command
10768 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
10774 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10776 if (note
->type
== NT_OPENBSD_PROCINFO
)
10777 return elfcore_grok_openbsd_procinfo (abfd
, note
);
10779 if (note
->type
== NT_OPENBSD_REGS
)
10780 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10782 if (note
->type
== NT_OPENBSD_FPREGS
)
10783 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10785 if (note
->type
== NT_OPENBSD_XFPREGS
)
10786 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
10788 if (note
->type
== NT_OPENBSD_AUXV
)
10789 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10791 if (note
->type
== NT_OPENBSD_WCOOKIE
)
10793 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
10798 sect
->size
= note
->descsz
;
10799 sect
->filepos
= note
->descpos
;
10800 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10809 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
10811 void *ddata
= note
->descdata
;
10818 if (note
->descsz
< 16)
10821 /* nto_procfs_status 'pid' field is at offset 0. */
10822 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
10824 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10825 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
10827 /* nto_procfs_status 'flags' field is at offset 8. */
10828 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
10830 /* nto_procfs_status 'what' field is at offset 14. */
10831 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
10833 elf_tdata (abfd
)->core
->signal
= sig
;
10834 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10837 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10838 do not come from signals so we make sure we set the current
10839 thread just in case. */
10840 if (flags
& 0x00000080)
10841 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10843 /* Make a ".qnx_core_status/%d" section. */
10844 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
10846 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10849 strcpy (name
, buf
);
10851 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10855 sect
->size
= note
->descsz
;
10856 sect
->filepos
= note
->descpos
;
10857 sect
->alignment_power
= 2;
10859 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
10863 elfcore_grok_nto_regs (bfd
*abfd
,
10864 Elf_Internal_Note
*note
,
10872 /* Make a "(base)/%d" section. */
10873 sprintf (buf
, "%s/%ld", base
, tid
);
10875 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10878 strcpy (name
, buf
);
10880 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10884 sect
->size
= note
->descsz
;
10885 sect
->filepos
= note
->descpos
;
10886 sect
->alignment_power
= 2;
10888 /* This is the current thread. */
10889 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
10890 return elfcore_maybe_make_sect (abfd
, base
, sect
);
10895 #define BFD_QNT_CORE_INFO 7
10896 #define BFD_QNT_CORE_STATUS 8
10897 #define BFD_QNT_CORE_GREG 9
10898 #define BFD_QNT_CORE_FPREG 10
10901 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10903 /* Every GREG section has a STATUS section before it. Store the
10904 tid from the previous call to pass down to the next gregs
10906 static long tid
= 1;
10908 switch (note
->type
)
10910 case BFD_QNT_CORE_INFO
:
10911 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
10912 case BFD_QNT_CORE_STATUS
:
10913 return elfcore_grok_nto_status (abfd
, note
, &tid
);
10914 case BFD_QNT_CORE_GREG
:
10915 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
10916 case BFD_QNT_CORE_FPREG
:
10917 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
10924 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10930 /* Use note name as section name. */
10931 len
= note
->namesz
;
10932 name
= (char *) bfd_alloc (abfd
, len
);
10935 memcpy (name
, note
->namedata
, len
);
10936 name
[len
- 1] = '\0';
10938 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10942 sect
->size
= note
->descsz
;
10943 sect
->filepos
= note
->descpos
;
10944 sect
->alignment_power
= 1;
10949 /* Function: elfcore_write_note
10952 buffer to hold note, and current size of buffer
10956 size of data for note
10958 Writes note to end of buffer. ELF64 notes are written exactly as
10959 for ELF32, despite the current (as of 2006) ELF gabi specifying
10960 that they ought to have 8-byte namesz and descsz field, and have
10961 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10964 Pointer to realloc'd buffer, *BUFSIZ updated. */
10967 elfcore_write_note (bfd
*abfd
,
10975 Elf_External_Note
*xnp
;
10982 namesz
= strlen (name
) + 1;
10984 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
10986 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
10989 dest
= buf
+ *bufsiz
;
10990 *bufsiz
+= newspace
;
10991 xnp
= (Elf_External_Note
*) dest
;
10992 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
10993 H_PUT_32 (abfd
, size
, xnp
->descsz
);
10994 H_PUT_32 (abfd
, type
, xnp
->type
);
10998 memcpy (dest
, name
, namesz
);
11006 memcpy (dest
, input
, size
);
11016 /* gcc-8 warns (*) on all the strncpy calls in this function about
11017 possible string truncation. The "truncation" is not a bug. We
11018 have an external representation of structs with fields that are not
11019 necessarily NULL terminated and corresponding internal
11020 representation fields that are one larger so that they can always
11021 be NULL terminated.
11022 gcc versions between 4.2 and 4.6 do not allow pragma control of
11023 diagnostics inside functions, giving a hard error if you try to use
11024 the finer control available with later versions.
11025 gcc prior to 4.2 warns about diagnostic push and pop.
11026 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11027 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11028 (*) Depending on your system header files! */
11029 #if GCC_VERSION >= 8000
11030 # pragma GCC diagnostic push
11031 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11034 elfcore_write_prpsinfo (bfd
*abfd
,
11038 const char *psargs
)
11040 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11042 if (bed
->elf_backend_write_core_note
!= NULL
)
11045 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11046 NT_PRPSINFO
, fname
, psargs
);
11051 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11052 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11053 if (bed
->s
->elfclass
== ELFCLASS32
)
11055 # if defined (HAVE_PSINFO32_T)
11057 int note_type
= NT_PSINFO
;
11060 int note_type
= NT_PRPSINFO
;
11063 memset (&data
, 0, sizeof (data
));
11064 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11065 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11066 return elfcore_write_note (abfd
, buf
, bufsiz
,
11067 "CORE", note_type
, &data
, sizeof (data
));
11072 # if defined (HAVE_PSINFO_T)
11074 int note_type
= NT_PSINFO
;
11077 int note_type
= NT_PRPSINFO
;
11080 memset (&data
, 0, sizeof (data
));
11081 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11082 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11083 return elfcore_write_note (abfd
, buf
, bufsiz
,
11084 "CORE", note_type
, &data
, sizeof (data
));
11086 #endif /* PSINFO_T or PRPSINFO_T */
11091 #if GCC_VERSION >= 8000
11092 # pragma GCC diagnostic pop
11096 elfcore_write_linux_prpsinfo32
11097 (bfd
*abfd
, char *buf
, int *bufsiz
,
11098 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11100 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11102 struct elf_external_linux_prpsinfo32_ugid16 data
;
11104 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11105 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11106 &data
, sizeof (data
));
11110 struct elf_external_linux_prpsinfo32_ugid32 data
;
11112 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11113 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11114 &data
, sizeof (data
));
11119 elfcore_write_linux_prpsinfo64
11120 (bfd
*abfd
, char *buf
, int *bufsiz
,
11121 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11123 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11125 struct elf_external_linux_prpsinfo64_ugid16 data
;
11127 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11128 return elfcore_write_note (abfd
, buf
, bufsiz
,
11129 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11133 struct elf_external_linux_prpsinfo64_ugid32 data
;
11135 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11136 return elfcore_write_note (abfd
, buf
, bufsiz
,
11137 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11142 elfcore_write_prstatus (bfd
*abfd
,
11149 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11151 if (bed
->elf_backend_write_core_note
!= NULL
)
11154 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11156 pid
, cursig
, gregs
);
11161 #if defined (HAVE_PRSTATUS_T)
11162 #if defined (HAVE_PRSTATUS32_T)
11163 if (bed
->s
->elfclass
== ELFCLASS32
)
11165 prstatus32_t prstat
;
11167 memset (&prstat
, 0, sizeof (prstat
));
11168 prstat
.pr_pid
= pid
;
11169 prstat
.pr_cursig
= cursig
;
11170 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11171 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11172 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11179 memset (&prstat
, 0, sizeof (prstat
));
11180 prstat
.pr_pid
= pid
;
11181 prstat
.pr_cursig
= cursig
;
11182 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11183 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11184 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11186 #endif /* HAVE_PRSTATUS_T */
11192 #if defined (HAVE_LWPSTATUS_T)
11194 elfcore_write_lwpstatus (bfd
*abfd
,
11201 lwpstatus_t lwpstat
;
11202 const char *note_name
= "CORE";
11204 memset (&lwpstat
, 0, sizeof (lwpstat
));
11205 lwpstat
.pr_lwpid
= pid
>> 16;
11206 lwpstat
.pr_cursig
= cursig
;
11207 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11208 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11209 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11210 #if !defined(gregs)
11211 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11212 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11214 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11215 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11218 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11219 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11221 #endif /* HAVE_LWPSTATUS_T */
11223 #if defined (HAVE_PSTATUS_T)
11225 elfcore_write_pstatus (bfd
*abfd
,
11229 int cursig ATTRIBUTE_UNUSED
,
11230 const void *gregs ATTRIBUTE_UNUSED
)
11232 const char *note_name
= "CORE";
11233 #if defined (HAVE_PSTATUS32_T)
11234 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11236 if (bed
->s
->elfclass
== ELFCLASS32
)
11240 memset (&pstat
, 0, sizeof (pstat
));
11241 pstat
.pr_pid
= pid
& 0xffff;
11242 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11243 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11251 memset (&pstat
, 0, sizeof (pstat
));
11252 pstat
.pr_pid
= pid
& 0xffff;
11253 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11254 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11258 #endif /* HAVE_PSTATUS_T */
11261 elfcore_write_prfpreg (bfd
*abfd
,
11264 const void *fpregs
,
11267 const char *note_name
= "CORE";
11268 return elfcore_write_note (abfd
, buf
, bufsiz
,
11269 note_name
, NT_FPREGSET
, fpregs
, size
);
11273 elfcore_write_prxfpreg (bfd
*abfd
,
11276 const void *xfpregs
,
11279 char *note_name
= "LINUX";
11280 return elfcore_write_note (abfd
, buf
, bufsiz
,
11281 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11285 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11286 const void *xfpregs
, int size
)
11289 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11290 note_name
= "FreeBSD";
11292 note_name
= "LINUX";
11293 return elfcore_write_note (abfd
, buf
, bufsiz
,
11294 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11298 elfcore_write_ppc_vmx (bfd
*abfd
,
11301 const void *ppc_vmx
,
11304 char *note_name
= "LINUX";
11305 return elfcore_write_note (abfd
, buf
, bufsiz
,
11306 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11310 elfcore_write_ppc_vsx (bfd
*abfd
,
11313 const void *ppc_vsx
,
11316 char *note_name
= "LINUX";
11317 return elfcore_write_note (abfd
, buf
, bufsiz
,
11318 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11322 elfcore_write_ppc_tar (bfd
*abfd
,
11325 const void *ppc_tar
,
11328 char *note_name
= "LINUX";
11329 return elfcore_write_note (abfd
, buf
, bufsiz
,
11330 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11334 elfcore_write_ppc_ppr (bfd
*abfd
,
11337 const void *ppc_ppr
,
11340 char *note_name
= "LINUX";
11341 return elfcore_write_note (abfd
, buf
, bufsiz
,
11342 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11346 elfcore_write_ppc_dscr (bfd
*abfd
,
11349 const void *ppc_dscr
,
11352 char *note_name
= "LINUX";
11353 return elfcore_write_note (abfd
, buf
, bufsiz
,
11354 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11358 elfcore_write_ppc_ebb (bfd
*abfd
,
11361 const void *ppc_ebb
,
11364 char *note_name
= "LINUX";
11365 return elfcore_write_note (abfd
, buf
, bufsiz
,
11366 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11370 elfcore_write_ppc_pmu (bfd
*abfd
,
11373 const void *ppc_pmu
,
11376 char *note_name
= "LINUX";
11377 return elfcore_write_note (abfd
, buf
, bufsiz
,
11378 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11382 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11385 const void *ppc_tm_cgpr
,
11388 char *note_name
= "LINUX";
11389 return elfcore_write_note (abfd
, buf
, bufsiz
,
11390 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11394 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11397 const void *ppc_tm_cfpr
,
11400 char *note_name
= "LINUX";
11401 return elfcore_write_note (abfd
, buf
, bufsiz
,
11402 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11406 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11409 const void *ppc_tm_cvmx
,
11412 char *note_name
= "LINUX";
11413 return elfcore_write_note (abfd
, buf
, bufsiz
,
11414 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11418 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11421 const void *ppc_tm_cvsx
,
11424 char *note_name
= "LINUX";
11425 return elfcore_write_note (abfd
, buf
, bufsiz
,
11426 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11430 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11433 const void *ppc_tm_spr
,
11436 char *note_name
= "LINUX";
11437 return elfcore_write_note (abfd
, buf
, bufsiz
,
11438 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11442 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11445 const void *ppc_tm_ctar
,
11448 char *note_name
= "LINUX";
11449 return elfcore_write_note (abfd
, buf
, bufsiz
,
11450 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11454 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11457 const void *ppc_tm_cppr
,
11460 char *note_name
= "LINUX";
11461 return elfcore_write_note (abfd
, buf
, bufsiz
,
11462 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11466 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11469 const void *ppc_tm_cdscr
,
11472 char *note_name
= "LINUX";
11473 return elfcore_write_note (abfd
, buf
, bufsiz
,
11474 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11478 elfcore_write_s390_high_gprs (bfd
*abfd
,
11481 const void *s390_high_gprs
,
11484 char *note_name
= "LINUX";
11485 return elfcore_write_note (abfd
, buf
, bufsiz
,
11486 note_name
, NT_S390_HIGH_GPRS
,
11487 s390_high_gprs
, size
);
11491 elfcore_write_s390_timer (bfd
*abfd
,
11494 const void *s390_timer
,
11497 char *note_name
= "LINUX";
11498 return elfcore_write_note (abfd
, buf
, bufsiz
,
11499 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11503 elfcore_write_s390_todcmp (bfd
*abfd
,
11506 const void *s390_todcmp
,
11509 char *note_name
= "LINUX";
11510 return elfcore_write_note (abfd
, buf
, bufsiz
,
11511 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11515 elfcore_write_s390_todpreg (bfd
*abfd
,
11518 const void *s390_todpreg
,
11521 char *note_name
= "LINUX";
11522 return elfcore_write_note (abfd
, buf
, bufsiz
,
11523 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11527 elfcore_write_s390_ctrs (bfd
*abfd
,
11530 const void *s390_ctrs
,
11533 char *note_name
= "LINUX";
11534 return elfcore_write_note (abfd
, buf
, bufsiz
,
11535 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11539 elfcore_write_s390_prefix (bfd
*abfd
,
11542 const void *s390_prefix
,
11545 char *note_name
= "LINUX";
11546 return elfcore_write_note (abfd
, buf
, bufsiz
,
11547 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11551 elfcore_write_s390_last_break (bfd
*abfd
,
11554 const void *s390_last_break
,
11557 char *note_name
= "LINUX";
11558 return elfcore_write_note (abfd
, buf
, bufsiz
,
11559 note_name
, NT_S390_LAST_BREAK
,
11560 s390_last_break
, size
);
11564 elfcore_write_s390_system_call (bfd
*abfd
,
11567 const void *s390_system_call
,
11570 char *note_name
= "LINUX";
11571 return elfcore_write_note (abfd
, buf
, bufsiz
,
11572 note_name
, NT_S390_SYSTEM_CALL
,
11573 s390_system_call
, size
);
11577 elfcore_write_s390_tdb (bfd
*abfd
,
11580 const void *s390_tdb
,
11583 char *note_name
= "LINUX";
11584 return elfcore_write_note (abfd
, buf
, bufsiz
,
11585 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11589 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11592 const void *s390_vxrs_low
,
11595 char *note_name
= "LINUX";
11596 return elfcore_write_note (abfd
, buf
, bufsiz
,
11597 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11601 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11604 const void *s390_vxrs_high
,
11607 char *note_name
= "LINUX";
11608 return elfcore_write_note (abfd
, buf
, bufsiz
,
11609 note_name
, NT_S390_VXRS_HIGH
,
11610 s390_vxrs_high
, size
);
11614 elfcore_write_s390_gs_cb (bfd
*abfd
,
11617 const void *s390_gs_cb
,
11620 char *note_name
= "LINUX";
11621 return elfcore_write_note (abfd
, buf
, bufsiz
,
11622 note_name
, NT_S390_GS_CB
,
11627 elfcore_write_s390_gs_bc (bfd
*abfd
,
11630 const void *s390_gs_bc
,
11633 char *note_name
= "LINUX";
11634 return elfcore_write_note (abfd
, buf
, bufsiz
,
11635 note_name
, NT_S390_GS_BC
,
11640 elfcore_write_arm_vfp (bfd
*abfd
,
11643 const void *arm_vfp
,
11646 char *note_name
= "LINUX";
11647 return elfcore_write_note (abfd
, buf
, bufsiz
,
11648 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11652 elfcore_write_aarch_tls (bfd
*abfd
,
11655 const void *aarch_tls
,
11658 char *note_name
= "LINUX";
11659 return elfcore_write_note (abfd
, buf
, bufsiz
,
11660 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11664 elfcore_write_aarch_hw_break (bfd
*abfd
,
11667 const void *aarch_hw_break
,
11670 char *note_name
= "LINUX";
11671 return elfcore_write_note (abfd
, buf
, bufsiz
,
11672 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11676 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11679 const void *aarch_hw_watch
,
11682 char *note_name
= "LINUX";
11683 return elfcore_write_note (abfd
, buf
, bufsiz
,
11684 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11688 elfcore_write_aarch_sve (bfd
*abfd
,
11691 const void *aarch_sve
,
11694 char *note_name
= "LINUX";
11695 return elfcore_write_note (abfd
, buf
, bufsiz
,
11696 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11700 elfcore_write_aarch_pauth (bfd
*abfd
,
11703 const void *aarch_pauth
,
11706 char *note_name
= "LINUX";
11707 return elfcore_write_note (abfd
, buf
, bufsiz
,
11708 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11712 elfcore_write_register_note (bfd
*abfd
,
11715 const char *section
,
11719 if (strcmp (section
, ".reg2") == 0)
11720 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
11721 if (strcmp (section
, ".reg-xfp") == 0)
11722 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
11723 if (strcmp (section
, ".reg-xstate") == 0)
11724 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
11725 if (strcmp (section
, ".reg-ppc-vmx") == 0)
11726 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
11727 if (strcmp (section
, ".reg-ppc-vsx") == 0)
11728 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
11729 if (strcmp (section
, ".reg-ppc-tar") == 0)
11730 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
11731 if (strcmp (section
, ".reg-ppc-ppr") == 0)
11732 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
11733 if (strcmp (section
, ".reg-ppc-dscr") == 0)
11734 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
11735 if (strcmp (section
, ".reg-ppc-ebb") == 0)
11736 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
11737 if (strcmp (section
, ".reg-ppc-pmu") == 0)
11738 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
11739 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
11740 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
11741 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
11742 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
11743 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
11744 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
11745 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
11746 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
11747 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
11748 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
11749 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
11750 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
11751 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
11752 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
11753 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
11754 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
11755 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
11756 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
11757 if (strcmp (section
, ".reg-s390-timer") == 0)
11758 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
11759 if (strcmp (section
, ".reg-s390-todcmp") == 0)
11760 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
11761 if (strcmp (section
, ".reg-s390-todpreg") == 0)
11762 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
11763 if (strcmp (section
, ".reg-s390-ctrs") == 0)
11764 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
11765 if (strcmp (section
, ".reg-s390-prefix") == 0)
11766 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
11767 if (strcmp (section
, ".reg-s390-last-break") == 0)
11768 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
11769 if (strcmp (section
, ".reg-s390-system-call") == 0)
11770 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
11771 if (strcmp (section
, ".reg-s390-tdb") == 0)
11772 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
11773 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
11774 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
11775 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
11776 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
11777 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
11778 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
11779 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
11780 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
11781 if (strcmp (section
, ".reg-arm-vfp") == 0)
11782 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
11783 if (strcmp (section
, ".reg-aarch-tls") == 0)
11784 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
11785 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
11786 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
11787 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
11788 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
11789 if (strcmp (section
, ".reg-aarch-sve") == 0)
11790 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
11791 if (strcmp (section
, ".reg-aarch-pauth") == 0)
11792 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
11797 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
11802 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11803 gABI specifies that PT_NOTE alignment should be aligned to 4
11804 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11805 align is less than 4, we use 4 byte alignment. */
11808 if (align
!= 4 && align
!= 8)
11812 while (p
< buf
+ size
)
11814 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
11815 Elf_Internal_Note in
;
11817 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
11820 in
.type
= H_GET_32 (abfd
, xnp
->type
);
11822 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
11823 in
.namedata
= xnp
->name
;
11824 if (in
.namesz
> buf
- in
.namedata
+ size
)
11827 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
11828 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
11829 in
.descpos
= offset
+ (in
.descdata
- buf
);
11831 && (in
.descdata
>= buf
+ size
11832 || in
.descsz
> buf
- in
.descdata
+ size
))
11835 switch (bfd_get_format (abfd
))
11842 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11845 const char * string
;
11847 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
11851 GROKER_ELEMENT ("", elfcore_grok_note
),
11852 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
11853 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
11854 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
11855 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
11856 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
11857 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
11859 #undef GROKER_ELEMENT
11862 for (i
= ARRAY_SIZE (grokers
); i
--;)
11864 if (in
.namesz
>= grokers
[i
].len
11865 && strncmp (in
.namedata
, grokers
[i
].string
,
11866 grokers
[i
].len
) == 0)
11868 if (! grokers
[i
].func (abfd
, & in
))
11877 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
11879 if (! elfobj_grok_gnu_note (abfd
, &in
))
11882 else if (in
.namesz
== sizeof "stapsdt"
11883 && strcmp (in
.namedata
, "stapsdt") == 0)
11885 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
11891 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
11898 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
11903 if (size
== 0 || (size
+ 1) == 0)
11906 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
11909 buf
= (char *) bfd_malloc (size
+ 1);
11913 /* PR 17512: file: ec08f814
11914 0-termintate the buffer so that string searches will not overflow. */
11917 if (bfd_bread (buf
, size
, abfd
) != size
11918 || !elf_parse_notes (abfd
, buf
, size
, offset
, align
))
11928 /* Providing external access to the ELF program header table. */
11930 /* Return an upper bound on the number of bytes required to store a
11931 copy of ABFD's program header table entries. Return -1 if an error
11932 occurs; bfd_get_error will return an appropriate code. */
11935 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
11937 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11939 bfd_set_error (bfd_error_wrong_format
);
11943 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
11946 /* Copy ABFD's program header table entries to *PHDRS. The entries
11947 will be stored as an array of Elf_Internal_Phdr structures, as
11948 defined in include/elf/internal.h. To find out how large the
11949 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11951 Return the number of program header table entries read, or -1 if an
11952 error occurs; bfd_get_error will return an appropriate code. */
11955 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
11959 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11961 bfd_set_error (bfd_error_wrong_format
);
11965 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
11966 if (num_phdrs
!= 0)
11967 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
11968 num_phdrs
* sizeof (Elf_Internal_Phdr
));
11973 enum elf_reloc_type_class
11974 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11975 const asection
*rel_sec ATTRIBUTE_UNUSED
,
11976 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
11978 return reloc_class_normal
;
11981 /* For RELA architectures, return the relocation value for a
11982 relocation against a local symbol. */
11985 _bfd_elf_rela_local_sym (bfd
*abfd
,
11986 Elf_Internal_Sym
*sym
,
11988 Elf_Internal_Rela
*rel
)
11990 asection
*sec
= *psec
;
11991 bfd_vma relocation
;
11993 relocation
= (sec
->output_section
->vma
11994 + sec
->output_offset
11996 if ((sec
->flags
& SEC_MERGE
)
11997 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
11998 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
12001 _bfd_merged_section_offset (abfd
, psec
,
12002 elf_section_data (sec
)->sec_info
,
12003 sym
->st_value
+ rel
->r_addend
);
12006 /* If we have changed the section, and our original section is
12007 marked with SEC_EXCLUDE, it means that the original
12008 SEC_MERGE section has been completely subsumed in some
12009 other SEC_MERGE section. In this case, we need to leave
12010 some info around for --emit-relocs. */
12011 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12012 sec
->kept_section
= *psec
;
12015 rel
->r_addend
-= relocation
;
12016 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12022 _bfd_elf_rel_local_sym (bfd
*abfd
,
12023 Elf_Internal_Sym
*sym
,
12027 asection
*sec
= *psec
;
12029 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12030 return sym
->st_value
+ addend
;
12032 return _bfd_merged_section_offset (abfd
, psec
,
12033 elf_section_data (sec
)->sec_info
,
12034 sym
->st_value
+ addend
);
12037 /* Adjust an address within a section. Given OFFSET within SEC, return
12038 the new offset within the section, based upon changes made to the
12039 section. Returns -1 if the offset is now invalid.
12040 The offset (in abnd out) is in target sized bytes, however big a
12044 _bfd_elf_section_offset (bfd
*abfd
,
12045 struct bfd_link_info
*info
,
12049 switch (sec
->sec_info_type
)
12051 case SEC_INFO_TYPE_STABS
:
12052 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12054 case SEC_INFO_TYPE_EH_FRAME
:
12055 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12058 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12060 /* Reverse the offset. */
12061 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12062 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12064 /* address_size and sec->size are in octets. Convert
12065 to bytes before subtracting the original offset. */
12066 offset
= ((sec
->size
- address_size
)
12067 / bfd_octets_per_byte (abfd
, sec
) - offset
);
12073 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12074 reconstruct an ELF file by reading the segments out of remote memory
12075 based on the ELF file header at EHDR_VMA and the ELF program headers it
12076 points to. If not null, *LOADBASEP is filled in with the difference
12077 between the VMAs from which the segments were read, and the VMAs the
12078 file headers (and hence BFD's idea of each section's VMA) put them at.
12080 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12081 remote memory at target address VMA into the local buffer at MYADDR; it
12082 should return zero on success or an `errno' code on failure. TEMPL must
12083 be a BFD for an ELF target with the word size and byte order found in
12084 the remote memory. */
12087 bfd_elf_bfd_from_remote_memory
12090 bfd_size_type size
,
12091 bfd_vma
*loadbasep
,
12092 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12094 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12095 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12099 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12100 long symcount ATTRIBUTE_UNUSED
,
12101 asymbol
**syms ATTRIBUTE_UNUSED
,
12106 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12109 const char *relplt_name
;
12110 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
12114 Elf_Internal_Shdr
*hdr
;
12120 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12123 if (dynsymcount
<= 0)
12126 if (!bed
->plt_sym_val
)
12129 relplt_name
= bed
->relplt_name
;
12130 if (relplt_name
== NULL
)
12131 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12132 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12133 if (relplt
== NULL
)
12136 hdr
= &elf_section_data (relplt
)->this_hdr
;
12137 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12138 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12141 plt
= bfd_get_section_by_name (abfd
, ".plt");
12145 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12146 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
12149 count
= relplt
->size
/ hdr
->sh_entsize
;
12150 size
= count
* sizeof (asymbol
);
12151 p
= relplt
->relocation
;
12152 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12154 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12155 if (p
->addend
!= 0)
12158 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12160 size
+= sizeof ("+0x") - 1 + 8;
12165 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12169 names
= (char *) (s
+ count
);
12170 p
= relplt
->relocation
;
12172 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12177 addr
= bed
->plt_sym_val (i
, plt
, p
);
12178 if (addr
== (bfd_vma
) -1)
12181 *s
= **p
->sym_ptr_ptr
;
12182 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12183 we are defining a symbol, ensure one of them is set. */
12184 if ((s
->flags
& BSF_LOCAL
) == 0)
12185 s
->flags
|= BSF_GLOBAL
;
12186 s
->flags
|= BSF_SYNTHETIC
;
12188 s
->value
= addr
- plt
->vma
;
12191 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12192 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12194 if (p
->addend
!= 0)
12198 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12199 names
+= sizeof ("+0x") - 1;
12200 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12201 for (a
= buf
; *a
== '0'; ++a
)
12204 memcpy (names
, a
, len
);
12207 memcpy (names
, "@plt", sizeof ("@plt"));
12208 names
+= sizeof ("@plt");
12215 /* It is only used by x86-64 so far.
12216 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12217 but current usage would allow all of _bfd_std_section to be zero. */
12218 static const asymbol lcomm_sym
12219 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12220 asection _bfd_elf_large_com_section
12221 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12222 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12225 _bfd_elf_final_write_processing (bfd
*abfd
)
12227 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12229 i_ehdrp
= elf_elfheader (abfd
);
12231 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12232 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12234 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12235 SHF_GNU_MBIND sections or symbols of STT_GNU_IFUNC type or
12236 STB_GNU_UNIQUE binding. */
12237 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12239 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12240 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12241 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12242 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12244 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12245 _bfd_error_handler (_("GNU_MBIND section is unsupported"));
12246 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12247 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is unsupported"));
12248 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12249 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is unsupported"));
12250 bfd_set_error (bfd_error_sorry
);
12258 /* Return TRUE for ELF symbol types that represent functions.
12259 This is the default version of this function, which is sufficient for
12260 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12263 _bfd_elf_is_function_type (unsigned int type
)
12265 return (type
== STT_FUNC
12266 || type
== STT_GNU_IFUNC
);
12269 /* If the ELF symbol SYM might be a function in SEC, return the
12270 function size and set *CODE_OFF to the function's entry point,
12271 otherwise return zero. */
12274 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12277 bfd_size_type size
;
12279 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12280 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12281 || sym
->section
!= sec
)
12284 *code_off
= sym
->value
;
12286 if (!(sym
->flags
& BSF_SYNTHETIC
))
12287 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;