1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2019 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 memset (shdr
->contents
, 0, amt
);
681 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
682 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
686 /* xgettext:c-format */
687 (_("%pB: invalid size field in group section"
688 " header: %#" PRIx64
""),
689 abfd
, (uint64_t) shdr
->sh_size
);
690 bfd_set_error (bfd_error_bad_value
);
692 /* PR 17510: If the group contents are even
693 partially corrupt, do not allow any of the
694 contents to be used. */
695 memset (shdr
->contents
, 0, amt
);
699 /* Translate raw contents, a flag word followed by an
700 array of elf section indices all in target byte order,
701 to the flag word followed by an array of elf section
703 src
= shdr
->contents
+ shdr
->sh_size
;
704 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
712 idx
= H_GET_32 (abfd
, src
);
713 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] == '.')
1108 p
= ".debug", n
= 6;
1109 else if (name
[1] == 'g' && name
[2] == 'n')
1110 p
= ".gnu.linkonce.wi.", n
= 17;
1111 else if (name
[1] == 'g' && name
[2] == 'd')
1112 p
= ".gdb_index", n
= 11; /* yes we really do mean 11. */
1113 else if (name
[1] == 'l')
1115 else if (name
[1] == 's')
1117 else if (name
[1] == 'z')
1118 p
= ".zdebug", n
= 7;
1121 if (p
!= NULL
&& strncmp (name
, p
, n
) == 0)
1122 flags
|= SEC_DEBUGGING
;
1126 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1127 only link a single copy of the section. This is used to support
1128 g++. g++ will emit each template expansion in its own section.
1129 The symbols will be defined as weak, so that multiple definitions
1130 are permitted. The GNU linker extension is to actually discard
1131 all but one of the sections. */
1132 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1133 && elf_next_in_group (newsect
) == NULL
)
1134 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1136 bed
= get_elf_backend_data (abfd
);
1137 if (bed
->elf_backend_section_flags
)
1138 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1141 if (!bfd_set_section_flags (newsect
, flags
))
1144 /* We do not parse the PT_NOTE segments as we are interested even in the
1145 separate debug info files which may have the segments offsets corrupted.
1146 PT_NOTEs from the core files are currently not parsed using BFD. */
1147 if (hdr
->sh_type
== SHT_NOTE
)
1151 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1154 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1155 hdr
->sh_offset
, hdr
->sh_addralign
);
1159 if ((flags
& SEC_ALLOC
) != 0)
1161 Elf_Internal_Phdr
*phdr
;
1162 unsigned int i
, nload
;
1164 /* Some ELF linkers produce binaries with all the program header
1165 p_paddr fields zero. If we have such a binary with more than
1166 one PT_LOAD header, then leave the section lma equal to vma
1167 so that we don't create sections with overlapping lma. */
1168 phdr
= elf_tdata (abfd
)->phdr
;
1169 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1170 if (phdr
->p_paddr
!= 0)
1172 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1174 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1177 phdr
= elf_tdata (abfd
)->phdr
;
1178 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1180 if (((phdr
->p_type
== PT_LOAD
1181 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1182 || phdr
->p_type
== PT_TLS
)
1183 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1185 if ((flags
& SEC_LOAD
) == 0)
1186 newsect
->lma
= (phdr
->p_paddr
1187 + hdr
->sh_addr
- phdr
->p_vaddr
);
1189 /* We used to use the same adjustment for SEC_LOAD
1190 sections, but that doesn't work if the segment
1191 is packed with code from multiple VMAs.
1192 Instead we calculate the section LMA based on
1193 the segment LMA. It is assumed that the
1194 segment will contain sections with contiguous
1195 LMAs, even if the VMAs are not. */
1196 newsect
->lma
= (phdr
->p_paddr
1197 + hdr
->sh_offset
- phdr
->p_offset
);
1199 /* With contiguous segments, we can't tell from file
1200 offsets whether a section with zero size should
1201 be placed at the end of one segment or the
1202 beginning of the next. Decide based on vaddr. */
1203 if (hdr
->sh_addr
>= phdr
->p_vaddr
1204 && (hdr
->sh_addr
+ hdr
->sh_size
1205 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1211 /* Compress/decompress DWARF debug sections with names: .debug_* and
1212 .zdebug_*, after the section flags is set. */
1213 if ((flags
& SEC_DEBUGGING
)
1214 && ((name
[1] == 'd' && name
[6] == '_')
1215 || (name
[1] == 'z' && name
[7] == '_')))
1217 enum { nothing
, compress
, decompress
} action
= nothing
;
1218 int compression_header_size
;
1219 bfd_size_type uncompressed_size
;
1220 unsigned int uncompressed_align_power
;
1221 bfd_boolean compressed
1222 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1223 &compression_header_size
,
1225 &uncompressed_align_power
);
1228 /* Compressed section. Check if we should decompress. */
1229 if ((abfd
->flags
& BFD_DECOMPRESS
))
1230 action
= decompress
;
1233 /* Compress the uncompressed section or convert from/to .zdebug*
1234 section. Check if we should compress. */
1235 if (action
== nothing
)
1237 if (newsect
->size
!= 0
1238 && (abfd
->flags
& BFD_COMPRESS
)
1239 && compression_header_size
>= 0
1240 && uncompressed_size
> 0
1242 || ((compression_header_size
> 0)
1243 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1249 if (action
== compress
)
1251 if (!bfd_init_section_compress_status (abfd
, newsect
))
1254 /* xgettext:c-format */
1255 (_("%pB: unable to initialize compress status for section %s"),
1262 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1265 /* xgettext:c-format */
1266 (_("%pB: unable to initialize decompress status for section %s"),
1272 if (abfd
->is_linker_input
)
1275 && (action
== decompress
1276 || (action
== compress
1277 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1279 /* Convert section name from .zdebug_* to .debug_* so
1280 that linker will consider this section as a debug
1282 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1283 if (new_name
== NULL
)
1285 bfd_rename_section (newsect
, new_name
);
1289 /* For objdump, don't rename the section. For objcopy, delay
1290 section rename to elf_fake_sections. */
1291 newsect
->flags
|= SEC_ELF_RENAME
;
1294 /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
1296 const char *lto_section_name
= ".gnu.lto_.lto.";
1297 if (strncmp (name
, lto_section_name
, strlen (lto_section_name
)) == 0)
1299 struct lto_section lsection
;
1300 if (bfd_get_section_contents (abfd
, newsect
, &lsection
, 0,
1301 sizeof (struct lto_section
)))
1302 abfd
->lto_slim_object
= lsection
.slim_object
;
1308 const char *const bfd_elf_section_type_names
[] =
1310 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1311 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1312 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1315 /* ELF relocs are against symbols. If we are producing relocatable
1316 output, and the reloc is against an external symbol, and nothing
1317 has given us any additional addend, the resulting reloc will also
1318 be against the same symbol. In such a case, we don't want to
1319 change anything about the way the reloc is handled, since it will
1320 all be done at final link time. Rather than put special case code
1321 into bfd_perform_relocation, all the reloc types use this howto
1322 function. It just short circuits the reloc if producing
1323 relocatable output against an external symbol. */
1325 bfd_reloc_status_type
1326 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1327 arelent
*reloc_entry
,
1329 void *data ATTRIBUTE_UNUSED
,
1330 asection
*input_section
,
1332 char **error_message ATTRIBUTE_UNUSED
)
1334 if (output_bfd
!= NULL
1335 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1336 && (! reloc_entry
->howto
->partial_inplace
1337 || reloc_entry
->addend
== 0))
1339 reloc_entry
->address
+= input_section
->output_offset
;
1340 return bfd_reloc_ok
;
1343 return bfd_reloc_continue
;
1346 /* Returns TRUE if section A matches section B.
1347 Names, addresses and links may be different, but everything else
1348 should be the same. */
1351 section_match (const Elf_Internal_Shdr
* a
,
1352 const Elf_Internal_Shdr
* b
)
1354 if (a
->sh_type
!= b
->sh_type
1355 || ((a
->sh_flags
^ b
->sh_flags
) & ~SHF_INFO_LINK
) != 0
1356 || a
->sh_addralign
!= b
->sh_addralign
1357 || a
->sh_entsize
!= b
->sh_entsize
)
1359 if (a
->sh_type
== SHT_SYMTAB
1360 || a
->sh_type
== SHT_STRTAB
)
1362 return a
->sh_size
== b
->sh_size
;
1365 /* Find a section in OBFD that has the same characteristics
1366 as IHEADER. Return the index of this section or SHN_UNDEF if
1367 none can be found. Check's section HINT first, as this is likely
1368 to be the correct section. */
1371 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1372 const unsigned int hint
)
1374 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1377 BFD_ASSERT (iheader
!= NULL
);
1379 /* See PR 20922 for a reproducer of the NULL test. */
1380 if (hint
< elf_numsections (obfd
)
1381 && oheaders
[hint
] != NULL
1382 && section_match (oheaders
[hint
], iheader
))
1385 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1387 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1389 if (oheader
== NULL
)
1391 if (section_match (oheader
, iheader
))
1392 /* FIXME: Do we care if there is a potential for
1393 multiple matches ? */
1400 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1401 Processor specific section, based upon a matching input section.
1402 Returns TRUE upon success, FALSE otherwise. */
1405 copy_special_section_fields (const bfd
*ibfd
,
1407 const Elf_Internal_Shdr
*iheader
,
1408 Elf_Internal_Shdr
*oheader
,
1409 const unsigned int secnum
)
1411 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1412 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1413 bfd_boolean changed
= FALSE
;
1414 unsigned int sh_link
;
1416 if (oheader
->sh_type
== SHT_NOBITS
)
1418 /* This is a feature for objcopy --only-keep-debug:
1419 When a section's type is changed to NOBITS, we preserve
1420 the sh_link and sh_info fields so that they can be
1421 matched up with the original.
1423 Note: Strictly speaking these assignments are wrong.
1424 The sh_link and sh_info fields should point to the
1425 relevent sections in the output BFD, which may not be in
1426 the same location as they were in the input BFD. But
1427 the whole point of this action is to preserve the
1428 original values of the sh_link and sh_info fields, so
1429 that they can be matched up with the section headers in
1430 the original file. So strictly speaking we may be
1431 creating an invalid ELF file, but it is only for a file
1432 that just contains debug info and only for sections
1433 without any contents. */
1434 if (oheader
->sh_link
== 0)
1435 oheader
->sh_link
= iheader
->sh_link
;
1436 if (oheader
->sh_info
== 0)
1437 oheader
->sh_info
= iheader
->sh_info
;
1441 /* Allow the target a chance to decide how these fields should be set. */
1442 if (bed
->elf_backend_copy_special_section_fields
!= NULL
1443 && bed
->elf_backend_copy_special_section_fields
1444 (ibfd
, obfd
, iheader
, oheader
))
1447 /* We have an iheader which might match oheader, and which has non-zero
1448 sh_info and/or sh_link fields. Attempt to follow those links and find
1449 the section in the output bfd which corresponds to the linked section
1450 in the input bfd. */
1451 if (iheader
->sh_link
!= SHN_UNDEF
)
1453 /* See PR 20931 for a reproducer. */
1454 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1457 /* xgettext:c-format */
1458 (_("%pB: invalid sh_link field (%d) in section number %d"),
1459 ibfd
, iheader
->sh_link
, secnum
);
1463 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1464 if (sh_link
!= SHN_UNDEF
)
1466 oheader
->sh_link
= sh_link
;
1470 /* FIXME: Should we install iheader->sh_link
1471 if we could not find a match ? */
1473 /* xgettext:c-format */
1474 (_("%pB: failed to find link section for section %d"), obfd
, secnum
);
1477 if (iheader
->sh_info
)
1479 /* The sh_info field can hold arbitrary information, but if the
1480 SHF_LINK_INFO flag is set then it should be interpreted as a
1482 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1484 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1486 if (sh_link
!= SHN_UNDEF
)
1487 oheader
->sh_flags
|= SHF_INFO_LINK
;
1490 /* No idea what it means - just copy it. */
1491 sh_link
= iheader
->sh_info
;
1493 if (sh_link
!= SHN_UNDEF
)
1495 oheader
->sh_info
= sh_link
;
1500 /* xgettext:c-format */
1501 (_("%pB: failed to find info section for section %d"), obfd
, secnum
);
1507 /* Copy the program header and other data from one object module to
1511 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1513 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1514 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1515 const struct elf_backend_data
*bed
;
1518 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1519 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1522 if (!elf_flags_init (obfd
))
1524 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1525 elf_flags_init (obfd
) = TRUE
;
1528 elf_gp (obfd
) = elf_gp (ibfd
);
1530 /* Also copy the EI_OSABI field. */
1531 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1532 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1534 /* If set, copy the EI_ABIVERSION field. */
1535 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1536 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1537 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1539 /* Copy object attributes. */
1540 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1542 if (iheaders
== NULL
|| oheaders
== NULL
)
1545 bed
= get_elf_backend_data (obfd
);
1547 /* Possibly copy other fields in the section header. */
1548 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1551 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1553 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1554 because of a special case need for generating separate debug info
1555 files. See below for more details. */
1557 || (oheader
->sh_type
!= SHT_NOBITS
1558 && oheader
->sh_type
< SHT_LOOS
))
1561 /* Ignore empty sections, and sections whose
1562 fields have already been initialised. */
1563 if (oheader
->sh_size
== 0
1564 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1567 /* Scan for the matching section in the input bfd.
1568 First we try for a direct mapping between the input and output sections. */
1569 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1571 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1573 if (iheader
== NULL
)
1576 if (oheader
->bfd_section
!= NULL
1577 && iheader
->bfd_section
!= NULL
1578 && iheader
->bfd_section
->output_section
!= NULL
1579 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1581 /* We have found a connection from the input section to the
1582 output section. Attempt to copy the header fields. If
1583 this fails then do not try any further sections - there
1584 should only be a one-to-one mapping between input and output. */
1585 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1586 j
= elf_numsections (ibfd
);
1591 if (j
< elf_numsections (ibfd
))
1594 /* That failed. So try to deduce the corresponding input section.
1595 Unfortunately we cannot compare names as the output string table
1596 is empty, so instead we check size, address and type. */
1597 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1599 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1601 if (iheader
== NULL
)
1604 /* Try matching fields in the input section's header.
1605 Since --only-keep-debug turns all non-debug sections into
1606 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1608 if ((oheader
->sh_type
== SHT_NOBITS
1609 || iheader
->sh_type
== oheader
->sh_type
)
1610 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1611 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1612 && iheader
->sh_addralign
== oheader
->sh_addralign
1613 && iheader
->sh_entsize
== oheader
->sh_entsize
1614 && iheader
->sh_size
== oheader
->sh_size
1615 && iheader
->sh_addr
== oheader
->sh_addr
1616 && (iheader
->sh_info
!= oheader
->sh_info
1617 || iheader
->sh_link
!= oheader
->sh_link
))
1619 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1624 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1626 /* Final attempt. Call the backend copy function
1627 with a NULL input section. */
1628 if (bed
->elf_backend_copy_special_section_fields
!= NULL
)
1629 bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
, NULL
, oheader
);
1637 get_segment_type (unsigned int p_type
)
1642 case PT_NULL
: pt
= "NULL"; break;
1643 case PT_LOAD
: pt
= "LOAD"; break;
1644 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1645 case PT_INTERP
: pt
= "INTERP"; break;
1646 case PT_NOTE
: pt
= "NOTE"; break;
1647 case PT_SHLIB
: pt
= "SHLIB"; break;
1648 case PT_PHDR
: pt
= "PHDR"; break;
1649 case PT_TLS
: pt
= "TLS"; break;
1650 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1651 case PT_GNU_STACK
: pt
= "STACK"; break;
1652 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1653 default: pt
= NULL
; break;
1658 /* Print out the program headers. */
1661 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1663 FILE *f
= (FILE *) farg
;
1664 Elf_Internal_Phdr
*p
;
1666 bfd_byte
*dynbuf
= NULL
;
1668 p
= elf_tdata (abfd
)->phdr
;
1673 fprintf (f
, _("\nProgram Header:\n"));
1674 c
= elf_elfheader (abfd
)->e_phnum
;
1675 for (i
= 0; i
< c
; i
++, p
++)
1677 const char *pt
= get_segment_type (p
->p_type
);
1682 sprintf (buf
, "0x%lx", p
->p_type
);
1685 fprintf (f
, "%8s off 0x", pt
);
1686 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1687 fprintf (f
, " vaddr 0x");
1688 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1689 fprintf (f
, " paddr 0x");
1690 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1691 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1692 fprintf (f
, " filesz 0x");
1693 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1694 fprintf (f
, " memsz 0x");
1695 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1696 fprintf (f
, " flags %c%c%c",
1697 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1698 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1699 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1700 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1701 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1706 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1709 unsigned int elfsec
;
1710 unsigned long shlink
;
1711 bfd_byte
*extdyn
, *extdynend
;
1713 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1715 fprintf (f
, _("\nDynamic Section:\n"));
1717 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1720 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1721 if (elfsec
== SHN_BAD
)
1723 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1725 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1726 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1729 /* PR 17512: file: 6f427532. */
1730 if (s
->size
< extdynsize
)
1732 extdynend
= extdyn
+ s
->size
;
1733 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1735 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1737 Elf_Internal_Dyn dyn
;
1738 const char *name
= "";
1740 bfd_boolean stringp
;
1741 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1743 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1745 if (dyn
.d_tag
== DT_NULL
)
1752 if (bed
->elf_backend_get_target_dtag
)
1753 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1755 if (!strcmp (name
, ""))
1757 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1762 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1763 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1764 case DT_PLTGOT
: name
= "PLTGOT"; break;
1765 case DT_HASH
: name
= "HASH"; break;
1766 case DT_STRTAB
: name
= "STRTAB"; break;
1767 case DT_SYMTAB
: name
= "SYMTAB"; break;
1768 case DT_RELA
: name
= "RELA"; break;
1769 case DT_RELASZ
: name
= "RELASZ"; break;
1770 case DT_RELAENT
: name
= "RELAENT"; break;
1771 case DT_STRSZ
: name
= "STRSZ"; break;
1772 case DT_SYMENT
: name
= "SYMENT"; break;
1773 case DT_INIT
: name
= "INIT"; break;
1774 case DT_FINI
: name
= "FINI"; break;
1775 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1776 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1777 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1778 case DT_REL
: name
= "REL"; break;
1779 case DT_RELSZ
: name
= "RELSZ"; break;
1780 case DT_RELENT
: name
= "RELENT"; break;
1781 case DT_PLTREL
: name
= "PLTREL"; break;
1782 case DT_DEBUG
: name
= "DEBUG"; break;
1783 case DT_TEXTREL
: name
= "TEXTREL"; break;
1784 case DT_JMPREL
: name
= "JMPREL"; break;
1785 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1786 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1787 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1788 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1789 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1790 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1791 case DT_FLAGS
: name
= "FLAGS"; break;
1792 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1793 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1794 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1795 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1796 case DT_MOVEENT
: name
= "MOVEENT"; break;
1797 case DT_MOVESZ
: name
= "MOVESZ"; break;
1798 case DT_FEATURE
: name
= "FEATURE"; break;
1799 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1800 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1801 case DT_SYMINENT
: name
= "SYMINENT"; break;
1802 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1803 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1804 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1805 case DT_PLTPAD
: name
= "PLTPAD"; break;
1806 case DT_MOVETAB
: name
= "MOVETAB"; break;
1807 case DT_SYMINFO
: name
= "SYMINFO"; break;
1808 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1809 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1810 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1811 case DT_VERSYM
: name
= "VERSYM"; break;
1812 case DT_VERDEF
: name
= "VERDEF"; break;
1813 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1814 case DT_VERNEED
: name
= "VERNEED"; break;
1815 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1816 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1817 case DT_USED
: name
= "USED"; break;
1818 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1819 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1822 fprintf (f
, " %-20s ", name
);
1826 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1831 unsigned int tagv
= dyn
.d_un
.d_val
;
1833 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1836 fprintf (f
, "%s", string
);
1845 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1846 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1848 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1852 if (elf_dynverdef (abfd
) != 0)
1854 Elf_Internal_Verdef
*t
;
1856 fprintf (f
, _("\nVersion definitions:\n"));
1857 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1859 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1860 t
->vd_flags
, t
->vd_hash
,
1861 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1862 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1864 Elf_Internal_Verdaux
*a
;
1867 for (a
= t
->vd_auxptr
->vda_nextptr
;
1871 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1877 if (elf_dynverref (abfd
) != 0)
1879 Elf_Internal_Verneed
*t
;
1881 fprintf (f
, _("\nVersion References:\n"));
1882 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1884 Elf_Internal_Vernaux
*a
;
1886 fprintf (f
, _(" required from %s:\n"),
1887 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1888 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1889 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1890 a
->vna_flags
, a
->vna_other
,
1891 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1903 /* Get version string. */
1906 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1907 bfd_boolean
*hidden
)
1909 const char *version_string
= NULL
;
1910 if (elf_dynversym (abfd
) != 0
1911 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1913 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1915 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1916 vernum
&= VERSYM_VERSION
;
1919 version_string
= "";
1920 else if (vernum
== 1
1921 && (vernum
> elf_tdata (abfd
)->cverdefs
1922 || (elf_tdata (abfd
)->verdef
[0].vd_flags
1924 version_string
= "Base";
1925 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1927 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1930 Elf_Internal_Verneed
*t
;
1932 version_string
= _("<corrupt>");
1933 for (t
= elf_tdata (abfd
)->verref
;
1937 Elf_Internal_Vernaux
*a
;
1939 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1941 if (a
->vna_other
== vernum
)
1943 version_string
= a
->vna_nodename
;
1950 return version_string
;
1953 /* Display ELF-specific fields of a symbol. */
1956 bfd_elf_print_symbol (bfd
*abfd
,
1959 bfd_print_symbol_type how
)
1961 FILE *file
= (FILE *) filep
;
1964 case bfd_print_symbol_name
:
1965 fprintf (file
, "%s", symbol
->name
);
1967 case bfd_print_symbol_more
:
1968 fprintf (file
, "elf ");
1969 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1970 fprintf (file
, " %x", symbol
->flags
);
1972 case bfd_print_symbol_all
:
1974 const char *section_name
;
1975 const char *name
= NULL
;
1976 const struct elf_backend_data
*bed
;
1977 unsigned char st_other
;
1979 const char *version_string
;
1982 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1984 bed
= get_elf_backend_data (abfd
);
1985 if (bed
->elf_backend_print_symbol_all
)
1986 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1990 name
= symbol
->name
;
1991 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1994 fprintf (file
, " %s\t", section_name
);
1995 /* Print the "other" value for a symbol. For common symbols,
1996 we've already printed the size; now print the alignment.
1997 For other symbols, we have no specified alignment, and
1998 we've printed the address; now print the size. */
1999 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
2000 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
2002 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
2003 bfd_fprintf_vma (abfd
, file
, val
);
2005 /* If we have version information, print it. */
2006 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
2012 fprintf (file
, " %-11s", version_string
);
2017 fprintf (file
, " (%s)", version_string
);
2018 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
2023 /* If the st_other field is not zero, print it. */
2024 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
2029 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
2030 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
2031 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
2033 /* Some other non-defined flags are also present, so print
2035 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
2038 fprintf (file
, " %s", name
);
2044 /* ELF .o/exec file reading */
2046 /* Create a new bfd section from an ELF section header. */
2049 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
2051 Elf_Internal_Shdr
*hdr
;
2052 Elf_Internal_Ehdr
*ehdr
;
2053 const struct elf_backend_data
*bed
;
2055 bfd_boolean ret
= TRUE
;
2056 static bfd_boolean
* sections_being_created
= NULL
;
2057 static bfd
* sections_being_created_abfd
= NULL
;
2058 static unsigned int nesting
= 0;
2060 if (shindex
>= elf_numsections (abfd
))
2065 /* PR17512: A corrupt ELF binary might contain a recursive group of
2066 sections, with each the string indices pointing to the next in the
2067 loop. Detect this here, by refusing to load a section that we are
2068 already in the process of loading. We only trigger this test if
2069 we have nested at least three sections deep as normal ELF binaries
2070 can expect to recurse at least once.
2072 FIXME: It would be better if this array was attached to the bfd,
2073 rather than being held in a static pointer. */
2075 if (sections_being_created_abfd
!= abfd
)
2076 sections_being_created
= NULL
;
2077 if (sections_being_created
== NULL
)
2079 sections_being_created
= (bfd_boolean
*)
2080 bfd_zalloc2 (abfd
, elf_numsections (abfd
), sizeof (bfd_boolean
));
2081 sections_being_created_abfd
= abfd
;
2083 if (sections_being_created
[shindex
])
2086 (_("%pB: warning: loop in section dependencies detected"), abfd
);
2089 sections_being_created
[shindex
] = TRUE
;
2092 hdr
= elf_elfsections (abfd
)[shindex
];
2093 ehdr
= elf_elfheader (abfd
);
2094 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2099 bed
= get_elf_backend_data (abfd
);
2100 switch (hdr
->sh_type
)
2103 /* Inactive section. Throw it away. */
2106 case SHT_PROGBITS
: /* Normal section with contents. */
2107 case SHT_NOBITS
: /* .bss section. */
2108 case SHT_HASH
: /* .hash section. */
2109 case SHT_NOTE
: /* .note section. */
2110 case SHT_INIT_ARRAY
: /* .init_array section. */
2111 case SHT_FINI_ARRAY
: /* .fini_array section. */
2112 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2113 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2114 case SHT_GNU_HASH
: /* .gnu.hash section. */
2115 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2118 case SHT_DYNAMIC
: /* Dynamic linking information. */
2119 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2122 if (hdr
->sh_link
> elf_numsections (abfd
))
2124 /* PR 10478: Accept Solaris binaries with a sh_link
2125 field set to SHN_BEFORE or SHN_AFTER. */
2126 switch (bfd_get_arch (abfd
))
2129 case bfd_arch_sparc
:
2130 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2131 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2133 /* Otherwise fall through. */
2138 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2140 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2142 Elf_Internal_Shdr
*dynsymhdr
;
2144 /* The shared libraries distributed with hpux11 have a bogus
2145 sh_link field for the ".dynamic" section. Find the
2146 string table for the ".dynsym" section instead. */
2147 if (elf_dynsymtab (abfd
) != 0)
2149 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2150 hdr
->sh_link
= dynsymhdr
->sh_link
;
2154 unsigned int i
, num_sec
;
2156 num_sec
= elf_numsections (abfd
);
2157 for (i
= 1; i
< num_sec
; i
++)
2159 dynsymhdr
= elf_elfsections (abfd
)[i
];
2160 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2162 hdr
->sh_link
= dynsymhdr
->sh_link
;
2170 case SHT_SYMTAB
: /* A symbol table. */
2171 if (elf_onesymtab (abfd
) == shindex
)
2174 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2177 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2179 if (hdr
->sh_size
!= 0)
2181 /* Some assemblers erroneously set sh_info to one with a
2182 zero sh_size. ld sees this as a global symbol count
2183 of (unsigned) -1. Fix it here. */
2188 /* PR 18854: A binary might contain more than one symbol table.
2189 Unusual, but possible. Warn, but continue. */
2190 if (elf_onesymtab (abfd
) != 0)
2193 /* xgettext:c-format */
2194 (_("%pB: warning: multiple symbol tables detected"
2195 " - ignoring the table in section %u"),
2199 elf_onesymtab (abfd
) = shindex
;
2200 elf_symtab_hdr (abfd
) = *hdr
;
2201 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2202 abfd
->flags
|= HAS_SYMS
;
2204 /* Sometimes a shared object will map in the symbol table. If
2205 SHF_ALLOC is set, and this is a shared object, then we also
2206 treat this section as a BFD section. We can not base the
2207 decision purely on SHF_ALLOC, because that flag is sometimes
2208 set in a relocatable object file, which would confuse the
2210 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2211 && (abfd
->flags
& DYNAMIC
) != 0
2212 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2216 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2217 can't read symbols without that section loaded as well. It
2218 is most likely specified by the next section header. */
2220 elf_section_list
* entry
;
2221 unsigned int i
, num_sec
;
2223 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2224 if (entry
->hdr
.sh_link
== shindex
)
2227 num_sec
= elf_numsections (abfd
);
2228 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2230 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2232 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2233 && hdr2
->sh_link
== shindex
)
2238 for (i
= 1; i
< shindex
; i
++)
2240 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2242 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2243 && hdr2
->sh_link
== shindex
)
2248 ret
= bfd_section_from_shdr (abfd
, i
);
2249 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2253 case SHT_DYNSYM
: /* A dynamic symbol table. */
2254 if (elf_dynsymtab (abfd
) == shindex
)
2257 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2260 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2262 if (hdr
->sh_size
!= 0)
2265 /* Some linkers erroneously set sh_info to one with a
2266 zero sh_size. ld sees this as a global symbol count
2267 of (unsigned) -1. Fix it here. */
2272 /* PR 18854: A binary might contain more than one dynamic symbol table.
2273 Unusual, but possible. Warn, but continue. */
2274 if (elf_dynsymtab (abfd
) != 0)
2277 /* xgettext:c-format */
2278 (_("%pB: warning: multiple dynamic symbol tables detected"
2279 " - ignoring the table in section %u"),
2283 elf_dynsymtab (abfd
) = shindex
;
2284 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2285 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2286 abfd
->flags
|= HAS_SYMS
;
2288 /* Besides being a symbol table, we also treat this as a regular
2289 section, so that objcopy can handle it. */
2290 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2293 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2295 elf_section_list
* entry
;
2297 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2298 if (entry
->ndx
== shindex
)
2301 entry
= bfd_alloc (abfd
, sizeof (*entry
));
2304 entry
->ndx
= shindex
;
2306 entry
->next
= elf_symtab_shndx_list (abfd
);
2307 elf_symtab_shndx_list (abfd
) = entry
;
2308 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2312 case SHT_STRTAB
: /* A string table. */
2313 if (hdr
->bfd_section
!= NULL
)
2316 if (ehdr
->e_shstrndx
== shindex
)
2318 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2319 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2323 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2326 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2327 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2331 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2334 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2335 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2336 elf_elfsections (abfd
)[shindex
] = hdr
;
2337 /* We also treat this as a regular section, so that objcopy
2339 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2344 /* If the string table isn't one of the above, then treat it as a
2345 regular section. We need to scan all the headers to be sure,
2346 just in case this strtab section appeared before the above. */
2347 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2349 unsigned int i
, num_sec
;
2351 num_sec
= elf_numsections (abfd
);
2352 for (i
= 1; i
< num_sec
; i
++)
2354 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2355 if (hdr2
->sh_link
== shindex
)
2357 /* Prevent endless recursion on broken objects. */
2360 if (! bfd_section_from_shdr (abfd
, i
))
2362 if (elf_onesymtab (abfd
) == i
)
2364 if (elf_dynsymtab (abfd
) == i
)
2365 goto dynsymtab_strtab
;
2369 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2374 /* *These* do a lot of work -- but build no sections! */
2376 asection
*target_sect
;
2377 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2378 unsigned int num_sec
= elf_numsections (abfd
);
2379 struct bfd_elf_section_data
*esdt
;
2382 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2383 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2386 /* Check for a bogus link to avoid crashing. */
2387 if (hdr
->sh_link
>= num_sec
)
2390 /* xgettext:c-format */
2391 (_("%pB: invalid link %u for reloc section %s (index %u)"),
2392 abfd
, hdr
->sh_link
, name
, shindex
);
2393 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2398 /* For some incomprehensible reason Oracle distributes
2399 libraries for Solaris in which some of the objects have
2400 bogus sh_link fields. It would be nice if we could just
2401 reject them, but, unfortunately, some people need to use
2402 them. We scan through the section headers; if we find only
2403 one suitable symbol table, we clobber the sh_link to point
2404 to it. I hope this doesn't break anything.
2406 Don't do it on executable nor shared library. */
2407 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2408 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2409 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2415 for (scan
= 1; scan
< num_sec
; scan
++)
2417 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2418 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2429 hdr
->sh_link
= found
;
2432 /* Get the symbol table. */
2433 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2434 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2435 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2438 /* If this is an alloc section in an executable or shared
2439 library, or the reloc section does not use the main symbol
2440 table we don't treat it as a reloc section. BFD can't
2441 adequately represent such a section, so at least for now,
2442 we don't try. We just present it as a normal section. We
2443 also can't use it as a reloc section if it points to the
2444 null section, an invalid section, another reloc section, or
2445 its sh_link points to the null section. */
2446 if (((abfd
->flags
& (DYNAMIC
| EXEC_P
)) != 0
2447 && (hdr
->sh_flags
& SHF_ALLOC
) != 0)
2448 || hdr
->sh_link
== SHN_UNDEF
2449 || hdr
->sh_link
!= elf_onesymtab (abfd
)
2450 || hdr
->sh_info
== SHN_UNDEF
2451 || hdr
->sh_info
>= num_sec
2452 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2453 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2455 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2460 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2463 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2464 if (target_sect
== NULL
)
2467 esdt
= elf_section_data (target_sect
);
2468 if (hdr
->sh_type
== SHT_RELA
)
2469 p_hdr
= &esdt
->rela
.hdr
;
2471 p_hdr
= &esdt
->rel
.hdr
;
2473 /* PR 17512: file: 0b4f81b7.
2474 Also see PR 24456, for a file which deliberately has two reloc
2479 /* xgettext:c-format */
2480 (_("%pB: warning: multiple relocation sections for section %pA \
2481 found - ignoring all but the first"),
2485 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2490 elf_elfsections (abfd
)[shindex
] = hdr2
;
2491 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2492 * bed
->s
->int_rels_per_ext_rel
);
2493 target_sect
->flags
|= SEC_RELOC
;
2494 target_sect
->relocation
= NULL
;
2495 target_sect
->rel_filepos
= hdr
->sh_offset
;
2496 /* In the section to which the relocations apply, mark whether
2497 its relocations are of the REL or RELA variety. */
2498 if (hdr
->sh_size
!= 0)
2500 if (hdr
->sh_type
== SHT_RELA
)
2501 target_sect
->use_rela_p
= 1;
2503 abfd
->flags
|= HAS_RELOC
;
2507 case SHT_GNU_verdef
:
2508 elf_dynverdef (abfd
) = shindex
;
2509 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2510 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2513 case SHT_GNU_versym
:
2514 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2517 elf_dynversym (abfd
) = shindex
;
2518 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2519 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2522 case SHT_GNU_verneed
:
2523 elf_dynverref (abfd
) = shindex
;
2524 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2525 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2532 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2535 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2541 /* Possibly an attributes section. */
2542 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2543 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2545 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2547 _bfd_elf_parse_attributes (abfd
, hdr
);
2551 /* Check for any processor-specific section types. */
2552 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2555 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2557 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2558 /* FIXME: How to properly handle allocated section reserved
2559 for applications? */
2561 /* xgettext:c-format */
2562 (_("%pB: unknown type [%#x] section `%s'"),
2563 abfd
, hdr
->sh_type
, name
);
2566 /* Allow sections reserved for applications. */
2567 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2572 else if (hdr
->sh_type
>= SHT_LOPROC
2573 && hdr
->sh_type
<= SHT_HIPROC
)
2574 /* FIXME: We should handle this section. */
2576 /* xgettext:c-format */
2577 (_("%pB: unknown type [%#x] section `%s'"),
2578 abfd
, hdr
->sh_type
, name
);
2579 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2581 /* Unrecognised OS-specific sections. */
2582 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2583 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2584 required to correctly process the section and the file should
2585 be rejected with an error message. */
2587 /* xgettext:c-format */
2588 (_("%pB: unknown type [%#x] section `%s'"),
2589 abfd
, hdr
->sh_type
, name
);
2592 /* Otherwise it should be processed. */
2593 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2598 /* FIXME: We should handle this section. */
2600 /* xgettext:c-format */
2601 (_("%pB: unknown type [%#x] section `%s'"),
2602 abfd
, hdr
->sh_type
, name
);
2610 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2611 sections_being_created
[shindex
] = FALSE
;
2612 if (-- nesting
== 0)
2614 sections_being_created
= NULL
;
2615 sections_being_created_abfd
= abfd
;
2620 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2623 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2625 unsigned long r_symndx
)
2627 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2629 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2631 Elf_Internal_Shdr
*symtab_hdr
;
2632 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2633 Elf_External_Sym_Shndx eshndx
;
2635 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2636 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2637 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2640 if (cache
->abfd
!= abfd
)
2642 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2645 cache
->indx
[ent
] = r_symndx
;
2648 return &cache
->sym
[ent
];
2651 /* Given an ELF section number, retrieve the corresponding BFD
2655 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2657 if (sec_index
>= elf_numsections (abfd
))
2659 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2662 static const struct bfd_elf_special_section special_sections_b
[] =
2664 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2665 { NULL
, 0, 0, 0, 0 }
2668 static const struct bfd_elf_special_section special_sections_c
[] =
2670 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2671 { STRING_COMMA_LEN (".ctf"), 0, SHT_PROGBITS
, 0 },
2672 { NULL
, 0, 0, 0, 0 }
2675 static const struct bfd_elf_special_section special_sections_d
[] =
2677 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2678 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2679 /* There are more DWARF sections than these, but they needn't be added here
2680 unless you have to cope with broken compilers that don't emit section
2681 attributes or you want to help the user writing assembler. */
2682 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2683 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2684 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2685 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2686 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2687 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2688 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2689 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2690 { NULL
, 0, 0, 0, 0 }
2693 static const struct bfd_elf_special_section special_sections_f
[] =
2695 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2696 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2697 { NULL
, 0 , 0, 0, 0 }
2700 static const struct bfd_elf_special_section special_sections_g
[] =
2702 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2703 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2704 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2705 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2706 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2707 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2708 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2709 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2710 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2711 { NULL
, 0, 0, 0, 0 }
2714 static const struct bfd_elf_special_section special_sections_h
[] =
2716 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2717 { NULL
, 0, 0, 0, 0 }
2720 static const struct bfd_elf_special_section special_sections_i
[] =
2722 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2723 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2724 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2725 { NULL
, 0, 0, 0, 0 }
2728 static const struct bfd_elf_special_section special_sections_l
[] =
2730 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2731 { NULL
, 0, 0, 0, 0 }
2734 static const struct bfd_elf_special_section special_sections_n
[] =
2736 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2737 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2738 { NULL
, 0, 0, 0, 0 }
2741 static const struct bfd_elf_special_section special_sections_p
[] =
2743 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2744 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2745 { NULL
, 0, 0, 0, 0 }
2748 static const struct bfd_elf_special_section special_sections_r
[] =
2750 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2751 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2752 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2753 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2754 { NULL
, 0, 0, 0, 0 }
2757 static const struct bfd_elf_special_section special_sections_s
[] =
2759 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2760 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2761 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2762 /* See struct bfd_elf_special_section declaration for the semantics of
2763 this special case where .prefix_length != strlen (.prefix). */
2764 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2765 { NULL
, 0, 0, 0, 0 }
2768 static const struct bfd_elf_special_section special_sections_t
[] =
2770 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2771 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2772 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2773 { NULL
, 0, 0, 0, 0 }
2776 static const struct bfd_elf_special_section special_sections_z
[] =
2778 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2779 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2780 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2781 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2782 { NULL
, 0, 0, 0, 0 }
2785 static const struct bfd_elf_special_section
* const special_sections
[] =
2787 special_sections_b
, /* 'b' */
2788 special_sections_c
, /* 'c' */
2789 special_sections_d
, /* 'd' */
2791 special_sections_f
, /* 'f' */
2792 special_sections_g
, /* 'g' */
2793 special_sections_h
, /* 'h' */
2794 special_sections_i
, /* 'i' */
2797 special_sections_l
, /* 'l' */
2799 special_sections_n
, /* 'n' */
2801 special_sections_p
, /* 'p' */
2803 special_sections_r
, /* 'r' */
2804 special_sections_s
, /* 's' */
2805 special_sections_t
, /* 't' */
2811 special_sections_z
/* 'z' */
2814 const struct bfd_elf_special_section
*
2815 _bfd_elf_get_special_section (const char *name
,
2816 const struct bfd_elf_special_section
*spec
,
2822 len
= strlen (name
);
2824 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2827 int prefix_len
= spec
[i
].prefix_length
;
2829 if (len
< prefix_len
)
2831 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2834 suffix_len
= spec
[i
].suffix_length
;
2835 if (suffix_len
<= 0)
2837 if (name
[prefix_len
] != 0)
2839 if (suffix_len
== 0)
2841 if (name
[prefix_len
] != '.'
2842 && (suffix_len
== -2
2843 || (rela
&& spec
[i
].type
== SHT_REL
)))
2849 if (len
< prefix_len
+ suffix_len
)
2851 if (memcmp (name
+ len
- suffix_len
,
2852 spec
[i
].prefix
+ prefix_len
,
2862 const struct bfd_elf_special_section
*
2863 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2866 const struct bfd_elf_special_section
*spec
;
2867 const struct elf_backend_data
*bed
;
2869 /* See if this is one of the special sections. */
2870 if (sec
->name
== NULL
)
2873 bed
= get_elf_backend_data (abfd
);
2874 spec
= bed
->special_sections
;
2877 spec
= _bfd_elf_get_special_section (sec
->name
,
2878 bed
->special_sections
,
2884 if (sec
->name
[0] != '.')
2887 i
= sec
->name
[1] - 'b';
2888 if (i
< 0 || i
> 'z' - 'b')
2891 spec
= special_sections
[i
];
2896 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2900 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2902 struct bfd_elf_section_data
*sdata
;
2903 const struct elf_backend_data
*bed
;
2904 const struct bfd_elf_special_section
*ssect
;
2906 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2909 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2913 sec
->used_by_bfd
= sdata
;
2916 /* Indicate whether or not this section should use RELA relocations. */
2917 bed
= get_elf_backend_data (abfd
);
2918 sec
->use_rela_p
= bed
->default_use_rela_p
;
2920 /* When we read a file, we don't need to set ELF section type and
2921 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2922 anyway. We will set ELF section type and flags for all linker
2923 created sections. If user specifies BFD section flags, we will
2924 set ELF section type and flags based on BFD section flags in
2925 elf_fake_sections. Special handling for .init_array/.fini_array
2926 output sections since they may contain .ctors/.dtors input
2927 sections. We don't want _bfd_elf_init_private_section_data to
2928 copy ELF section type from .ctors/.dtors input sections. */
2929 if (abfd
->direction
!= read_direction
2930 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2932 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2935 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2936 || ssect
->type
== SHT_INIT_ARRAY
2937 || ssect
->type
== SHT_FINI_ARRAY
))
2939 elf_section_type (sec
) = ssect
->type
;
2940 elf_section_flags (sec
) = ssect
->attr
;
2944 return _bfd_generic_new_section_hook (abfd
, sec
);
2947 /* Create a new bfd section from an ELF program header.
2949 Since program segments have no names, we generate a synthetic name
2950 of the form segment<NUM>, where NUM is generally the index in the
2951 program header table. For segments that are split (see below) we
2952 generate the names segment<NUM>a and segment<NUM>b.
2954 Note that some program segments may have a file size that is different than
2955 (less than) the memory size. All this means is that at execution the
2956 system must allocate the amount of memory specified by the memory size,
2957 but only initialize it with the first "file size" bytes read from the
2958 file. This would occur for example, with program segments consisting
2959 of combined data+bss.
2961 To handle the above situation, this routine generates TWO bfd sections
2962 for the single program segment. The first has the length specified by
2963 the file size of the segment, and the second has the length specified
2964 by the difference between the two sizes. In effect, the segment is split
2965 into its initialized and uninitialized parts.
2970 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2971 Elf_Internal_Phdr
*hdr
,
2973 const char *type_name
)
2981 split
= ((hdr
->p_memsz
> 0)
2982 && (hdr
->p_filesz
> 0)
2983 && (hdr
->p_memsz
> hdr
->p_filesz
));
2985 if (hdr
->p_filesz
> 0)
2987 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2988 len
= strlen (namebuf
) + 1;
2989 name
= (char *) bfd_alloc (abfd
, len
);
2992 memcpy (name
, namebuf
, len
);
2993 newsect
= bfd_make_section (abfd
, name
);
2994 if (newsect
== NULL
)
2996 newsect
->vma
= hdr
->p_vaddr
;
2997 newsect
->lma
= hdr
->p_paddr
;
2998 newsect
->size
= hdr
->p_filesz
;
2999 newsect
->filepos
= hdr
->p_offset
;
3000 newsect
->flags
|= SEC_HAS_CONTENTS
;
3001 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
3002 if (hdr
->p_type
== PT_LOAD
)
3004 newsect
->flags
|= SEC_ALLOC
;
3005 newsect
->flags
|= SEC_LOAD
;
3006 if (hdr
->p_flags
& PF_X
)
3008 /* FIXME: all we known is that it has execute PERMISSION,
3010 newsect
->flags
|= SEC_CODE
;
3013 if (!(hdr
->p_flags
& PF_W
))
3015 newsect
->flags
|= SEC_READONLY
;
3019 if (hdr
->p_memsz
> hdr
->p_filesz
)
3023 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
3024 len
= strlen (namebuf
) + 1;
3025 name
= (char *) bfd_alloc (abfd
, len
);
3028 memcpy (name
, namebuf
, len
);
3029 newsect
= bfd_make_section (abfd
, name
);
3030 if (newsect
== NULL
)
3032 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
3033 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
3034 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
3035 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
3036 align
= newsect
->vma
& -newsect
->vma
;
3037 if (align
== 0 || align
> hdr
->p_align
)
3038 align
= hdr
->p_align
;
3039 newsect
->alignment_power
= bfd_log2 (align
);
3040 if (hdr
->p_type
== PT_LOAD
)
3042 /* Hack for gdb. Segments that have not been modified do
3043 not have their contents written to a core file, on the
3044 assumption that a debugger can find the contents in the
3045 executable. We flag this case by setting the fake
3046 section size to zero. Note that "real" bss sections will
3047 always have their contents dumped to the core file. */
3048 if (bfd_get_format (abfd
) == bfd_core
)
3050 newsect
->flags
|= SEC_ALLOC
;
3051 if (hdr
->p_flags
& PF_X
)
3052 newsect
->flags
|= SEC_CODE
;
3054 if (!(hdr
->p_flags
& PF_W
))
3055 newsect
->flags
|= SEC_READONLY
;
3062 _bfd_elf_core_find_build_id (bfd
*templ
, bfd_vma offset
)
3064 /* The return value is ignored. Build-ids are considered optional. */
3065 if (templ
->xvec
->flavour
== bfd_target_elf_flavour
)
3066 return (*get_elf_backend_data (templ
)->elf_backend_core_find_build_id
)
3072 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
3074 const struct elf_backend_data
*bed
;
3076 switch (hdr
->p_type
)
3079 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
3082 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load"))
3084 if (bfd_get_format (abfd
) == bfd_core
&& abfd
->build_id
== NULL
)
3085 _bfd_elf_core_find_build_id (abfd
, hdr
->p_offset
);
3089 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
3092 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
3095 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3097 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3103 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3106 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3108 case PT_GNU_EH_FRAME
:
3109 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3113 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3116 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3119 /* Check for any processor-specific program segment types. */
3120 bed
= get_elf_backend_data (abfd
);
3121 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3125 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3129 _bfd_elf_single_rel_hdr (asection
*sec
)
3131 if (elf_section_data (sec
)->rel
.hdr
)
3133 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3134 return elf_section_data (sec
)->rel
.hdr
;
3137 return elf_section_data (sec
)->rela
.hdr
;
3141 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3142 Elf_Internal_Shdr
*rel_hdr
,
3143 const char *sec_name
,
3144 bfd_boolean use_rela_p
)
3146 char *name
= (char *) bfd_alloc (abfd
,
3147 sizeof ".rela" + strlen (sec_name
));
3151 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3153 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3155 if (rel_hdr
->sh_name
== (unsigned int) -1)
3161 /* Allocate and initialize a section-header for a new reloc section,
3162 containing relocations against ASECT. It is stored in RELDATA. If
3163 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3167 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3168 struct bfd_elf_section_reloc_data
*reldata
,
3169 const char *sec_name
,
3170 bfd_boolean use_rela_p
,
3171 bfd_boolean delay_st_name_p
)
3173 Elf_Internal_Shdr
*rel_hdr
;
3174 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3176 BFD_ASSERT (reldata
->hdr
== NULL
);
3177 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3178 reldata
->hdr
= rel_hdr
;
3180 if (delay_st_name_p
)
3181 rel_hdr
->sh_name
= (unsigned int) -1;
3182 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3185 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3186 rel_hdr
->sh_entsize
= (use_rela_p
3187 ? bed
->s
->sizeof_rela
3188 : bed
->s
->sizeof_rel
);
3189 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3190 rel_hdr
->sh_flags
= 0;
3191 rel_hdr
->sh_addr
= 0;
3192 rel_hdr
->sh_size
= 0;
3193 rel_hdr
->sh_offset
= 0;
3198 /* Return the default section type based on the passed in section flags. */
3201 bfd_elf_get_default_section_type (flagword flags
)
3203 if ((flags
& (SEC_ALLOC
| SEC_IS_COMMON
)) != 0
3204 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3206 return SHT_PROGBITS
;
3209 struct fake_section_arg
3211 struct bfd_link_info
*link_info
;
3215 /* Set up an ELF internal section header for a section. */
3218 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3220 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3221 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3222 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3223 Elf_Internal_Shdr
*this_hdr
;
3224 unsigned int sh_type
;
3225 const char *name
= asect
->name
;
3226 bfd_boolean delay_st_name_p
= FALSE
;
3230 /* We already failed; just get out of the bfd_map_over_sections
3235 this_hdr
= &esd
->this_hdr
;
3239 /* ld: compress DWARF debug sections with names: .debug_*. */
3240 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3241 && (asect
->flags
& SEC_DEBUGGING
)
3245 /* Set SEC_ELF_COMPRESS to indicate this section should be
3247 asect
->flags
|= SEC_ELF_COMPRESS
;
3249 /* If this section will be compressed, delay adding section
3250 name to section name section after it is compressed in
3251 _bfd_elf_assign_file_positions_for_non_load. */
3252 delay_st_name_p
= TRUE
;
3255 else if ((asect
->flags
& SEC_ELF_RENAME
))
3257 /* objcopy: rename output DWARF debug section. */
3258 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3260 /* When we decompress or compress with SHF_COMPRESSED,
3261 convert section name from .zdebug_* to .debug_* if
3265 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3266 if (new_name
== NULL
)
3274 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3276 /* PR binutils/18087: Compression does not always make a
3277 section smaller. So only rename the section when
3278 compression has actually taken place. If input section
3279 name is .zdebug_*, we should never compress it again. */
3280 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3281 if (new_name
== NULL
)
3286 BFD_ASSERT (name
[1] != 'z');
3291 if (delay_st_name_p
)
3292 this_hdr
->sh_name
= (unsigned int) -1;
3296 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3298 if (this_hdr
->sh_name
== (unsigned int) -1)
3305 /* Don't clear sh_flags. Assembler may set additional bits. */
3307 if ((asect
->flags
& SEC_ALLOC
) != 0
3308 || asect
->user_set_vma
)
3309 this_hdr
->sh_addr
= asect
->vma
;
3311 this_hdr
->sh_addr
= 0;
3313 this_hdr
->sh_offset
= 0;
3314 this_hdr
->sh_size
= asect
->size
;
3315 this_hdr
->sh_link
= 0;
3316 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3317 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3320 /* xgettext:c-format */
3321 (_("%pB: error: alignment power %d of section `%pA' is too big"),
3322 abfd
, asect
->alignment_power
, asect
);
3326 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
3327 /* The sh_entsize and sh_info fields may have been set already by
3328 copy_private_section_data. */
3330 this_hdr
->bfd_section
= asect
;
3331 this_hdr
->contents
= NULL
;
3333 /* If the section type is unspecified, we set it based on
3335 if ((asect
->flags
& SEC_GROUP
) != 0)
3336 sh_type
= SHT_GROUP
;
3338 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3340 if (this_hdr
->sh_type
== SHT_NULL
)
3341 this_hdr
->sh_type
= sh_type
;
3342 else if (this_hdr
->sh_type
== SHT_NOBITS
3343 && sh_type
== SHT_PROGBITS
3344 && (asect
->flags
& SEC_ALLOC
) != 0)
3346 /* Warn if we are changing a NOBITS section to PROGBITS, but
3347 allow the link to proceed. This can happen when users link
3348 non-bss input sections to bss output sections, or emit data
3349 to a bss output section via a linker script. */
3351 (_("warning: section `%pA' type changed to PROGBITS"), asect
);
3352 this_hdr
->sh_type
= sh_type
;
3355 switch (this_hdr
->sh_type
)
3366 case SHT_INIT_ARRAY
:
3367 case SHT_FINI_ARRAY
:
3368 case SHT_PREINIT_ARRAY
:
3369 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3373 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3377 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3381 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3385 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3386 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3390 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3391 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3394 case SHT_GNU_versym
:
3395 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3398 case SHT_GNU_verdef
:
3399 this_hdr
->sh_entsize
= 0;
3400 /* objcopy or strip will copy over sh_info, but may not set
3401 cverdefs. The linker will set cverdefs, but sh_info will be
3403 if (this_hdr
->sh_info
== 0)
3404 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3406 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3407 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3410 case SHT_GNU_verneed
:
3411 this_hdr
->sh_entsize
= 0;
3412 /* objcopy or strip will copy over sh_info, but may not set
3413 cverrefs. The linker will set cverrefs, but sh_info will be
3415 if (this_hdr
->sh_info
== 0)
3416 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3418 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3419 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3423 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3427 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3431 if ((asect
->flags
& SEC_ALLOC
) != 0)
3432 this_hdr
->sh_flags
|= SHF_ALLOC
;
3433 if ((asect
->flags
& SEC_READONLY
) == 0)
3434 this_hdr
->sh_flags
|= SHF_WRITE
;
3435 if ((asect
->flags
& SEC_CODE
) != 0)
3436 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3437 if ((asect
->flags
& SEC_MERGE
) != 0)
3439 this_hdr
->sh_flags
|= SHF_MERGE
;
3440 this_hdr
->sh_entsize
= asect
->entsize
;
3442 if ((asect
->flags
& SEC_STRINGS
) != 0)
3443 this_hdr
->sh_flags
|= SHF_STRINGS
;
3444 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3445 this_hdr
->sh_flags
|= SHF_GROUP
;
3446 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3448 this_hdr
->sh_flags
|= SHF_TLS
;
3449 if (asect
->size
== 0
3450 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3452 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3454 this_hdr
->sh_size
= 0;
3457 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3458 if (this_hdr
->sh_size
!= 0)
3459 this_hdr
->sh_type
= SHT_NOBITS
;
3463 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3464 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3466 /* If the section has relocs, set up a section header for the
3467 SHT_REL[A] section. If two relocation sections are required for
3468 this section, it is up to the processor-specific back-end to
3469 create the other. */
3470 if ((asect
->flags
& SEC_RELOC
) != 0)
3472 /* When doing a relocatable link, create both REL and RELA sections if
3475 /* Do the normal setup if we wouldn't create any sections here. */
3476 && esd
->rel
.count
+ esd
->rela
.count
> 0
3477 && (bfd_link_relocatable (arg
->link_info
)
3478 || arg
->link_info
->emitrelocations
))
3480 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3481 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3482 FALSE
, delay_st_name_p
))
3487 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3488 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3489 TRUE
, delay_st_name_p
))
3495 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3497 ? &esd
->rela
: &esd
->rel
),
3507 /* Check for processor-specific section types. */
3508 sh_type
= this_hdr
->sh_type
;
3509 if (bed
->elf_backend_fake_sections
3510 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3516 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3518 /* Don't change the header type from NOBITS if we are being
3519 called for objcopy --only-keep-debug. */
3520 this_hdr
->sh_type
= sh_type
;
3524 /* Fill in the contents of a SHT_GROUP section. Called from
3525 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3526 when ELF targets use the generic linker, ld. Called for ld -r
3527 from bfd_elf_final_link. */
3530 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3532 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3533 asection
*elt
, *first
;
3537 /* Ignore linker created group section. See elfNN_ia64_object_p in
3539 if ((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
3544 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3546 unsigned long symindx
= 0;
3548 /* elf_group_id will have been set up by objcopy and the
3550 if (elf_group_id (sec
) != NULL
)
3551 symindx
= elf_group_id (sec
)->udata
.i
;
3555 /* If called from the assembler, swap_out_syms will have set up
3556 elf_section_syms. */
3557 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3558 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3560 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3562 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3564 /* The ELF backend linker sets sh_info to -2 when the group
3565 signature symbol is global, and thus the index can't be
3566 set until all local symbols are output. */
3568 struct bfd_elf_section_data
*sec_data
;
3569 unsigned long symndx
;
3570 unsigned long extsymoff
;
3571 struct elf_link_hash_entry
*h
;
3573 /* The point of this little dance to the first SHF_GROUP section
3574 then back to the SHT_GROUP section is that this gets us to
3575 the SHT_GROUP in the input object. */
3576 igroup
= elf_sec_group (elf_next_in_group (sec
));
3577 sec_data
= elf_section_data (igroup
);
3578 symndx
= sec_data
->this_hdr
.sh_info
;
3580 if (!elf_bad_symtab (igroup
->owner
))
3582 Elf_Internal_Shdr
*symtab_hdr
;
3584 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3585 extsymoff
= symtab_hdr
->sh_info
;
3587 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3588 while (h
->root
.type
== bfd_link_hash_indirect
3589 || h
->root
.type
== bfd_link_hash_warning
)
3590 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3592 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3595 /* The contents won't be allocated for "ld -r" or objcopy. */
3597 if (sec
->contents
== NULL
)
3600 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3602 /* Arrange for the section to be written out. */
3603 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3604 if (sec
->contents
== NULL
)
3611 loc
= sec
->contents
+ sec
->size
;
3613 /* Get the pointer to the first section in the group that gas
3614 squirreled away here. objcopy arranges for this to be set to the
3615 start of the input section group. */
3616 first
= elt
= elf_next_in_group (sec
);
3618 /* First element is a flag word. Rest of section is elf section
3619 indices for all the sections of the group. Write them backwards
3620 just to keep the group in the same order as given in .section
3621 directives, not that it matters. */
3628 s
= s
->output_section
;
3630 && !bfd_is_abs_section (s
))
3632 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3633 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3635 if (elf_sec
->rel
.hdr
!= NULL
3637 || (input_elf_sec
->rel
.hdr
!= NULL
3638 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3640 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3642 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3644 if (elf_sec
->rela
.hdr
!= NULL
3646 || (input_elf_sec
->rela
.hdr
!= NULL
3647 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3649 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3651 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3654 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3656 elt
= elf_next_in_group (elt
);
3662 BFD_ASSERT (loc
== sec
->contents
);
3664 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3667 /* Given NAME, the name of a relocation section stripped of its
3668 .rel/.rela prefix, return the section in ABFD to which the
3669 relocations apply. */
3672 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3674 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3675 section likely apply to .got.plt or .got section. */
3676 if (get_elf_backend_data (abfd
)->want_got_plt
3677 && strcmp (name
, ".plt") == 0)
3682 sec
= bfd_get_section_by_name (abfd
, name
);
3688 return bfd_get_section_by_name (abfd
, name
);
3691 /* Return the section to which RELOC_SEC applies. */
3694 elf_get_reloc_section (asection
*reloc_sec
)
3699 const struct elf_backend_data
*bed
;
3701 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3702 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3705 /* We look up the section the relocs apply to by name. */
3706 name
= reloc_sec
->name
;
3707 if (strncmp (name
, ".rel", 4) != 0)
3710 if (type
== SHT_RELA
&& *name
++ != 'a')
3713 abfd
= reloc_sec
->owner
;
3714 bed
= get_elf_backend_data (abfd
);
3715 return bed
->get_reloc_section (abfd
, name
);
3718 /* Assign all ELF section numbers. The dummy first section is handled here
3719 too. The link/info pointers for the standard section types are filled
3720 in here too, while we're at it. */
3723 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3725 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3727 unsigned int section_number
;
3728 Elf_Internal_Shdr
**i_shdrp
;
3729 struct bfd_elf_section_data
*d
;
3730 bfd_boolean need_symtab
;
3734 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3736 /* SHT_GROUP sections are in relocatable files only. */
3737 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3739 size_t reloc_count
= 0;
3741 /* Put SHT_GROUP sections first. */
3742 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3744 d
= elf_section_data (sec
);
3746 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3748 if (sec
->flags
& SEC_LINKER_CREATED
)
3750 /* Remove the linker created SHT_GROUP sections. */
3751 bfd_section_list_remove (abfd
, sec
);
3752 abfd
->section_count
--;
3755 d
->this_idx
= section_number
++;
3758 /* Count relocations. */
3759 reloc_count
+= sec
->reloc_count
;
3762 /* Clear HAS_RELOC if there are no relocations. */
3763 if (reloc_count
== 0)
3764 abfd
->flags
&= ~HAS_RELOC
;
3767 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3769 d
= elf_section_data (sec
);
3771 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3772 d
->this_idx
= section_number
++;
3773 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3774 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3777 d
->rel
.idx
= section_number
++;
3778 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3779 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3786 d
->rela
.idx
= section_number
++;
3787 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3788 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3794 need_symtab
= (bfd_get_symcount (abfd
) > 0
3795 || (link_info
== NULL
3796 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3800 elf_onesymtab (abfd
) = section_number
++;
3801 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3802 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3804 elf_section_list
*entry
;
3806 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3808 entry
= bfd_zalloc (abfd
, sizeof (*entry
));
3809 entry
->ndx
= section_number
++;
3810 elf_symtab_shndx_list (abfd
) = entry
;
3812 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3813 ".symtab_shndx", FALSE
);
3814 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3817 elf_strtab_sec (abfd
) = section_number
++;
3818 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3821 elf_shstrtab_sec (abfd
) = section_number
++;
3822 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3823 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3825 if (section_number
>= SHN_LORESERVE
)
3827 /* xgettext:c-format */
3828 _bfd_error_handler (_("%pB: too many sections: %u"),
3829 abfd
, section_number
);
3833 elf_numsections (abfd
) = section_number
;
3834 elf_elfheader (abfd
)->e_shnum
= section_number
;
3836 /* Set up the list of section header pointers, in agreement with the
3838 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3839 sizeof (Elf_Internal_Shdr
*));
3840 if (i_shdrp
== NULL
)
3843 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3844 sizeof (Elf_Internal_Shdr
));
3845 if (i_shdrp
[0] == NULL
)
3847 bfd_release (abfd
, i_shdrp
);
3851 elf_elfsections (abfd
) = i_shdrp
;
3853 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3856 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3857 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3859 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3860 BFD_ASSERT (entry
!= NULL
);
3861 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3862 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3864 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3865 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3868 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3872 d
= elf_section_data (sec
);
3874 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3875 if (d
->rel
.idx
!= 0)
3876 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3877 if (d
->rela
.idx
!= 0)
3878 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3880 /* Fill in the sh_link and sh_info fields while we're at it. */
3882 /* sh_link of a reloc section is the section index of the symbol
3883 table. sh_info is the section index of the section to which
3884 the relocation entries apply. */
3885 if (d
->rel
.idx
!= 0)
3887 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3888 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3889 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3891 if (d
->rela
.idx
!= 0)
3893 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3894 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3895 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3898 /* We need to set up sh_link for SHF_LINK_ORDER. */
3899 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3901 s
= elf_linked_to_section (sec
);
3904 /* elf_linked_to_section points to the input section. */
3905 if (link_info
!= NULL
)
3907 /* Check discarded linkonce section. */
3908 if (discarded_section (s
))
3912 /* xgettext:c-format */
3913 (_("%pB: sh_link of section `%pA' points to"
3914 " discarded section `%pA' of `%pB'"),
3915 abfd
, d
->this_hdr
.bfd_section
,
3917 /* Point to the kept section if it has the same
3918 size as the discarded one. */
3919 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3922 bfd_set_error (bfd_error_bad_value
);
3928 s
= s
->output_section
;
3929 BFD_ASSERT (s
!= NULL
);
3933 /* Handle objcopy. */
3934 if (s
->output_section
== NULL
)
3937 /* xgettext:c-format */
3938 (_("%pB: sh_link of section `%pA' points to"
3939 " removed section `%pA' of `%pB'"),
3940 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3941 bfd_set_error (bfd_error_bad_value
);
3944 s
= s
->output_section
;
3946 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3951 The Intel C compiler generates SHT_IA_64_UNWIND with
3952 SHF_LINK_ORDER. But it doesn't set the sh_link or
3953 sh_info fields. Hence we could get the situation
3955 const struct elf_backend_data
*bed
3956 = get_elf_backend_data (abfd
);
3957 if (bed
->link_order_error_handler
)
3958 bed
->link_order_error_handler
3959 /* xgettext:c-format */
3960 (_("%pB: warning: sh_link not set for section `%pA'"),
3965 switch (d
->this_hdr
.sh_type
)
3969 /* A reloc section which we are treating as a normal BFD
3970 section. sh_link is the section index of the symbol
3971 table. sh_info is the section index of the section to
3972 which the relocation entries apply. We assume that an
3973 allocated reloc section uses the dynamic symbol table.
3974 FIXME: How can we be sure? */
3975 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3977 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3979 s
= elf_get_reloc_section (sec
);
3982 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3983 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3988 /* We assume that a section named .stab*str is a stabs
3989 string section. We look for a section with the same name
3990 but without the trailing ``str'', and set its sh_link
3991 field to point to this section. */
3992 if (CONST_STRNEQ (sec
->name
, ".stab")
3993 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3998 len
= strlen (sec
->name
);
3999 alc
= (char *) bfd_malloc (len
- 2);
4002 memcpy (alc
, sec
->name
, len
- 3);
4003 alc
[len
- 3] = '\0';
4004 s
= bfd_get_section_by_name (abfd
, alc
);
4008 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
4010 /* This is a .stab section. */
4011 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
4012 elf_section_data (s
)->this_hdr
.sh_entsize
4013 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
4020 case SHT_GNU_verneed
:
4021 case SHT_GNU_verdef
:
4022 /* sh_link is the section header index of the string table
4023 used for the dynamic entries, or the symbol table, or the
4025 s
= bfd_get_section_by_name (abfd
, ".dynstr");
4027 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4030 case SHT_GNU_LIBLIST
:
4031 /* sh_link is the section header index of the prelink library
4032 list used for the dynamic entries, or the symbol table, or
4033 the version strings. */
4034 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
4035 ? ".dynstr" : ".gnu.libstr");
4037 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4042 case SHT_GNU_versym
:
4043 /* sh_link is the section header index of the symbol table
4044 this hash table or version table is for. */
4045 s
= bfd_get_section_by_name (abfd
, ".dynsym");
4047 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
4051 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
4055 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
4056 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
4057 debug section name from .debug_* to .zdebug_* if needed. */
4063 sym_is_global (bfd
*abfd
, asymbol
*sym
)
4065 /* If the backend has a special mapping, use it. */
4066 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4067 if (bed
->elf_backend_sym_is_global
)
4068 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
4070 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
4071 || bfd_is_und_section (bfd_asymbol_section (sym
))
4072 || bfd_is_com_section (bfd_asymbol_section (sym
)));
4075 /* Filter global symbols of ABFD to include in the import library. All
4076 SYMCOUNT symbols of ABFD can be examined from their pointers in
4077 SYMS. Pointers of symbols to keep should be stored contiguously at
4078 the beginning of that array.
4080 Returns the number of symbols to keep. */
4083 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
4084 asymbol
**syms
, long symcount
)
4086 long src_count
, dst_count
= 0;
4088 for (src_count
= 0; src_count
< symcount
; src_count
++)
4090 asymbol
*sym
= syms
[src_count
];
4091 char *name
= (char *) bfd_asymbol_name (sym
);
4092 struct bfd_link_hash_entry
*h
;
4094 if (!sym_is_global (abfd
, sym
))
4097 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
4100 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4102 if (h
->linker_def
|| h
->ldscript_def
)
4105 syms
[dst_count
++] = sym
;
4108 syms
[dst_count
] = NULL
;
4113 /* Don't output section symbols for sections that are not going to be
4114 output, that are duplicates or there is no BFD section. */
4117 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4119 elf_symbol_type
*type_ptr
;
4124 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4127 if (sym
->section
== NULL
)
4130 type_ptr
= elf_symbol_from (abfd
, sym
);
4131 return ((type_ptr
!= NULL
4132 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4133 && bfd_is_abs_section (sym
->section
))
4134 || !(sym
->section
->owner
== abfd
4135 || (sym
->section
->output_section
!= NULL
4136 && sym
->section
->output_section
->owner
== abfd
4137 && sym
->section
->output_offset
== 0)
4138 || bfd_is_abs_section (sym
->section
)));
4141 /* Map symbol from it's internal number to the external number, moving
4142 all local symbols to be at the head of the list. */
4145 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4147 unsigned int symcount
= bfd_get_symcount (abfd
);
4148 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4149 asymbol
**sect_syms
;
4150 unsigned int num_locals
= 0;
4151 unsigned int num_globals
= 0;
4152 unsigned int num_locals2
= 0;
4153 unsigned int num_globals2
= 0;
4154 unsigned int max_index
= 0;
4160 fprintf (stderr
, "elf_map_symbols\n");
4164 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4166 if (max_index
< asect
->index
)
4167 max_index
= asect
->index
;
4171 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
4172 if (sect_syms
== NULL
)
4174 elf_section_syms (abfd
) = sect_syms
;
4175 elf_num_section_syms (abfd
) = max_index
;
4177 /* Init sect_syms entries for any section symbols we have already
4178 decided to output. */
4179 for (idx
= 0; idx
< symcount
; idx
++)
4181 asymbol
*sym
= syms
[idx
];
4183 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4185 && !ignore_section_sym (abfd
, sym
)
4186 && !bfd_is_abs_section (sym
->section
))
4188 asection
*sec
= sym
->section
;
4190 if (sec
->owner
!= abfd
)
4191 sec
= sec
->output_section
;
4193 sect_syms
[sec
->index
] = syms
[idx
];
4197 /* Classify all of the symbols. */
4198 for (idx
= 0; idx
< symcount
; idx
++)
4200 if (sym_is_global (abfd
, syms
[idx
]))
4202 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4206 /* We will be adding a section symbol for each normal BFD section. Most
4207 sections will already have a section symbol in outsymbols, but
4208 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4209 at least in that case. */
4210 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4212 if (sect_syms
[asect
->index
] == NULL
)
4214 if (!sym_is_global (abfd
, asect
->symbol
))
4221 /* Now sort the symbols so the local symbols are first. */
4222 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
4223 sizeof (asymbol
*));
4225 if (new_syms
== NULL
)
4228 for (idx
= 0; idx
< symcount
; idx
++)
4230 asymbol
*sym
= syms
[idx
];
4233 if (sym_is_global (abfd
, sym
))
4234 i
= num_locals
+ num_globals2
++;
4235 else if (!ignore_section_sym (abfd
, sym
))
4240 sym
->udata
.i
= i
+ 1;
4242 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4244 if (sect_syms
[asect
->index
] == NULL
)
4246 asymbol
*sym
= asect
->symbol
;
4249 sect_syms
[asect
->index
] = sym
;
4250 if (!sym_is_global (abfd
, sym
))
4253 i
= num_locals
+ num_globals2
++;
4255 sym
->udata
.i
= i
+ 1;
4259 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4261 *pnum_locals
= num_locals
;
4265 /* Align to the maximum file alignment that could be required for any
4266 ELF data structure. */
4268 static inline file_ptr
4269 align_file_position (file_ptr off
, int align
)
4271 return (off
+ align
- 1) & ~(align
- 1);
4274 /* Assign a file position to a section, optionally aligning to the
4275 required section alignment. */
4278 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4282 if (align
&& i_shdrp
->sh_addralign
> 1)
4283 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4284 i_shdrp
->sh_offset
= offset
;
4285 if (i_shdrp
->bfd_section
!= NULL
)
4286 i_shdrp
->bfd_section
->filepos
= offset
;
4287 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4288 offset
+= i_shdrp
->sh_size
;
4292 /* Compute the file positions we are going to put the sections at, and
4293 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4294 is not NULL, this is being called by the ELF backend linker. */
4297 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4298 struct bfd_link_info
*link_info
)
4300 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4301 struct fake_section_arg fsargs
;
4303 struct elf_strtab_hash
*strtab
= NULL
;
4304 Elf_Internal_Shdr
*shstrtab_hdr
;
4305 bfd_boolean need_symtab
;
4307 if (abfd
->output_has_begun
)
4310 /* Do any elf backend specific processing first. */
4311 if (bed
->elf_backend_begin_write_processing
)
4312 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4314 if (!(*bed
->elf_backend_init_file_header
) (abfd
, link_info
))
4317 fsargs
.failed
= FALSE
;
4318 fsargs
.link_info
= link_info
;
4319 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4323 if (!assign_section_numbers (abfd
, link_info
))
4326 /* The backend linker builds symbol table information itself. */
4327 need_symtab
= (link_info
== NULL
4328 && (bfd_get_symcount (abfd
) > 0
4329 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4333 /* Non-zero if doing a relocatable link. */
4334 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4336 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
4341 if (link_info
== NULL
)
4343 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4348 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4349 /* sh_name was set in init_file_header. */
4350 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4351 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4352 shstrtab_hdr
->sh_addr
= 0;
4353 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4354 shstrtab_hdr
->sh_entsize
= 0;
4355 shstrtab_hdr
->sh_link
= 0;
4356 shstrtab_hdr
->sh_info
= 0;
4357 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4358 shstrtab_hdr
->sh_addralign
= 1;
4360 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4366 Elf_Internal_Shdr
*hdr
;
4368 off
= elf_next_file_pos (abfd
);
4370 hdr
= & elf_symtab_hdr (abfd
);
4371 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4373 if (elf_symtab_shndx_list (abfd
) != NULL
)
4375 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4376 if (hdr
->sh_size
!= 0)
4377 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4378 /* FIXME: What about other symtab_shndx sections in the list ? */
4381 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4382 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4384 elf_next_file_pos (abfd
) = off
;
4386 /* Now that we know where the .strtab section goes, write it
4388 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4389 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4391 _bfd_elf_strtab_free (strtab
);
4394 abfd
->output_has_begun
= TRUE
;
4399 /* Make an initial estimate of the size of the program header. If we
4400 get the number wrong here, we'll redo section placement. */
4402 static bfd_size_type
4403 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4407 const struct elf_backend_data
*bed
;
4409 /* Assume we will need exactly two PT_LOAD segments: one for text
4410 and one for data. */
4413 s
= bfd_get_section_by_name (abfd
, ".interp");
4414 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4416 /* If we have a loadable interpreter section, we need a
4417 PT_INTERP segment. In this case, assume we also need a
4418 PT_PHDR segment, although that may not be true for all
4423 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4425 /* We need a PT_DYNAMIC segment. */
4429 if (info
!= NULL
&& info
->relro
)
4431 /* We need a PT_GNU_RELRO segment. */
4435 if (elf_eh_frame_hdr (abfd
))
4437 /* We need a PT_GNU_EH_FRAME segment. */
4441 if (elf_stack_flags (abfd
))
4443 /* We need a PT_GNU_STACK segment. */
4447 s
= bfd_get_section_by_name (abfd
,
4448 NOTE_GNU_PROPERTY_SECTION_NAME
);
4449 if (s
!= NULL
&& s
->size
!= 0)
4451 /* We need a PT_GNU_PROPERTY segment. */
4455 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4457 if ((s
->flags
& SEC_LOAD
) != 0
4458 && elf_section_type (s
) == SHT_NOTE
)
4460 unsigned int alignment_power
;
4461 /* We need a PT_NOTE segment. */
4463 /* Try to create just one PT_NOTE segment for all adjacent
4464 loadable SHT_NOTE sections. gABI requires that within a
4465 PT_NOTE segment (and also inside of each SHT_NOTE section)
4466 each note should have the same alignment. So we check
4467 whether the sections are correctly aligned. */
4468 alignment_power
= s
->alignment_power
;
4469 while (s
->next
!= NULL
4470 && s
->next
->alignment_power
== alignment_power
4471 && (s
->next
->flags
& SEC_LOAD
) != 0
4472 && elf_section_type (s
->next
) == SHT_NOTE
)
4477 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4479 if (s
->flags
& SEC_THREAD_LOCAL
)
4481 /* We need a PT_TLS segment. */
4487 bed
= get_elf_backend_data (abfd
);
4489 if ((abfd
->flags
& D_PAGED
) != 0
4490 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
4492 /* Add a PT_GNU_MBIND segment for each mbind section. */
4493 unsigned int page_align_power
= bfd_log2 (bed
->commonpagesize
);
4494 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4495 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4497 if (elf_section_data (s
)->this_hdr
.sh_info
> PT_GNU_MBIND_NUM
)
4500 /* xgettext:c-format */
4501 (_("%pB: GNU_MBIND section `%pA' has invalid "
4502 "sh_info field: %d"),
4503 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4506 /* Align mbind section to page size. */
4507 if (s
->alignment_power
< page_align_power
)
4508 s
->alignment_power
= page_align_power
;
4513 /* Let the backend count up any program headers it might need. */
4514 if (bed
->elf_backend_additional_program_headers
)
4518 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4524 return segs
* bed
->s
->sizeof_phdr
;
4527 /* Find the segment that contains the output_section of section. */
4530 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4532 struct elf_segment_map
*m
;
4533 Elf_Internal_Phdr
*p
;
4535 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4541 for (i
= m
->count
- 1; i
>= 0; i
--)
4542 if (m
->sections
[i
] == section
)
4549 /* Create a mapping from a set of sections to a program segment. */
4551 static struct elf_segment_map
*
4552 make_mapping (bfd
*abfd
,
4553 asection
**sections
,
4558 struct elf_segment_map
*m
;
4563 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
4564 amt
+= (to
- from
) * sizeof (asection
*);
4565 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4569 m
->p_type
= PT_LOAD
;
4570 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4571 m
->sections
[i
- from
] = *hdrpp
;
4572 m
->count
= to
- from
;
4574 if (from
== 0 && phdr
)
4576 /* Include the headers in the first PT_LOAD segment. */
4577 m
->includes_filehdr
= 1;
4578 m
->includes_phdrs
= 1;
4584 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4587 struct elf_segment_map
*
4588 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4590 struct elf_segment_map
*m
;
4592 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4593 sizeof (struct elf_segment_map
));
4597 m
->p_type
= PT_DYNAMIC
;
4599 m
->sections
[0] = dynsec
;
4604 /* Possibly add or remove segments from the segment map. */
4607 elf_modify_segment_map (bfd
*abfd
,
4608 struct bfd_link_info
*info
,
4609 bfd_boolean remove_empty_load
)
4611 struct elf_segment_map
**m
;
4612 const struct elf_backend_data
*bed
;
4614 /* The placement algorithm assumes that non allocated sections are
4615 not in PT_LOAD segments. We ensure this here by removing such
4616 sections from the segment map. We also remove excluded
4617 sections. Finally, any PT_LOAD segment without sections is
4619 m
= &elf_seg_map (abfd
);
4622 unsigned int i
, new_count
;
4624 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4626 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4627 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4628 || (*m
)->p_type
!= PT_LOAD
))
4630 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4634 (*m
)->count
= new_count
;
4636 if (remove_empty_load
4637 && (*m
)->p_type
== PT_LOAD
4639 && !(*m
)->includes_phdrs
)
4645 bed
= get_elf_backend_data (abfd
);
4646 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4648 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4655 #define IS_TBSS(s) \
4656 ((s->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) == SEC_THREAD_LOCAL)
4658 /* Set up a mapping from BFD sections to program segments. */
4661 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4664 struct elf_segment_map
*m
;
4665 asection
**sections
= NULL
;
4666 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4667 bfd_boolean no_user_phdrs
;
4669 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4672 info
->user_phdrs
= !no_user_phdrs
;
4674 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4678 struct elf_segment_map
*mfirst
;
4679 struct elf_segment_map
**pm
;
4682 unsigned int hdr_index
;
4683 bfd_vma maxpagesize
;
4685 bfd_boolean phdr_in_segment
;
4686 bfd_boolean writable
;
4687 bfd_boolean executable
;
4689 asection
*first_tls
= NULL
;
4690 asection
*first_mbind
= NULL
;
4691 asection
*dynsec
, *eh_frame_hdr
;
4693 bfd_vma addr_mask
, wrap_to
= 0;
4694 bfd_size_type phdr_size
;
4696 /* Select the allocated sections, and sort them. */
4698 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4699 sizeof (asection
*));
4700 if (sections
== NULL
)
4703 /* Calculate top address, avoiding undefined behaviour of shift
4704 left operator when shift count is equal to size of type
4706 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4707 addr_mask
= (addr_mask
<< 1) + 1;
4710 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4712 if ((s
->flags
& SEC_ALLOC
) != 0)
4714 /* target_index is unused until bfd_elf_final_link
4715 starts output of section symbols. Use it to make
4717 s
->target_index
= i
;
4720 /* A wrapping section potentially clashes with header. */
4721 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4722 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4725 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4728 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4730 phdr_size
= elf_program_header_size (abfd
);
4731 if (phdr_size
== (bfd_size_type
) -1)
4732 phdr_size
= get_program_header_size (abfd
, info
);
4733 phdr_size
+= bed
->s
->sizeof_ehdr
;
4734 maxpagesize
= bed
->maxpagesize
;
4735 if (maxpagesize
== 0)
4737 phdr_in_segment
= info
!= NULL
&& info
->load_phdrs
;
4739 && (((sections
[0]->lma
& addr_mask
) & (maxpagesize
- 1))
4740 >= (phdr_size
& (maxpagesize
- 1))))
4741 /* For compatibility with old scripts that may not be using
4742 SIZEOF_HEADERS, add headers when it looks like space has
4743 been left for them. */
4744 phdr_in_segment
= TRUE
;
4746 /* Build the mapping. */
4750 /* If we have a .interp section, then create a PT_PHDR segment for
4751 the program headers and a PT_INTERP segment for the .interp
4753 s
= bfd_get_section_by_name (abfd
, ".interp");
4754 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0 && s
->size
!= 0)
4756 amt
= sizeof (struct elf_segment_map
);
4757 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4761 m
->p_type
= PT_PHDR
;
4763 m
->p_flags_valid
= 1;
4764 m
->includes_phdrs
= 1;
4765 phdr_in_segment
= TRUE
;
4769 amt
= sizeof (struct elf_segment_map
);
4770 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4774 m
->p_type
= PT_INTERP
;
4782 /* Look through the sections. We put sections in the same program
4783 segment when the start of the second section can be placed within
4784 a few bytes of the end of the first section. */
4790 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4792 && (dynsec
->flags
& SEC_LOAD
) == 0)
4795 if ((abfd
->flags
& D_PAGED
) == 0)
4796 phdr_in_segment
= FALSE
;
4798 /* Deal with -Ttext or something similar such that the first section
4799 is not adjacent to the program headers. This is an
4800 approximation, since at this point we don't know exactly how many
4801 program headers we will need. */
4802 if (phdr_in_segment
&& count
> 0)
4805 bfd_boolean separate_phdr
= FALSE
;
4807 phdr_lma
= (sections
[0]->lma
- phdr_size
) & addr_mask
& -maxpagesize
;
4809 && info
->separate_code
4810 && (sections
[0]->flags
& SEC_CODE
) != 0)
4812 /* If data sections should be separate from code and
4813 thus not executable, and the first section is
4814 executable then put the file and program headers in
4815 their own PT_LOAD. */
4816 separate_phdr
= TRUE
;
4817 if ((((phdr_lma
+ phdr_size
- 1) & addr_mask
& -maxpagesize
)
4818 == (sections
[0]->lma
& addr_mask
& -maxpagesize
)))
4820 /* The file and program headers are currently on the
4821 same page as the first section. Put them on the
4822 previous page if we can. */
4823 if (phdr_lma
>= maxpagesize
)
4824 phdr_lma
-= maxpagesize
;
4826 separate_phdr
= FALSE
;
4829 if ((sections
[0]->lma
& addr_mask
) < phdr_lma
4830 || (sections
[0]->lma
& addr_mask
) < phdr_size
)
4831 /* If file and program headers would be placed at the end
4832 of memory then it's probably better to omit them. */
4833 phdr_in_segment
= FALSE
;
4834 else if (phdr_lma
< wrap_to
)
4835 /* If a section wraps around to where we'll be placing
4836 file and program headers, then the headers will be
4838 phdr_in_segment
= FALSE
;
4839 else if (separate_phdr
)
4841 m
= make_mapping (abfd
, sections
, 0, 0, phdr_in_segment
);
4844 m
->p_paddr
= phdr_lma
;
4846 = (sections
[0]->vma
- phdr_size
) & addr_mask
& -maxpagesize
;
4847 m
->p_paddr_valid
= 1;
4850 phdr_in_segment
= FALSE
;
4854 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4857 bfd_boolean new_segment
;
4861 /* See if this section and the last one will fit in the same
4864 if (last_hdr
== NULL
)
4866 /* If we don't have a segment yet, then we don't need a new
4867 one (we build the last one after this loop). */
4868 new_segment
= FALSE
;
4870 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4872 /* If this section has a different relation between the
4873 virtual address and the load address, then we need a new
4877 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4878 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4880 /* If this section has a load address that makes it overlap
4881 the previous section, then we need a new segment. */
4884 else if ((abfd
->flags
& D_PAGED
) != 0
4885 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4886 == (hdr
->lma
& -maxpagesize
)))
4888 /* If we are demand paged then we can't map two disk
4889 pages onto the same memory page. */
4890 new_segment
= FALSE
;
4892 /* In the next test we have to be careful when last_hdr->lma is close
4893 to the end of the address space. If the aligned address wraps
4894 around to the start of the address space, then there are no more
4895 pages left in memory and it is OK to assume that the current
4896 section can be included in the current segment. */
4897 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4898 + maxpagesize
> last_hdr
->lma
)
4899 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4900 + maxpagesize
<= hdr
->lma
))
4902 /* If putting this section in this segment would force us to
4903 skip a page in the segment, then we need a new segment. */
4906 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4907 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4909 /* We don't want to put a loaded section after a
4910 nonloaded (ie. bss style) section in the same segment
4911 as that will force the non-loaded section to be loaded.
4912 Consider .tbss sections as loaded for this purpose. */
4915 else if ((abfd
->flags
& D_PAGED
) == 0)
4917 /* If the file is not demand paged, which means that we
4918 don't require the sections to be correctly aligned in the
4919 file, then there is no other reason for a new segment. */
4920 new_segment
= FALSE
;
4922 else if (info
!= NULL
4923 && info
->separate_code
4924 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4929 && (hdr
->flags
& SEC_READONLY
) == 0)
4931 /* We don't want to put a writable section in a read only
4937 /* Otherwise, we can use the same segment. */
4938 new_segment
= FALSE
;
4941 /* Allow interested parties a chance to override our decision. */
4942 if (last_hdr
!= NULL
4944 && info
->callbacks
->override_segment_assignment
!= NULL
)
4946 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4952 if ((hdr
->flags
& SEC_READONLY
) == 0)
4954 if ((hdr
->flags
& SEC_CODE
) != 0)
4957 /* .tbss sections effectively have zero size. */
4958 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4962 /* We need a new program segment. We must create a new program
4963 header holding all the sections from hdr_index until hdr. */
4965 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
4972 if ((hdr
->flags
& SEC_READONLY
) == 0)
4977 if ((hdr
->flags
& SEC_CODE
) == 0)
4983 /* .tbss sections effectively have zero size. */
4984 last_size
= !IS_TBSS (hdr
) ? hdr
->size
: 0;
4986 phdr_in_segment
= FALSE
;
4989 /* Create a final PT_LOAD program segment, but not if it's just
4991 if (last_hdr
!= NULL
4992 && (i
- hdr_index
!= 1
4993 || !IS_TBSS (last_hdr
)))
4995 m
= make_mapping (abfd
, sections
, hdr_index
, i
, phdr_in_segment
);
5003 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
5006 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
5013 /* For each batch of consecutive loadable SHT_NOTE sections,
5014 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
5015 because if we link together nonloadable .note sections and
5016 loadable .note sections, we will generate two .note sections
5017 in the output file. */
5018 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5020 if ((s
->flags
& SEC_LOAD
) != 0
5021 && elf_section_type (s
) == SHT_NOTE
)
5024 unsigned int alignment_power
= s
->alignment_power
;
5027 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
5029 if (s2
->next
->alignment_power
== alignment_power
5030 && (s2
->next
->flags
& SEC_LOAD
) != 0
5031 && elf_section_type (s2
->next
) == SHT_NOTE
5032 && align_power (s2
->lma
+ s2
->size
,
5039 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5040 amt
+= count
* sizeof (asection
*);
5041 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5045 m
->p_type
= PT_NOTE
;
5049 m
->sections
[m
->count
- count
--] = s
;
5050 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5053 m
->sections
[m
->count
- 1] = s
;
5054 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
5058 if (s
->flags
& SEC_THREAD_LOCAL
)
5064 if (first_mbind
== NULL
5065 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
5069 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
5072 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
5073 amt
+= tls_count
* sizeof (asection
*);
5074 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5079 m
->count
= tls_count
;
5080 /* Mandated PF_R. */
5082 m
->p_flags_valid
= 1;
5084 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
5086 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
5089 (_("%pB: TLS sections are not adjacent:"), abfd
);
5092 while (i
< (unsigned int) tls_count
)
5094 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
5096 _bfd_error_handler (_(" TLS: %pA"), s
);
5100 _bfd_error_handler (_(" non-TLS: %pA"), s
);
5103 bfd_set_error (bfd_error_bad_value
);
5115 && (abfd
->flags
& D_PAGED
) != 0
5116 && (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0)
5117 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
5118 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
5119 && elf_section_data (s
)->this_hdr
.sh_info
<= PT_GNU_MBIND_NUM
)
5121 /* Mandated PF_R. */
5122 unsigned long p_flags
= PF_R
;
5123 if ((s
->flags
& SEC_READONLY
) == 0)
5125 if ((s
->flags
& SEC_CODE
) != 0)
5128 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5129 m
= bfd_zalloc (abfd
, amt
);
5133 m
->p_type
= (PT_GNU_MBIND_LO
5134 + elf_section_data (s
)->this_hdr
.sh_info
);
5136 m
->p_flags_valid
= 1;
5138 m
->p_flags
= p_flags
;
5144 s
= bfd_get_section_by_name (abfd
,
5145 NOTE_GNU_PROPERTY_SECTION_NAME
);
5146 if (s
!= NULL
&& s
->size
!= 0)
5148 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
5149 m
= bfd_zalloc (abfd
, amt
);
5153 m
->p_type
= PT_GNU_PROPERTY
;
5155 m
->p_flags_valid
= 1;
5162 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
5164 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5165 if (eh_frame_hdr
!= NULL
5166 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5168 amt
= sizeof (struct elf_segment_map
);
5169 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5173 m
->p_type
= PT_GNU_EH_FRAME
;
5175 m
->sections
[0] = eh_frame_hdr
->output_section
;
5181 if (elf_stack_flags (abfd
))
5183 amt
= sizeof (struct elf_segment_map
);
5184 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5188 m
->p_type
= PT_GNU_STACK
;
5189 m
->p_flags
= elf_stack_flags (abfd
);
5190 m
->p_align
= bed
->stack_align
;
5191 m
->p_flags_valid
= 1;
5192 m
->p_align_valid
= m
->p_align
!= 0;
5193 if (info
->stacksize
> 0)
5195 m
->p_size
= info
->stacksize
;
5196 m
->p_size_valid
= 1;
5203 if (info
!= NULL
&& info
->relro
)
5205 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5207 if (m
->p_type
== PT_LOAD
5209 && m
->sections
[0]->vma
>= info
->relro_start
5210 && m
->sections
[0]->vma
< info
->relro_end
)
5213 while (--i
!= (unsigned) -1)
5214 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5215 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5218 if (i
!= (unsigned) -1)
5223 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5226 amt
= sizeof (struct elf_segment_map
);
5227 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5231 m
->p_type
= PT_GNU_RELRO
;
5238 elf_seg_map (abfd
) = mfirst
;
5241 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5244 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5246 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5251 if (sections
!= NULL
)
5256 /* Sort sections by address. */
5259 elf_sort_sections (const void *arg1
, const void *arg2
)
5261 const asection
*sec1
= *(const asection
**) arg1
;
5262 const asection
*sec2
= *(const asection
**) arg2
;
5263 bfd_size_type size1
, size2
;
5265 /* Sort by LMA first, since this is the address used to
5266 place the section into a segment. */
5267 if (sec1
->lma
< sec2
->lma
)
5269 else if (sec1
->lma
> sec2
->lma
)
5272 /* Then sort by VMA. Normally the LMA and the VMA will be
5273 the same, and this will do nothing. */
5274 if (sec1
->vma
< sec2
->vma
)
5276 else if (sec1
->vma
> sec2
->vma
)
5279 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5281 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5288 else if (TOEND (sec2
))
5293 /* Sort by size, to put zero sized sections
5294 before others at the same address. */
5296 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5297 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5304 return sec1
->target_index
- sec2
->target_index
;
5307 /* This qsort comparison functions sorts PT_LOAD segments first and
5308 by p_paddr, for assign_file_positions_for_load_sections. */
5311 elf_sort_segments (const void *arg1
, const void *arg2
)
5313 const struct elf_segment_map
*m1
= *(const struct elf_segment_map
**) arg1
;
5314 const struct elf_segment_map
*m2
= *(const struct elf_segment_map
**) arg2
;
5316 if (m1
->p_type
!= m2
->p_type
)
5318 if (m1
->p_type
== PT_NULL
)
5320 if (m2
->p_type
== PT_NULL
)
5322 return m1
->p_type
< m2
->p_type
? -1 : 1;
5324 if (m1
->includes_filehdr
!= m2
->includes_filehdr
)
5325 return m1
->includes_filehdr
? -1 : 1;
5326 if (m1
->no_sort_lma
!= m2
->no_sort_lma
)
5327 return m1
->no_sort_lma
? -1 : 1;
5328 if (m1
->p_type
== PT_LOAD
&& !m1
->no_sort_lma
)
5332 if (m1
->p_paddr_valid
)
5334 else if (m1
->count
!= 0)
5335 lma1
= m1
->sections
[0]->lma
+ m1
->p_vaddr_offset
;
5337 if (m2
->p_paddr_valid
)
5339 else if (m2
->count
!= 0)
5340 lma2
= m2
->sections
[0]->lma
+ m2
->p_vaddr_offset
;
5342 return lma1
< lma2
? -1 : 1;
5344 if (m1
->idx
!= m2
->idx
)
5345 return m1
->idx
< m2
->idx
? -1 : 1;
5349 /* Ian Lance Taylor writes:
5351 We shouldn't be using % with a negative signed number. That's just
5352 not good. We have to make sure either that the number is not
5353 negative, or that the number has an unsigned type. When the types
5354 are all the same size they wind up as unsigned. When file_ptr is a
5355 larger signed type, the arithmetic winds up as signed long long,
5358 What we're trying to say here is something like ``increase OFF by
5359 the least amount that will cause it to be equal to the VMA modulo
5361 /* In other words, something like:
5363 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5364 off_offset = off % bed->maxpagesize;
5365 if (vma_offset < off_offset)
5366 adjustment = vma_offset + bed->maxpagesize - off_offset;
5368 adjustment = vma_offset - off_offset;
5370 which can be collapsed into the expression below. */
5373 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5375 /* PR binutils/16199: Handle an alignment of zero. */
5376 if (maxpagesize
== 0)
5378 return ((vma
- off
) % maxpagesize
);
5382 print_segment_map (const struct elf_segment_map
*m
)
5385 const char *pt
= get_segment_type (m
->p_type
);
5390 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5391 sprintf (buf
, "LOPROC+%7.7x",
5392 (unsigned int) (m
->p_type
- PT_LOPROC
));
5393 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5394 sprintf (buf
, "LOOS+%7.7x",
5395 (unsigned int) (m
->p_type
- PT_LOOS
));
5397 snprintf (buf
, sizeof (buf
), "%8.8x",
5398 (unsigned int) m
->p_type
);
5402 fprintf (stderr
, "%s:", pt
);
5403 for (j
= 0; j
< m
->count
; j
++)
5404 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5410 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5415 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5417 buf
= bfd_zmalloc (len
);
5420 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5425 /* Assign file positions to the sections based on the mapping from
5426 sections to segments. This function also sets up some fields in
5430 assign_file_positions_for_load_sections (bfd
*abfd
,
5431 struct bfd_link_info
*link_info
)
5433 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5434 struct elf_segment_map
*m
;
5435 struct elf_segment_map
*phdr_load_seg
;
5436 Elf_Internal_Phdr
*phdrs
;
5437 Elf_Internal_Phdr
*p
;
5439 bfd_size_type maxpagesize
;
5440 unsigned int alloc
, actual
;
5442 struct elf_segment_map
**sorted_seg_map
;
5444 if (link_info
== NULL
5445 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5449 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5454 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5455 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5459 /* PR binutils/12467. */
5460 elf_elfheader (abfd
)->e_phoff
= 0;
5461 elf_elfheader (abfd
)->e_phentsize
= 0;
5464 elf_elfheader (abfd
)->e_phnum
= alloc
;
5466 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5469 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5473 actual
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
5474 BFD_ASSERT (elf_program_header_size (abfd
)
5475 == actual
* bed
->s
->sizeof_phdr
);
5476 BFD_ASSERT (actual
>= alloc
);
5481 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5485 /* We're writing the size in elf_program_header_size (abfd),
5486 see assign_file_positions_except_relocs, so make sure we have
5487 that amount allocated, with trailing space cleared.
5488 The variable alloc contains the computed need, while
5489 elf_program_header_size (abfd) contains the size used for the
5491 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5492 where the layout is forced to according to a larger size in the
5493 last iterations for the testcase ld-elf/header. */
5494 phdrs
= bfd_zalloc (abfd
, (actual
* sizeof (*phdrs
)
5495 + alloc
* sizeof (*sorted_seg_map
)));
5496 sorted_seg_map
= (struct elf_segment_map
**) (phdrs
+ actual
);
5497 elf_tdata (abfd
)->phdr
= phdrs
;
5501 for (m
= elf_seg_map (abfd
), j
= 0; m
!= NULL
; m
= m
->next
, j
++)
5503 sorted_seg_map
[j
] = m
;
5504 /* If elf_segment_map is not from map_sections_to_segments, the
5505 sections may not be correctly ordered. NOTE: sorting should
5506 not be done to the PT_NOTE section of a corefile, which may
5507 contain several pseudo-sections artificially created by bfd.
5508 Sorting these pseudo-sections breaks things badly. */
5510 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5511 && m
->p_type
== PT_NOTE
))
5513 for (i
= 0; i
< m
->count
; i
++)
5514 m
->sections
[i
]->target_index
= i
;
5515 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5520 qsort (sorted_seg_map
, alloc
, sizeof (*sorted_seg_map
),
5524 if ((abfd
->flags
& D_PAGED
) != 0)
5525 maxpagesize
= bed
->maxpagesize
;
5527 /* Sections must map to file offsets past the ELF file header. */
5528 off
= bed
->s
->sizeof_ehdr
;
5529 /* And if one of the PT_LOAD headers doesn't include the program
5530 headers then we'll be mapping program headers in the usual
5531 position after the ELF file header. */
5532 phdr_load_seg
= NULL
;
5533 for (j
= 0; j
< alloc
; j
++)
5535 m
= sorted_seg_map
[j
];
5536 if (m
->p_type
!= PT_LOAD
)
5538 if (m
->includes_phdrs
)
5544 if (phdr_load_seg
== NULL
)
5545 off
+= actual
* bed
->s
->sizeof_phdr
;
5547 for (j
= 0; j
< alloc
; j
++)
5551 bfd_boolean no_contents
;
5553 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5554 number of sections with contents contributing to both p_filesz
5555 and p_memsz, followed by a number of sections with no contents
5556 that just contribute to p_memsz. In this loop, OFF tracks next
5557 available file offset for PT_LOAD and PT_NOTE segments. */
5558 m
= sorted_seg_map
[j
];
5560 p
->p_type
= m
->p_type
;
5561 p
->p_flags
= m
->p_flags
;
5564 p
->p_vaddr
= m
->p_vaddr_offset
;
5566 p
->p_vaddr
= m
->sections
[0]->vma
+ m
->p_vaddr_offset
;
5568 if (m
->p_paddr_valid
)
5569 p
->p_paddr
= m
->p_paddr
;
5570 else if (m
->count
== 0)
5573 p
->p_paddr
= m
->sections
[0]->lma
+ m
->p_vaddr_offset
;
5575 if (p
->p_type
== PT_LOAD
5576 && (abfd
->flags
& D_PAGED
) != 0)
5578 /* p_align in demand paged PT_LOAD segments effectively stores
5579 the maximum page size. When copying an executable with
5580 objcopy, we set m->p_align from the input file. Use this
5581 value for maxpagesize rather than bed->maxpagesize, which
5582 may be different. Note that we use maxpagesize for PT_TLS
5583 segment alignment later in this function, so we are relying
5584 on at least one PT_LOAD segment appearing before a PT_TLS
5586 if (m
->p_align_valid
)
5587 maxpagesize
= m
->p_align
;
5589 p
->p_align
= maxpagesize
;
5591 else if (m
->p_align_valid
)
5592 p
->p_align
= m
->p_align
;
5593 else if (m
->count
== 0)
5594 p
->p_align
= 1 << bed
->s
->log_file_align
;
5596 if (m
== phdr_load_seg
)
5598 if (!m
->includes_filehdr
)
5600 off
+= actual
* bed
->s
->sizeof_phdr
;
5603 no_contents
= FALSE
;
5605 if (p
->p_type
== PT_LOAD
5608 bfd_size_type align
;
5609 unsigned int align_power
= 0;
5611 if (m
->p_align_valid
)
5615 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5617 unsigned int secalign
;
5619 secalign
= bfd_section_alignment (*secpp
);
5620 if (secalign
> align_power
)
5621 align_power
= secalign
;
5623 align
= (bfd_size_type
) 1 << align_power
;
5624 if (align
< maxpagesize
)
5625 align
= maxpagesize
;
5628 for (i
= 0; i
< m
->count
; i
++)
5629 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5630 /* If we aren't making room for this section, then
5631 it must be SHT_NOBITS regardless of what we've
5632 set via struct bfd_elf_special_section. */
5633 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5635 /* Find out whether this segment contains any loadable
5638 for (i
= 0; i
< m
->count
; i
++)
5639 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5641 no_contents
= FALSE
;
5645 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5647 /* Broken hardware and/or kernel require that files do not
5648 map the same page with different permissions on some hppa
5651 && (abfd
->flags
& D_PAGED
) != 0
5652 && bed
->no_page_alias
5653 && (off
& (maxpagesize
- 1)) != 0
5654 && (off
& -maxpagesize
) == ((off
+ off_adjust
) & -maxpagesize
))
5655 off_adjust
+= maxpagesize
;
5659 /* We shouldn't need to align the segment on disk since
5660 the segment doesn't need file space, but the gABI
5661 arguably requires the alignment and glibc ld.so
5662 checks it. So to comply with the alignment
5663 requirement but not waste file space, we adjust
5664 p_offset for just this segment. (OFF_ADJUST is
5665 subtracted from OFF later.) This may put p_offset
5666 past the end of file, but that shouldn't matter. */
5671 /* Make sure the .dynamic section is the first section in the
5672 PT_DYNAMIC segment. */
5673 else if (p
->p_type
== PT_DYNAMIC
5675 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5678 (_("%pB: The first section in the PT_DYNAMIC segment"
5679 " is not the .dynamic section"),
5681 bfd_set_error (bfd_error_bad_value
);
5684 /* Set the note section type to SHT_NOTE. */
5685 else if (p
->p_type
== PT_NOTE
)
5686 for (i
= 0; i
< m
->count
; i
++)
5687 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5689 if (m
->includes_filehdr
)
5691 if (!m
->p_flags_valid
)
5693 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5694 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5695 if (p
->p_type
== PT_LOAD
)
5699 if (p
->p_vaddr
< (bfd_vma
) off
5700 || (!m
->p_paddr_valid
5701 && p
->p_paddr
< (bfd_vma
) off
))
5704 (_("%pB: not enough room for program headers,"
5705 " try linking with -N"),
5707 bfd_set_error (bfd_error_bad_value
);
5711 if (!m
->p_paddr_valid
)
5715 else if (sorted_seg_map
[0]->includes_filehdr
)
5717 Elf_Internal_Phdr
*filehdr
= phdrs
+ sorted_seg_map
[0]->idx
;
5718 p
->p_vaddr
= filehdr
->p_vaddr
;
5719 if (!m
->p_paddr_valid
)
5720 p
->p_paddr
= filehdr
->p_paddr
;
5724 if (m
->includes_phdrs
)
5726 if (!m
->p_flags_valid
)
5728 p
->p_filesz
+= actual
* bed
->s
->sizeof_phdr
;
5729 p
->p_memsz
+= actual
* bed
->s
->sizeof_phdr
;
5730 if (!m
->includes_filehdr
)
5732 if (p
->p_type
== PT_LOAD
)
5734 elf_elfheader (abfd
)->e_phoff
= p
->p_offset
;
5737 p
->p_vaddr
-= off
- p
->p_offset
;
5738 if (!m
->p_paddr_valid
)
5739 p
->p_paddr
-= off
- p
->p_offset
;
5742 else if (phdr_load_seg
!= NULL
)
5744 Elf_Internal_Phdr
*phdr
= phdrs
+ phdr_load_seg
->idx
;
5745 bfd_vma phdr_off
= 0;
5746 if (phdr_load_seg
->includes_filehdr
)
5747 phdr_off
= bed
->s
->sizeof_ehdr
;
5748 p
->p_vaddr
= phdr
->p_vaddr
+ phdr_off
;
5749 if (!m
->p_paddr_valid
)
5750 p
->p_paddr
= phdr
->p_paddr
+ phdr_off
;
5751 p
->p_offset
= phdr
->p_offset
+ phdr_off
;
5754 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5758 if (p
->p_type
== PT_LOAD
5759 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5761 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5767 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5769 p
->p_filesz
+= adjust
;
5770 p
->p_memsz
+= adjust
;
5774 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5775 maps. Set filepos for sections in PT_LOAD segments, and in
5776 core files, for sections in PT_NOTE segments.
5777 assign_file_positions_for_non_load_sections will set filepos
5778 for other sections and update p_filesz for other segments. */
5779 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5782 bfd_size_type align
;
5783 Elf_Internal_Shdr
*this_hdr
;
5786 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5787 align
= (bfd_size_type
) 1 << bfd_section_alignment (sec
);
5789 if ((p
->p_type
== PT_LOAD
5790 || p
->p_type
== PT_TLS
)
5791 && (this_hdr
->sh_type
!= SHT_NOBITS
5792 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5793 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5794 || p
->p_type
== PT_TLS
))))
5796 bfd_vma p_start
= p
->p_paddr
;
5797 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5798 bfd_vma s_start
= sec
->lma
;
5799 bfd_vma adjust
= s_start
- p_end
;
5803 || p_end
< p_start
))
5806 /* xgettext:c-format */
5807 (_("%pB: section %pA lma %#" PRIx64
" adjusted to %#" PRIx64
),
5808 abfd
, sec
, (uint64_t) s_start
, (uint64_t) p_end
);
5812 p
->p_memsz
+= adjust
;
5814 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5816 if (p
->p_type
== PT_LOAD
)
5818 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5820 /* We have a PROGBITS section following NOBITS ones.
5821 Allocate file space for the NOBITS section(s) and
5823 adjust
= p
->p_memsz
- p
->p_filesz
;
5824 if (!write_zeros (abfd
, off
, adjust
))
5829 p
->p_filesz
+= adjust
;
5833 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5835 /* The section at i == 0 is the one that actually contains
5839 this_hdr
->sh_offset
= sec
->filepos
= off
;
5840 off
+= this_hdr
->sh_size
;
5841 p
->p_filesz
= this_hdr
->sh_size
;
5847 /* The rest are fake sections that shouldn't be written. */
5856 if (p
->p_type
== PT_LOAD
)
5858 this_hdr
->sh_offset
= sec
->filepos
= off
;
5859 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5860 off
+= this_hdr
->sh_size
;
5862 else if (this_hdr
->sh_type
== SHT_NOBITS
5863 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5864 && this_hdr
->sh_offset
== 0)
5866 /* This is a .tbss section that didn't get a PT_LOAD.
5867 (See _bfd_elf_map_sections_to_segments "Create a
5868 final PT_LOAD".) Set sh_offset to the value it
5869 would have if we had created a zero p_filesz and
5870 p_memsz PT_LOAD header for the section. This
5871 also makes the PT_TLS header have the same
5873 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5875 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5878 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5880 p
->p_filesz
+= this_hdr
->sh_size
;
5881 /* A load section without SHF_ALLOC is something like
5882 a note section in a PT_NOTE segment. These take
5883 file space but are not loaded into memory. */
5884 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5885 p
->p_memsz
+= this_hdr
->sh_size
;
5887 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5889 if (p
->p_type
== PT_TLS
)
5890 p
->p_memsz
+= this_hdr
->sh_size
;
5892 /* .tbss is special. It doesn't contribute to p_memsz of
5894 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5895 p
->p_memsz
+= this_hdr
->sh_size
;
5898 if (align
> p
->p_align
5899 && !m
->p_align_valid
5900 && (p
->p_type
!= PT_LOAD
5901 || (abfd
->flags
& D_PAGED
) == 0))
5905 if (!m
->p_flags_valid
)
5908 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5910 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5917 /* PR ld/20815 - Check that the program header segment, if
5918 present, will be loaded into memory. */
5919 if (p
->p_type
== PT_PHDR
5920 && phdr_load_seg
== NULL
5921 && !(bed
->elf_backend_allow_non_load_phdr
!= NULL
5922 && bed
->elf_backend_allow_non_load_phdr (abfd
, phdrs
, alloc
)))
5924 /* The fix for this error is usually to edit the linker script being
5925 used and set up the program headers manually. Either that or
5926 leave room for the headers at the start of the SECTIONS. */
5927 _bfd_error_handler (_("%pB: error: PHDR segment not covered"
5928 " by LOAD segment"),
5933 /* Check that all sections are in a PT_LOAD segment.
5934 Don't check funky gdb generated core files. */
5935 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5937 bfd_boolean check_vma
= TRUE
;
5939 for (i
= 1; i
< m
->count
; i
++)
5940 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5941 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5942 ->this_hdr
), p
) != 0
5943 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5944 ->this_hdr
), p
) != 0)
5946 /* Looks like we have overlays packed into the segment. */
5951 for (i
= 0; i
< m
->count
; i
++)
5953 Elf_Internal_Shdr
*this_hdr
;
5956 sec
= m
->sections
[i
];
5957 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5958 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5959 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5962 /* xgettext:c-format */
5963 (_("%pB: section `%pA' can't be allocated in segment %d"),
5965 print_segment_map (m
);
5971 elf_next_file_pos (abfd
) = off
;
5973 if (link_info
!= NULL
5974 && phdr_load_seg
!= NULL
5975 && phdr_load_seg
->includes_filehdr
)
5977 /* There is a segment that contains both the file headers and the
5978 program headers, so provide a symbol __ehdr_start pointing there.
5979 A program can use this to examine itself robustly. */
5981 struct elf_link_hash_entry
*hash
5982 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5983 FALSE
, FALSE
, TRUE
);
5984 /* If the symbol was referenced and not defined, define it. */
5986 && (hash
->root
.type
== bfd_link_hash_new
5987 || hash
->root
.type
== bfd_link_hash_undefined
5988 || hash
->root
.type
== bfd_link_hash_undefweak
5989 || hash
->root
.type
== bfd_link_hash_common
))
5992 bfd_vma filehdr_vaddr
= phdrs
[phdr_load_seg
->idx
].p_vaddr
;
5994 if (phdr_load_seg
->count
!= 0)
5995 /* The segment contains sections, so use the first one. */
5996 s
= phdr_load_seg
->sections
[0];
5998 /* Use the first (i.e. lowest-addressed) section in any segment. */
5999 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
6000 if (m
->p_type
== PT_LOAD
&& m
->count
!= 0)
6008 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
6009 hash
->root
.u
.def
.section
= s
;
6013 hash
->root
.u
.def
.value
= filehdr_vaddr
;
6014 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6017 hash
->root
.type
= bfd_link_hash_defined
;
6018 hash
->def_regular
= 1;
6026 /* Determine if a bfd is a debuginfo file. Unfortunately there
6027 is no defined method for detecting such files, so we have to
6028 use heuristics instead. */
6031 is_debuginfo_file (bfd
*abfd
)
6033 if (abfd
== NULL
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
6036 Elf_Internal_Shdr
**start_headers
= elf_elfsections (abfd
);
6037 Elf_Internal_Shdr
**end_headers
= start_headers
+ elf_numsections (abfd
);
6038 Elf_Internal_Shdr
**headerp
;
6040 for (headerp
= start_headers
; headerp
< end_headers
; headerp
++)
6042 Elf_Internal_Shdr
*header
= * headerp
;
6044 /* Debuginfo files do not have any allocated SHT_PROGBITS sections.
6045 The only allocated sections are SHT_NOBITS or SHT_NOTES. */
6046 if ((header
->sh_flags
& SHF_ALLOC
) == SHF_ALLOC
6047 && header
->sh_type
!= SHT_NOBITS
6048 && header
->sh_type
!= SHT_NOTE
)
6055 /* Assign file positions for the other sections, except for compressed debugging
6056 and other sections assigned in _bfd_elf_assign_file_positions_for_non_load(). */
6059 assign_file_positions_for_non_load_sections (bfd
*abfd
,
6060 struct bfd_link_info
*link_info
)
6062 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6063 Elf_Internal_Shdr
**i_shdrpp
;
6064 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
6065 Elf_Internal_Phdr
*phdrs
;
6066 Elf_Internal_Phdr
*p
;
6067 struct elf_segment_map
*m
;
6070 i_shdrpp
= elf_elfsections (abfd
);
6071 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
6072 off
= elf_next_file_pos (abfd
);
6073 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
6075 Elf_Internal_Shdr
*hdr
;
6078 if (hdr
->bfd_section
!= NULL
6079 && (hdr
->bfd_section
->filepos
!= 0
6080 || (hdr
->sh_type
== SHT_NOBITS
6081 && hdr
->contents
== NULL
)))
6082 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
6083 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
6085 if (hdr
->sh_size
!= 0
6086 /* PR 24717 - debuginfo files are known to be not strictly
6087 compliant with the ELF standard. In particular they often
6088 have .note.gnu.property sections that are outside of any
6089 loadable segment. This is not a problem for such files,
6090 so do not warn about them. */
6091 && ! is_debuginfo_file (abfd
))
6093 /* xgettext:c-format */
6094 (_("%pB: warning: allocated section `%s' not in segment"),
6096 (hdr
->bfd_section
== NULL
6098 : hdr
->bfd_section
->name
));
6099 /* We don't need to page align empty sections. */
6100 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
6101 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6104 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
6106 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
6109 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6110 && hdr
->bfd_section
== NULL
)
6111 /* We don't know the offset of these sections yet: their size has
6112 not been decided. */
6113 || (hdr
->bfd_section
!= NULL
6114 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6115 || (bfd_section_is_ctf (hdr
->bfd_section
)
6116 && abfd
->is_linker_output
)))
6117 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
6118 || (elf_symtab_shndx_list (abfd
) != NULL
6119 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6120 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
6121 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
6122 hdr
->sh_offset
= -1;
6124 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6126 elf_next_file_pos (abfd
) = off
;
6128 /* Now that we have set the section file positions, we can set up
6129 the file positions for the non PT_LOAD segments. */
6130 phdrs
= elf_tdata (abfd
)->phdr
;
6131 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
6133 if (p
->p_type
== PT_GNU_RELRO
)
6138 if (link_info
!= NULL
)
6140 /* During linking the range of the RELRO segment is passed
6141 in link_info. Note that there may be padding between
6142 relro_start and the first RELRO section. */
6143 start
= link_info
->relro_start
;
6144 end
= link_info
->relro_end
;
6146 else if (m
->count
!= 0)
6148 if (!m
->p_size_valid
)
6150 start
= m
->sections
[0]->vma
;
6151 end
= start
+ m
->p_size
;
6162 struct elf_segment_map
*lm
;
6163 const Elf_Internal_Phdr
*lp
;
6166 /* Find a LOAD segment containing a section in the RELRO
6168 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
6170 lm
= lm
->next
, lp
++)
6172 if (lp
->p_type
== PT_LOAD
6174 && (lm
->sections
[lm
->count
- 1]->vma
6175 + (!IS_TBSS (lm
->sections
[lm
->count
- 1])
6176 ? lm
->sections
[lm
->count
- 1]->size
6178 && lm
->sections
[0]->vma
< end
)
6184 /* Find the section starting the RELRO segment. */
6185 for (i
= 0; i
< lm
->count
; i
++)
6187 asection
*s
= lm
->sections
[i
];
6196 p
->p_vaddr
= lm
->sections
[i
]->vma
;
6197 p
->p_paddr
= lm
->sections
[i
]->lma
;
6198 p
->p_offset
= lm
->sections
[i
]->filepos
;
6199 p
->p_memsz
= end
- p
->p_vaddr
;
6200 p
->p_filesz
= p
->p_memsz
;
6202 /* The RELRO segment typically ends a few bytes
6203 into .got.plt but other layouts are possible.
6204 In cases where the end does not match any
6205 loaded section (for instance is in file
6206 padding), trim p_filesz back to correspond to
6207 the end of loaded section contents. */
6208 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
6209 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
6211 /* Preserve the alignment and flags if they are
6212 valid. The gold linker generates RW/4 for
6213 the PT_GNU_RELRO section. It is better for
6214 objcopy/strip to honor these attributes
6215 otherwise gdb will choke when using separate
6217 if (!m
->p_align_valid
)
6219 if (!m
->p_flags_valid
)
6225 if (link_info
!= NULL
)
6228 memset (p
, 0, sizeof *p
);
6230 else if (p
->p_type
== PT_GNU_STACK
)
6232 if (m
->p_size_valid
)
6233 p
->p_memsz
= m
->p_size
;
6235 else if (m
->count
!= 0)
6239 if (p
->p_type
!= PT_LOAD
6240 && (p
->p_type
!= PT_NOTE
6241 || bfd_get_format (abfd
) != bfd_core
))
6243 /* A user specified segment layout may include a PHDR
6244 segment that overlaps with a LOAD segment... */
6245 if (p
->p_type
== PT_PHDR
)
6251 if (m
->includes_filehdr
|| m
->includes_phdrs
)
6253 /* PR 17512: file: 2195325e. */
6255 (_("%pB: error: non-load segment %d includes file header "
6256 "and/or program header"),
6257 abfd
, (int) (p
- phdrs
));
6262 p
->p_offset
= m
->sections
[0]->filepos
;
6263 for (i
= m
->count
; i
-- != 0;)
6265 asection
*sect
= m
->sections
[i
];
6266 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
6267 if (hdr
->sh_type
!= SHT_NOBITS
)
6269 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
6281 static elf_section_list
*
6282 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6284 for (;list
!= NULL
; list
= list
->next
)
6290 /* Work out the file positions of all the sections. This is called by
6291 _bfd_elf_compute_section_file_positions. All the section sizes and
6292 VMAs must be known before this is called.
6294 Reloc sections come in two flavours: Those processed specially as
6295 "side-channel" data attached to a section to which they apply, and those that
6296 bfd doesn't process as relocations. The latter sort are stored in a normal
6297 bfd section by bfd_section_from_shdr. We don't consider the former sort
6298 here, unless they form part of the loadable image. Reloc sections not
6299 assigned here (and compressed debugging sections and CTF sections which
6300 nothing else in the file can rely upon) will be handled later by
6301 assign_file_positions_for_relocs.
6303 We also don't set the positions of the .symtab and .strtab here. */
6306 assign_file_positions_except_relocs (bfd
*abfd
,
6307 struct bfd_link_info
*link_info
)
6309 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6310 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6311 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6314 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6315 && bfd_get_format (abfd
) != bfd_core
)
6317 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6318 unsigned int num_sec
= elf_numsections (abfd
);
6319 Elf_Internal_Shdr
**hdrpp
;
6323 /* Start after the ELF header. */
6324 off
= i_ehdrp
->e_ehsize
;
6326 /* We are not creating an executable, which means that we are
6327 not creating a program header, and that the actual order of
6328 the sections in the file is unimportant. */
6329 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6331 Elf_Internal_Shdr
*hdr
;
6334 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6335 && hdr
->bfd_section
== NULL
)
6336 /* Do not assign offsets for these sections yet: we don't know
6338 || (hdr
->bfd_section
!= NULL
6339 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
6340 || (bfd_section_is_ctf (hdr
->bfd_section
)
6341 && abfd
->is_linker_output
)))
6342 || i
== elf_onesymtab (abfd
)
6343 || (elf_symtab_shndx_list (abfd
) != NULL
6344 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6345 || i
== elf_strtab_sec (abfd
)
6346 || i
== elf_shstrtab_sec (abfd
))
6348 hdr
->sh_offset
= -1;
6351 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6354 elf_next_file_pos (abfd
) = off
;
6355 elf_program_header_size (abfd
) = 0;
6359 /* Assign file positions for the loaded sections based on the
6360 assignment of sections to segments. */
6361 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6364 /* And for non-load sections. */
6365 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6369 if (!(*bed
->elf_backend_modify_headers
) (abfd
, link_info
))
6372 /* Write out the program headers. */
6373 alloc
= i_ehdrp
->e_phnum
;
6376 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0
6377 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6385 _bfd_elf_init_file_header (bfd
*abfd
,
6386 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
6388 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6389 struct elf_strtab_hash
*shstrtab
;
6390 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6392 i_ehdrp
= elf_elfheader (abfd
);
6394 shstrtab
= _bfd_elf_strtab_init ();
6395 if (shstrtab
== NULL
)
6398 elf_shstrtab (abfd
) = shstrtab
;
6400 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6401 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6402 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6403 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6405 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6406 i_ehdrp
->e_ident
[EI_DATA
] =
6407 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6408 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6410 if ((abfd
->flags
& DYNAMIC
) != 0)
6411 i_ehdrp
->e_type
= ET_DYN
;
6412 else if ((abfd
->flags
& EXEC_P
) != 0)
6413 i_ehdrp
->e_type
= ET_EXEC
;
6414 else if (bfd_get_format (abfd
) == bfd_core
)
6415 i_ehdrp
->e_type
= ET_CORE
;
6417 i_ehdrp
->e_type
= ET_REL
;
6419 switch (bfd_get_arch (abfd
))
6421 case bfd_arch_unknown
:
6422 i_ehdrp
->e_machine
= EM_NONE
;
6425 /* There used to be a long list of cases here, each one setting
6426 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6427 in the corresponding bfd definition. To avoid duplication,
6428 the switch was removed. Machines that need special handling
6429 can generally do it in elf_backend_final_write_processing(),
6430 unless they need the information earlier than the final write.
6431 Such need can generally be supplied by replacing the tests for
6432 e_machine with the conditions used to determine it. */
6434 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6437 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6438 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6440 /* No program header, for now. */
6441 i_ehdrp
->e_phoff
= 0;
6442 i_ehdrp
->e_phentsize
= 0;
6443 i_ehdrp
->e_phnum
= 0;
6445 /* Each bfd section is section header entry. */
6446 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6447 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6449 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6450 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6451 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6452 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6453 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6454 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6455 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6456 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6457 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6463 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=.
6465 FIXME: We used to have code here to sort the PT_LOAD segments into
6466 ascending order, as per the ELF spec. But this breaks some programs,
6467 including the Linux kernel. But really either the spec should be
6468 changed or the programs updated. */
6471 _bfd_elf_modify_headers (bfd
*obfd
, struct bfd_link_info
*link_info
)
6473 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6475 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (obfd
);
6476 unsigned int num_segments
= i_ehdrp
->e_phnum
;
6477 struct elf_obj_tdata
*tdata
= elf_tdata (obfd
);
6478 Elf_Internal_Phdr
*segment
= tdata
->phdr
;
6479 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6481 /* Find the lowest p_vaddr in PT_LOAD segments. */
6482 bfd_vma p_vaddr
= (bfd_vma
) -1;
6483 for (; segment
< end_segment
; segment
++)
6484 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6485 p_vaddr
= segment
->p_vaddr
;
6487 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6488 segments is non-zero. */
6490 i_ehdrp
->e_type
= ET_EXEC
;
6495 /* Assign file positions for all the reloc sections which are not part
6496 of the loadable file image, and the file position of section headers. */
6499 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6502 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6503 Elf_Internal_Shdr
*shdrp
;
6504 Elf_Internal_Ehdr
*i_ehdrp
;
6505 const struct elf_backend_data
*bed
;
6507 off
= elf_next_file_pos (abfd
);
6509 shdrpp
= elf_elfsections (abfd
);
6510 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6511 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6514 if (shdrp
->sh_offset
== -1)
6516 asection
*sec
= shdrp
->bfd_section
;
6517 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6518 || shdrp
->sh_type
== SHT_RELA
);
6519 bfd_boolean is_ctf
= sec
&& bfd_section_is_ctf (sec
);
6522 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6524 if (!is_rel
&& !is_ctf
)
6526 const char *name
= sec
->name
;
6527 struct bfd_elf_section_data
*d
;
6529 /* Compress DWARF debug sections. */
6530 if (!bfd_compress_section (abfd
, sec
,
6534 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6535 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6537 /* If section is compressed with zlib-gnu, convert
6538 section name from .debug_* to .zdebug_*. */
6540 = convert_debug_to_zdebug (abfd
, name
);
6541 if (new_name
== NULL
)
6545 /* Add section name to section name section. */
6546 if (shdrp
->sh_name
!= (unsigned int) -1)
6549 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6551 d
= elf_section_data (sec
);
6553 /* Add reloc section name to section name section. */
6555 && !_bfd_elf_set_reloc_sh_name (abfd
,
6560 && !_bfd_elf_set_reloc_sh_name (abfd
,
6565 /* Update section size and contents. */
6566 shdrp
->sh_size
= sec
->size
;
6567 shdrp
->contents
= sec
->contents
;
6568 shdrp
->bfd_section
->contents
= NULL
;
6572 /* Update section size and contents. */
6573 shdrp
->sh_size
= sec
->size
;
6574 shdrp
->contents
= sec
->contents
;
6577 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6584 /* Place section name section after DWARF debug sections have been
6586 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6587 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6588 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6589 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6591 /* Place the section headers. */
6592 i_ehdrp
= elf_elfheader (abfd
);
6593 bed
= get_elf_backend_data (abfd
);
6594 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6595 i_ehdrp
->e_shoff
= off
;
6596 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6597 elf_next_file_pos (abfd
) = off
;
6603 _bfd_elf_write_object_contents (bfd
*abfd
)
6605 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6606 Elf_Internal_Shdr
**i_shdrp
;
6608 unsigned int count
, num_sec
;
6609 struct elf_obj_tdata
*t
;
6611 if (! abfd
->output_has_begun
6612 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6614 /* Do not rewrite ELF data when the BFD has been opened for update.
6615 abfd->output_has_begun was set to TRUE on opening, so creation of new
6616 sections, and modification of existing section sizes was restricted.
6617 This means the ELF header, program headers and section headers can't have
6619 If the contents of any sections has been modified, then those changes have
6620 already been written to the BFD. */
6621 else if (abfd
->direction
== both_direction
)
6623 BFD_ASSERT (abfd
->output_has_begun
);
6627 i_shdrp
= elf_elfsections (abfd
);
6630 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6634 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6637 /* After writing the headers, we need to write the sections too... */
6638 num_sec
= elf_numsections (abfd
);
6639 for (count
= 1; count
< num_sec
; count
++)
6641 i_shdrp
[count
]->sh_name
6642 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6643 i_shdrp
[count
]->sh_name
);
6644 if (bed
->elf_backend_section_processing
)
6645 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6647 if (i_shdrp
[count
]->contents
)
6649 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6651 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6652 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6657 /* Write out the section header names. */
6658 t
= elf_tdata (abfd
);
6659 if (elf_shstrtab (abfd
) != NULL
6660 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6661 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6664 if (!(*bed
->elf_backend_final_write_processing
) (abfd
))
6667 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6670 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6671 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6672 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6678 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6680 /* Hopefully this can be done just like an object file. */
6681 return _bfd_elf_write_object_contents (abfd
);
6684 /* Given a section, search the header to find them. */
6687 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6689 const struct elf_backend_data
*bed
;
6690 unsigned int sec_index
;
6692 if (elf_section_data (asect
) != NULL
6693 && elf_section_data (asect
)->this_idx
!= 0)
6694 return elf_section_data (asect
)->this_idx
;
6696 if (bfd_is_abs_section (asect
))
6697 sec_index
= SHN_ABS
;
6698 else if (bfd_is_com_section (asect
))
6699 sec_index
= SHN_COMMON
;
6700 else if (bfd_is_und_section (asect
))
6701 sec_index
= SHN_UNDEF
;
6703 sec_index
= SHN_BAD
;
6705 bed
= get_elf_backend_data (abfd
);
6706 if (bed
->elf_backend_section_from_bfd_section
)
6708 int retval
= sec_index
;
6710 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6714 if (sec_index
== SHN_BAD
)
6715 bfd_set_error (bfd_error_nonrepresentable_section
);
6720 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6724 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6726 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6728 flagword flags
= asym_ptr
->flags
;
6730 /* When gas creates relocations against local labels, it creates its
6731 own symbol for the section, but does put the symbol into the
6732 symbol chain, so udata is 0. When the linker is generating
6733 relocatable output, this section symbol may be for one of the
6734 input sections rather than the output section. */
6735 if (asym_ptr
->udata
.i
== 0
6736 && (flags
& BSF_SECTION_SYM
)
6737 && asym_ptr
->section
)
6742 sec
= asym_ptr
->section
;
6743 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6744 sec
= sec
->output_section
;
6745 if (sec
->owner
== abfd
6746 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6747 && elf_section_syms (abfd
)[indx
] != NULL
)
6748 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6751 idx
= asym_ptr
->udata
.i
;
6755 /* This case can occur when using --strip-symbol on a symbol
6756 which is used in a relocation entry. */
6758 /* xgettext:c-format */
6759 (_("%pB: symbol `%s' required but not present"),
6760 abfd
, bfd_asymbol_name (asym_ptr
));
6761 bfd_set_error (bfd_error_no_symbols
);
6768 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6769 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6777 /* Rewrite program header information. */
6780 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6782 Elf_Internal_Ehdr
*iehdr
;
6783 struct elf_segment_map
*map
;
6784 struct elf_segment_map
*map_first
;
6785 struct elf_segment_map
**pointer_to_map
;
6786 Elf_Internal_Phdr
*segment
;
6789 unsigned int num_segments
;
6790 bfd_boolean phdr_included
= FALSE
;
6791 bfd_boolean p_paddr_valid
;
6792 bfd_vma maxpagesize
;
6793 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6794 unsigned int phdr_adjust_num
= 0;
6795 const struct elf_backend_data
*bed
;
6797 bed
= get_elf_backend_data (ibfd
);
6798 iehdr
= elf_elfheader (ibfd
);
6801 pointer_to_map
= &map_first
;
6803 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6804 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6806 /* Returns the end address of the segment + 1. */
6807 #define SEGMENT_END(segment, start) \
6808 (start + (segment->p_memsz > segment->p_filesz \
6809 ? segment->p_memsz : segment->p_filesz))
6811 #define SECTION_SIZE(section, segment) \
6812 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6813 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6814 ? section->size : 0)
6816 /* Returns TRUE if the given section is contained within
6817 the given segment. VMA addresses are compared. */
6818 #define IS_CONTAINED_BY_VMA(section, segment) \
6819 (section->vma >= segment->p_vaddr \
6820 && (section->vma + SECTION_SIZE (section, segment) \
6821 <= (SEGMENT_END (segment, segment->p_vaddr))))
6823 /* Returns TRUE if the given section is contained within
6824 the given segment. LMA addresses are compared. */
6825 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6826 (section->lma >= base \
6827 && (section->lma + SECTION_SIZE (section, segment) >= section->lma) \
6828 && (section->lma + SECTION_SIZE (section, segment) \
6829 <= SEGMENT_END (segment, base)))
6831 /* Handle PT_NOTE segment. */
6832 #define IS_NOTE(p, s) \
6833 (p->p_type == PT_NOTE \
6834 && elf_section_type (s) == SHT_NOTE \
6835 && (bfd_vma) s->filepos >= p->p_offset \
6836 && ((bfd_vma) s->filepos + s->size \
6837 <= p->p_offset + p->p_filesz))
6839 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6841 #define IS_COREFILE_NOTE(p, s) \
6843 && bfd_get_format (ibfd) == bfd_core \
6847 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6848 linker, which generates a PT_INTERP section with p_vaddr and
6849 p_memsz set to 0. */
6850 #define IS_SOLARIS_PT_INTERP(p, s) \
6852 && p->p_paddr == 0 \
6853 && p->p_memsz == 0 \
6854 && p->p_filesz > 0 \
6855 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6857 && (bfd_vma) s->filepos >= p->p_offset \
6858 && ((bfd_vma) s->filepos + s->size \
6859 <= p->p_offset + p->p_filesz))
6861 /* Decide if the given section should be included in the given segment.
6862 A section will be included if:
6863 1. It is within the address space of the segment -- we use the LMA
6864 if that is set for the segment and the VMA otherwise,
6865 2. It is an allocated section or a NOTE section in a PT_NOTE
6867 3. There is an output section associated with it,
6868 4. The section has not already been allocated to a previous segment.
6869 5. PT_GNU_STACK segments do not include any sections.
6870 6. PT_TLS segment includes only SHF_TLS sections.
6871 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6872 8. PT_DYNAMIC should not contain empty sections at the beginning
6873 (with the possible exception of .dynamic). */
6874 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6875 ((((segment->p_paddr \
6876 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6877 : IS_CONTAINED_BY_VMA (section, segment)) \
6878 && (section->flags & SEC_ALLOC) != 0) \
6879 || IS_NOTE (segment, section)) \
6880 && segment->p_type != PT_GNU_STACK \
6881 && (segment->p_type != PT_TLS \
6882 || (section->flags & SEC_THREAD_LOCAL)) \
6883 && (segment->p_type == PT_LOAD \
6884 || segment->p_type == PT_TLS \
6885 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6886 && (segment->p_type != PT_DYNAMIC \
6887 || SECTION_SIZE (section, segment) > 0 \
6888 || (segment->p_paddr \
6889 ? segment->p_paddr != section->lma \
6890 : segment->p_vaddr != section->vma) \
6891 || (strcmp (bfd_section_name (section), ".dynamic") == 0)) \
6892 && (segment->p_type != PT_LOAD || !section->segment_mark))
6894 /* If the output section of a section in the input segment is NULL,
6895 it is removed from the corresponding output segment. */
6896 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6897 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6898 && section->output_section != NULL)
6900 /* Returns TRUE iff seg1 starts after the end of seg2. */
6901 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6902 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6904 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6905 their VMA address ranges and their LMA address ranges overlap.
6906 It is possible to have overlapping VMA ranges without overlapping LMA
6907 ranges. RedBoot images for example can have both .data and .bss mapped
6908 to the same VMA range, but with the .data section mapped to a different
6910 #define SEGMENT_OVERLAPS(seg1, seg2) \
6911 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6912 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6913 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6914 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6916 /* Initialise the segment mark field. */
6917 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6918 section
->segment_mark
= FALSE
;
6920 /* The Solaris linker creates program headers in which all the
6921 p_paddr fields are zero. When we try to objcopy or strip such a
6922 file, we get confused. Check for this case, and if we find it
6923 don't set the p_paddr_valid fields. */
6924 p_paddr_valid
= FALSE
;
6925 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6928 if (segment
->p_paddr
!= 0)
6930 p_paddr_valid
= TRUE
;
6934 /* Scan through the segments specified in the program header
6935 of the input BFD. For this first scan we look for overlaps
6936 in the loadable segments. These can be created by weird
6937 parameters to objcopy. Also, fix some solaris weirdness. */
6938 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6943 Elf_Internal_Phdr
*segment2
;
6945 if (segment
->p_type
== PT_INTERP
)
6946 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6947 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6949 /* Mininal change so that the normal section to segment
6950 assignment code will work. */
6951 segment
->p_vaddr
= section
->vma
;
6955 if (segment
->p_type
!= PT_LOAD
)
6957 /* Remove PT_GNU_RELRO segment. */
6958 if (segment
->p_type
== PT_GNU_RELRO
)
6959 segment
->p_type
= PT_NULL
;
6963 /* Determine if this segment overlaps any previous segments. */
6964 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6966 bfd_signed_vma extra_length
;
6968 if (segment2
->p_type
!= PT_LOAD
6969 || !SEGMENT_OVERLAPS (segment
, segment2
))
6972 /* Merge the two segments together. */
6973 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6975 /* Extend SEGMENT2 to include SEGMENT and then delete
6977 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6978 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6980 if (extra_length
> 0)
6982 segment2
->p_memsz
+= extra_length
;
6983 segment2
->p_filesz
+= extra_length
;
6986 segment
->p_type
= PT_NULL
;
6988 /* Since we have deleted P we must restart the outer loop. */
6990 segment
= elf_tdata (ibfd
)->phdr
;
6995 /* Extend SEGMENT to include SEGMENT2 and then delete
6997 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
6998 - SEGMENT_END (segment
, segment
->p_vaddr
));
7000 if (extra_length
> 0)
7002 segment
->p_memsz
+= extra_length
;
7003 segment
->p_filesz
+= extra_length
;
7006 segment2
->p_type
= PT_NULL
;
7011 /* The second scan attempts to assign sections to segments. */
7012 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7016 unsigned int section_count
;
7017 asection
**sections
;
7018 asection
*output_section
;
7020 asection
*matching_lma
;
7021 asection
*suggested_lma
;
7024 asection
*first_section
;
7026 if (segment
->p_type
== PT_NULL
)
7029 first_section
= NULL
;
7030 /* Compute how many sections might be placed into this segment. */
7031 for (section
= ibfd
->sections
, section_count
= 0;
7033 section
= section
->next
)
7035 /* Find the first section in the input segment, which may be
7036 removed from the corresponding output segment. */
7037 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
7039 if (first_section
== NULL
)
7040 first_section
= section
;
7041 if (section
->output_section
!= NULL
)
7046 /* Allocate a segment map big enough to contain
7047 all of the sections we have selected. */
7048 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7049 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7050 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7054 /* Initialise the fields of the segment map. Default to
7055 using the physical address of the segment in the input BFD. */
7057 map
->p_type
= segment
->p_type
;
7058 map
->p_flags
= segment
->p_flags
;
7059 map
->p_flags_valid
= 1;
7061 /* If the first section in the input segment is removed, there is
7062 no need to preserve segment physical address in the corresponding
7064 if (!first_section
|| first_section
->output_section
!= NULL
)
7066 map
->p_paddr
= segment
->p_paddr
;
7067 map
->p_paddr_valid
= p_paddr_valid
;
7070 /* Determine if this segment contains the ELF file header
7071 and if it contains the program headers themselves. */
7072 map
->includes_filehdr
= (segment
->p_offset
== 0
7073 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7074 map
->includes_phdrs
= 0;
7076 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
7078 map
->includes_phdrs
=
7079 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7080 && (segment
->p_offset
+ segment
->p_filesz
7081 >= ((bfd_vma
) iehdr
->e_phoff
7082 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7084 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7085 phdr_included
= TRUE
;
7088 if (section_count
== 0)
7090 /* Special segments, such as the PT_PHDR segment, may contain
7091 no sections, but ordinary, loadable segments should contain
7092 something. They are allowed by the ELF spec however, so only
7093 a warning is produced.
7094 There is however the valid use case of embedded systems which
7095 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
7096 flash memory with zeros. No warning is shown for that case. */
7097 if (segment
->p_type
== PT_LOAD
7098 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
7099 /* xgettext:c-format */
7101 (_("%pB: warning: empty loadable segment detected"
7102 " at vaddr=%#" PRIx64
", is this intentional?"),
7103 ibfd
, (uint64_t) segment
->p_vaddr
);
7105 map
->p_vaddr_offset
= segment
->p_vaddr
;
7107 *pointer_to_map
= map
;
7108 pointer_to_map
= &map
->next
;
7113 /* Now scan the sections in the input BFD again and attempt
7114 to add their corresponding output sections to the segment map.
7115 The problem here is how to handle an output section which has
7116 been moved (ie had its LMA changed). There are four possibilities:
7118 1. None of the sections have been moved.
7119 In this case we can continue to use the segment LMA from the
7122 2. All of the sections have been moved by the same amount.
7123 In this case we can change the segment's LMA to match the LMA
7124 of the first section.
7126 3. Some of the sections have been moved, others have not.
7127 In this case those sections which have not been moved can be
7128 placed in the current segment which will have to have its size,
7129 and possibly its LMA changed, and a new segment or segments will
7130 have to be created to contain the other sections.
7132 4. The sections have been moved, but not by the same amount.
7133 In this case we can change the segment's LMA to match the LMA
7134 of the first section and we will have to create a new segment
7135 or segments to contain the other sections.
7137 In order to save time, we allocate an array to hold the section
7138 pointers that we are interested in. As these sections get assigned
7139 to a segment, they are removed from this array. */
7141 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
7142 if (sections
== NULL
)
7145 /* Step One: Scan for segment vs section LMA conflicts.
7146 Also add the sections to the section array allocated above.
7147 Also add the sections to the current segment. In the common
7148 case, where the sections have not been moved, this means that
7149 we have completely filled the segment, and there is nothing
7152 matching_lma
= NULL
;
7153 suggested_lma
= NULL
;
7155 for (section
= first_section
, j
= 0;
7157 section
= section
->next
)
7159 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
7161 output_section
= section
->output_section
;
7163 sections
[j
++] = section
;
7165 /* The Solaris native linker always sets p_paddr to 0.
7166 We try to catch that case here, and set it to the
7167 correct value. Note - some backends require that
7168 p_paddr be left as zero. */
7170 && segment
->p_vaddr
!= 0
7171 && !bed
->want_p_paddr_set_to_zero
7173 && output_section
->lma
!= 0
7174 && (align_power (segment
->p_vaddr
7175 + (map
->includes_filehdr
7176 ? iehdr
->e_ehsize
: 0)
7177 + (map
->includes_phdrs
7178 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7180 output_section
->alignment_power
)
7181 == output_section
->vma
))
7182 map
->p_paddr
= segment
->p_vaddr
;
7184 /* Match up the physical address of the segment with the
7185 LMA address of the output section. */
7186 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7187 || IS_COREFILE_NOTE (segment
, section
)
7188 || (bed
->want_p_paddr_set_to_zero
7189 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
7191 if (matching_lma
== NULL
7192 || output_section
->lma
< matching_lma
->lma
)
7193 matching_lma
= output_section
;
7195 /* We assume that if the section fits within the segment
7196 then it does not overlap any other section within that
7198 map
->sections
[isec
++] = output_section
;
7200 else if (suggested_lma
== NULL
)
7201 suggested_lma
= output_section
;
7203 if (j
== section_count
)
7208 BFD_ASSERT (j
== section_count
);
7210 /* Step Two: Adjust the physical address of the current segment,
7212 if (isec
== section_count
)
7214 /* All of the sections fitted within the segment as currently
7215 specified. This is the default case. Add the segment to
7216 the list of built segments and carry on to process the next
7217 program header in the input BFD. */
7218 map
->count
= section_count
;
7219 *pointer_to_map
= map
;
7220 pointer_to_map
= &map
->next
;
7223 && !bed
->want_p_paddr_set_to_zero
)
7225 bfd_vma hdr_size
= 0;
7226 if (map
->includes_filehdr
)
7227 hdr_size
= iehdr
->e_ehsize
;
7228 if (map
->includes_phdrs
)
7229 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7231 /* Account for padding before the first section in the
7233 map
->p_vaddr_offset
= map
->p_paddr
+ hdr_size
- matching_lma
->lma
;
7241 /* Change the current segment's physical address to match
7242 the LMA of the first section that fitted, or if no
7243 section fitted, the first section. */
7244 if (matching_lma
== NULL
)
7245 matching_lma
= suggested_lma
;
7247 map
->p_paddr
= matching_lma
->lma
;
7249 /* Offset the segment physical address from the lma
7250 to allow for space taken up by elf headers. */
7251 if (map
->includes_phdrs
)
7253 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7255 /* iehdr->e_phnum is just an estimate of the number
7256 of program headers that we will need. Make a note
7257 here of the number we used and the segment we chose
7258 to hold these headers, so that we can adjust the
7259 offset when we know the correct value. */
7260 phdr_adjust_num
= iehdr
->e_phnum
;
7261 phdr_adjust_seg
= map
;
7264 if (map
->includes_filehdr
)
7266 bfd_vma align
= (bfd_vma
) 1 << matching_lma
->alignment_power
;
7267 map
->p_paddr
-= iehdr
->e_ehsize
;
7268 /* We've subtracted off the size of headers from the
7269 first section lma, but there may have been some
7270 alignment padding before that section too. Try to
7271 account for that by adjusting the segment lma down to
7272 the same alignment. */
7273 if (segment
->p_align
!= 0 && segment
->p_align
< align
)
7274 align
= segment
->p_align
;
7275 map
->p_paddr
&= -align
;
7279 /* Step Three: Loop over the sections again, this time assigning
7280 those that fit to the current segment and removing them from the
7281 sections array; but making sure not to leave large gaps. Once all
7282 possible sections have been assigned to the current segment it is
7283 added to the list of built segments and if sections still remain
7284 to be assigned, a new segment is constructed before repeating
7290 suggested_lma
= NULL
;
7292 /* Fill the current segment with sections that fit. */
7293 for (j
= 0; j
< section_count
; j
++)
7295 section
= sections
[j
];
7297 if (section
== NULL
)
7300 output_section
= section
->output_section
;
7302 BFD_ASSERT (output_section
!= NULL
);
7304 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7305 || IS_COREFILE_NOTE (segment
, section
))
7307 if (map
->count
== 0)
7309 /* If the first section in a segment does not start at
7310 the beginning of the segment, then something is
7312 if (align_power (map
->p_paddr
7313 + (map
->includes_filehdr
7314 ? iehdr
->e_ehsize
: 0)
7315 + (map
->includes_phdrs
7316 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7318 output_section
->alignment_power
)
7319 != output_section
->lma
)
7326 prev_sec
= map
->sections
[map
->count
- 1];
7328 /* If the gap between the end of the previous section
7329 and the start of this section is more than
7330 maxpagesize then we need to start a new segment. */
7331 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7333 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7334 || (prev_sec
->lma
+ prev_sec
->size
7335 > output_section
->lma
))
7337 if (suggested_lma
== NULL
)
7338 suggested_lma
= output_section
;
7344 map
->sections
[map
->count
++] = output_section
;
7347 if (segment
->p_type
== PT_LOAD
)
7348 section
->segment_mark
= TRUE
;
7350 else if (suggested_lma
== NULL
)
7351 suggested_lma
= output_section
;
7354 /* PR 23932. A corrupt input file may contain sections that cannot
7355 be assigned to any segment - because for example they have a
7356 negative size - or segments that do not contain any sections. */
7357 if (map
->count
== 0)
7360 bfd_set_error (bfd_error_sorry
);
7365 /* Add the current segment to the list of built segments. */
7366 *pointer_to_map
= map
;
7367 pointer_to_map
= &map
->next
;
7369 if (isec
< section_count
)
7371 /* We still have not allocated all of the sections to
7372 segments. Create a new segment here, initialise it
7373 and carry on looping. */
7374 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7375 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7376 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7383 /* Initialise the fields of the segment map. Set the physical
7384 physical address to the LMA of the first section that has
7385 not yet been assigned. */
7387 map
->p_type
= segment
->p_type
;
7388 map
->p_flags
= segment
->p_flags
;
7389 map
->p_flags_valid
= 1;
7390 map
->p_paddr
= suggested_lma
->lma
;
7391 map
->p_paddr_valid
= p_paddr_valid
;
7392 map
->includes_filehdr
= 0;
7393 map
->includes_phdrs
= 0;
7396 while (isec
< section_count
);
7401 elf_seg_map (obfd
) = map_first
;
7403 /* If we had to estimate the number of program headers that were
7404 going to be needed, then check our estimate now and adjust
7405 the offset if necessary. */
7406 if (phdr_adjust_seg
!= NULL
)
7410 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7413 if (count
> phdr_adjust_num
)
7414 phdr_adjust_seg
->p_paddr
7415 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7417 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
7418 if (map
->p_type
== PT_PHDR
)
7421 = phdr_adjust_seg
->includes_filehdr
? iehdr
->e_ehsize
: 0;
7422 map
->p_paddr
= phdr_adjust_seg
->p_paddr
+ adjust
;
7429 #undef IS_CONTAINED_BY_VMA
7430 #undef IS_CONTAINED_BY_LMA
7432 #undef IS_COREFILE_NOTE
7433 #undef IS_SOLARIS_PT_INTERP
7434 #undef IS_SECTION_IN_INPUT_SEGMENT
7435 #undef INCLUDE_SECTION_IN_SEGMENT
7436 #undef SEGMENT_AFTER_SEGMENT
7437 #undef SEGMENT_OVERLAPS
7441 /* Copy ELF program header information. */
7444 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7446 Elf_Internal_Ehdr
*iehdr
;
7447 struct elf_segment_map
*map
;
7448 struct elf_segment_map
*map_first
;
7449 struct elf_segment_map
**pointer_to_map
;
7450 Elf_Internal_Phdr
*segment
;
7452 unsigned int num_segments
;
7453 bfd_boolean phdr_included
= FALSE
;
7454 bfd_boolean p_paddr_valid
;
7456 iehdr
= elf_elfheader (ibfd
);
7459 pointer_to_map
= &map_first
;
7461 /* If all the segment p_paddr fields are zero, don't set
7462 map->p_paddr_valid. */
7463 p_paddr_valid
= FALSE
;
7464 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7465 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7468 if (segment
->p_paddr
!= 0)
7470 p_paddr_valid
= TRUE
;
7474 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7479 unsigned int section_count
;
7481 Elf_Internal_Shdr
*this_hdr
;
7482 asection
*first_section
= NULL
;
7483 asection
*lowest_section
;
7485 /* Compute how many sections are in this segment. */
7486 for (section
= ibfd
->sections
, section_count
= 0;
7488 section
= section
->next
)
7490 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7491 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7493 if (first_section
== NULL
)
7494 first_section
= section
;
7499 /* Allocate a segment map big enough to contain
7500 all of the sections we have selected. */
7501 amt
= sizeof (struct elf_segment_map
) - sizeof (asection
*);
7502 amt
+= (bfd_size_type
) section_count
* sizeof (asection
*);
7503 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7507 /* Initialize the fields of the output segment map with the
7510 map
->p_type
= segment
->p_type
;
7511 map
->p_flags
= segment
->p_flags
;
7512 map
->p_flags_valid
= 1;
7513 map
->p_paddr
= segment
->p_paddr
;
7514 map
->p_paddr_valid
= p_paddr_valid
;
7515 map
->p_align
= segment
->p_align
;
7516 map
->p_align_valid
= 1;
7517 map
->p_vaddr_offset
= 0;
7519 if (map
->p_type
== PT_GNU_RELRO
7520 || map
->p_type
== PT_GNU_STACK
)
7522 /* The PT_GNU_RELRO segment may contain the first a few
7523 bytes in the .got.plt section even if the whole .got.plt
7524 section isn't in the PT_GNU_RELRO segment. We won't
7525 change the size of the PT_GNU_RELRO segment.
7526 Similarly, PT_GNU_STACK size is significant on uclinux
7528 map
->p_size
= segment
->p_memsz
;
7529 map
->p_size_valid
= 1;
7532 /* Determine if this segment contains the ELF file header
7533 and if it contains the program headers themselves. */
7534 map
->includes_filehdr
= (segment
->p_offset
== 0
7535 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7537 map
->includes_phdrs
= 0;
7538 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7540 map
->includes_phdrs
=
7541 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7542 && (segment
->p_offset
+ segment
->p_filesz
7543 >= ((bfd_vma
) iehdr
->e_phoff
7544 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7546 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7547 phdr_included
= TRUE
;
7550 lowest_section
= NULL
;
7551 if (section_count
!= 0)
7553 unsigned int isec
= 0;
7555 for (section
= first_section
;
7557 section
= section
->next
)
7559 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7560 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7562 map
->sections
[isec
++] = section
->output_section
;
7563 if ((section
->flags
& SEC_ALLOC
) != 0)
7567 if (lowest_section
== NULL
7568 || section
->lma
< lowest_section
->lma
)
7569 lowest_section
= section
;
7571 /* Section lmas are set up from PT_LOAD header
7572 p_paddr in _bfd_elf_make_section_from_shdr.
7573 If this header has a p_paddr that disagrees
7574 with the section lma, flag the p_paddr as
7576 if ((section
->flags
& SEC_LOAD
) != 0)
7577 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7579 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7580 if (section
->lma
- segment
->p_paddr
!= seg_off
)
7581 map
->p_paddr_valid
= FALSE
;
7583 if (isec
== section_count
)
7589 if (section_count
== 0)
7590 map
->p_vaddr_offset
= segment
->p_vaddr
;
7591 else if (map
->p_paddr_valid
)
7593 /* Account for padding before the first section in the segment. */
7594 bfd_vma hdr_size
= 0;
7595 if (map
->includes_filehdr
)
7596 hdr_size
= iehdr
->e_ehsize
;
7597 if (map
->includes_phdrs
)
7598 hdr_size
+= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7600 map
->p_vaddr_offset
= (map
->p_paddr
+ hdr_size
7601 - (lowest_section
? lowest_section
->lma
: 0));
7604 map
->count
= section_count
;
7605 *pointer_to_map
= map
;
7606 pointer_to_map
= &map
->next
;
7609 elf_seg_map (obfd
) = map_first
;
7613 /* Copy private BFD data. This copies or rewrites ELF program header
7617 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7619 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7620 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7623 if (elf_tdata (ibfd
)->phdr
== NULL
)
7626 if (ibfd
->xvec
== obfd
->xvec
)
7628 /* Check to see if any sections in the input BFD
7629 covered by ELF program header have changed. */
7630 Elf_Internal_Phdr
*segment
;
7631 asection
*section
, *osec
;
7632 unsigned int i
, num_segments
;
7633 Elf_Internal_Shdr
*this_hdr
;
7634 const struct elf_backend_data
*bed
;
7636 bed
= get_elf_backend_data (ibfd
);
7638 /* Regenerate the segment map if p_paddr is set to 0. */
7639 if (bed
->want_p_paddr_set_to_zero
)
7642 /* Initialize the segment mark field. */
7643 for (section
= obfd
->sections
; section
!= NULL
;
7644 section
= section
->next
)
7645 section
->segment_mark
= FALSE
;
7647 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7648 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7652 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7653 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7654 which severly confuses things, so always regenerate the segment
7655 map in this case. */
7656 if (segment
->p_paddr
== 0
7657 && segment
->p_memsz
== 0
7658 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7661 for (section
= ibfd
->sections
;
7662 section
!= NULL
; section
= section
->next
)
7664 /* We mark the output section so that we know it comes
7665 from the input BFD. */
7666 osec
= section
->output_section
;
7668 osec
->segment_mark
= TRUE
;
7670 /* Check if this section is covered by the segment. */
7671 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7672 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7674 /* FIXME: Check if its output section is changed or
7675 removed. What else do we need to check? */
7677 || section
->flags
!= osec
->flags
7678 || section
->lma
!= osec
->lma
7679 || section
->vma
!= osec
->vma
7680 || section
->size
!= osec
->size
7681 || section
->rawsize
!= osec
->rawsize
7682 || section
->alignment_power
!= osec
->alignment_power
)
7688 /* Check to see if any output section do not come from the
7690 for (section
= obfd
->sections
; section
!= NULL
;
7691 section
= section
->next
)
7693 if (!section
->segment_mark
)
7696 section
->segment_mark
= FALSE
;
7699 return copy_elf_program_header (ibfd
, obfd
);
7703 if (ibfd
->xvec
== obfd
->xvec
)
7705 /* When rewriting program header, set the output maxpagesize to
7706 the maximum alignment of input PT_LOAD segments. */
7707 Elf_Internal_Phdr
*segment
;
7709 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7710 bfd_vma maxpagesize
= 0;
7712 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7715 if (segment
->p_type
== PT_LOAD
7716 && maxpagesize
< segment
->p_align
)
7718 /* PR 17512: file: f17299af. */
7719 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7720 /* xgettext:c-format */
7721 _bfd_error_handler (_("%pB: warning: segment alignment of %#"
7722 PRIx64
" is too large"),
7723 ibfd
, (uint64_t) segment
->p_align
);
7725 maxpagesize
= segment
->p_align
;
7728 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7729 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7732 return rewrite_elf_program_header (ibfd
, obfd
);
7735 /* Initialize private output section information from input section. */
7738 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7742 struct bfd_link_info
*link_info
)
7745 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7746 bfd_boolean final_link
= (link_info
!= NULL
7747 && !bfd_link_relocatable (link_info
));
7749 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7750 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7753 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7755 /* For objcopy and relocatable link, don't copy the output ELF
7756 section type from input if the output BFD section flags have been
7757 set to something different. For a final link allow some flags
7758 that the linker clears to differ. */
7759 if (elf_section_type (osec
) == SHT_NULL
7760 && (osec
->flags
== isec
->flags
7762 && ((osec
->flags
^ isec
->flags
)
7763 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7764 elf_section_type (osec
) = elf_section_type (isec
);
7766 /* FIXME: Is this correct for all OS/PROC specific flags? */
7767 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7768 & (SHF_MASKOS
| SHF_MASKPROC
));
7770 /* Copy sh_info from input for mbind section. */
7771 if ((elf_tdata (ibfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
) != 0
7772 && elf_section_flags (isec
) & SHF_GNU_MBIND
)
7773 elf_section_data (osec
)->this_hdr
.sh_info
7774 = elf_section_data (isec
)->this_hdr
.sh_info
;
7776 /* Set things up for objcopy and relocatable link. The output
7777 SHT_GROUP section will have its elf_next_in_group pointing back
7778 to the input group members. Ignore linker created group section.
7779 See elfNN_ia64_object_p in elfxx-ia64.c. */
7780 if ((link_info
== NULL
7781 || !link_info
->resolve_section_groups
)
7782 && (elf_sec_group (isec
) == NULL
7783 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7785 if (elf_section_flags (isec
) & SHF_GROUP
)
7786 elf_section_flags (osec
) |= SHF_GROUP
;
7787 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7788 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7791 /* If not decompress, preserve SHF_COMPRESSED. */
7792 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7793 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7796 ihdr
= &elf_section_data (isec
)->this_hdr
;
7798 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7799 don't use the output section of the linked-to section since it
7800 may be NULL at this point. */
7801 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7803 ohdr
= &elf_section_data (osec
)->this_hdr
;
7804 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7805 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7808 osec
->use_rela_p
= isec
->use_rela_p
;
7813 /* Copy private section information. This copies over the entsize
7814 field, and sometimes the info field. */
7817 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7822 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7824 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7825 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7828 ihdr
= &elf_section_data (isec
)->this_hdr
;
7829 ohdr
= &elf_section_data (osec
)->this_hdr
;
7831 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7833 if (ihdr
->sh_type
== SHT_SYMTAB
7834 || ihdr
->sh_type
== SHT_DYNSYM
7835 || ihdr
->sh_type
== SHT_GNU_verneed
7836 || ihdr
->sh_type
== SHT_GNU_verdef
)
7837 ohdr
->sh_info
= ihdr
->sh_info
;
7839 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7843 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7844 necessary if we are removing either the SHT_GROUP section or any of
7845 the group member sections. DISCARDED is the value that a section's
7846 output_section has if the section will be discarded, NULL when this
7847 function is called from objcopy, bfd_abs_section_ptr when called
7851 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7855 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7856 if (elf_section_type (isec
) == SHT_GROUP
)
7858 asection
*first
= elf_next_in_group (isec
);
7859 asection
*s
= first
;
7860 bfd_size_type removed
= 0;
7864 /* If this member section is being output but the
7865 SHT_GROUP section is not, then clear the group info
7866 set up by _bfd_elf_copy_private_section_data. */
7867 if (s
->output_section
!= discarded
7868 && isec
->output_section
== discarded
)
7870 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7871 elf_group_name (s
->output_section
) = NULL
;
7873 /* Conversely, if the member section is not being output
7874 but the SHT_GROUP section is, then adjust its size. */
7875 else if (s
->output_section
== discarded
7876 && isec
->output_section
!= discarded
)
7878 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7880 if (elf_sec
->rel
.hdr
!= NULL
7881 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7883 if (elf_sec
->rela
.hdr
!= NULL
7884 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7887 s
= elf_next_in_group (s
);
7893 if (discarded
!= NULL
)
7895 /* If we've been called for ld -r, then we need to
7896 adjust the input section size. */
7897 if (isec
->rawsize
== 0)
7898 isec
->rawsize
= isec
->size
;
7899 isec
->size
= isec
->rawsize
- removed
;
7900 if (isec
->size
<= 4)
7903 isec
->flags
|= SEC_EXCLUDE
;
7908 /* Adjust the output section size when called from
7910 isec
->output_section
->size
-= removed
;
7911 if (isec
->output_section
->size
<= 4)
7913 isec
->output_section
->size
= 0;
7914 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7923 /* Copy private header information. */
7926 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7928 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7929 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7932 /* Copy over private BFD data if it has not already been copied.
7933 This must be done here, rather than in the copy_private_bfd_data
7934 entry point, because the latter is called after the section
7935 contents have been set, which means that the program headers have
7936 already been worked out. */
7937 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7939 if (! copy_private_bfd_data (ibfd
, obfd
))
7943 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7946 /* Copy private symbol information. If this symbol is in a section
7947 which we did not map into a BFD section, try to map the section
7948 index correctly. We use special macro definitions for the mapped
7949 section indices; these definitions are interpreted by the
7950 swap_out_syms function. */
7952 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7953 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7954 #define MAP_STRTAB (SHN_HIOS + 3)
7955 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7956 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7959 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7964 elf_symbol_type
*isym
, *osym
;
7966 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7967 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7970 isym
= elf_symbol_from (ibfd
, isymarg
);
7971 osym
= elf_symbol_from (obfd
, osymarg
);
7974 && isym
->internal_elf_sym
.st_shndx
!= 0
7976 && bfd_is_abs_section (isym
->symbol
.section
))
7980 shndx
= isym
->internal_elf_sym
.st_shndx
;
7981 if (shndx
== elf_onesymtab (ibfd
))
7982 shndx
= MAP_ONESYMTAB
;
7983 else if (shndx
== elf_dynsymtab (ibfd
))
7984 shndx
= MAP_DYNSYMTAB
;
7985 else if (shndx
== elf_strtab_sec (ibfd
))
7987 else if (shndx
== elf_shstrtab_sec (ibfd
))
7988 shndx
= MAP_SHSTRTAB
;
7989 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
7990 shndx
= MAP_SYM_SHNDX
;
7991 osym
->internal_elf_sym
.st_shndx
= shndx
;
7997 /* Swap out the symbols. */
8000 swap_out_syms (bfd
*abfd
,
8001 struct elf_strtab_hash
**sttp
,
8004 const struct elf_backend_data
*bed
;
8007 struct elf_strtab_hash
*stt
;
8008 Elf_Internal_Shdr
*symtab_hdr
;
8009 Elf_Internal_Shdr
*symtab_shndx_hdr
;
8010 Elf_Internal_Shdr
*symstrtab_hdr
;
8011 struct elf_sym_strtab
*symstrtab
;
8012 bfd_byte
*outbound_syms
;
8013 bfd_byte
*outbound_shndx
;
8014 unsigned long outbound_syms_index
;
8015 unsigned long outbound_shndx_index
;
8017 unsigned int num_locals
;
8019 bfd_boolean name_local_sections
;
8021 if (!elf_map_symbols (abfd
, &num_locals
))
8024 /* Dump out the symtabs. */
8025 stt
= _bfd_elf_strtab_init ();
8029 bed
= get_elf_backend_data (abfd
);
8030 symcount
= bfd_get_symcount (abfd
);
8031 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8032 symtab_hdr
->sh_type
= SHT_SYMTAB
;
8033 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
8034 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
8035 symtab_hdr
->sh_info
= num_locals
+ 1;
8036 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
8038 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
8039 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8041 /* Allocate buffer to swap out the .strtab section. */
8042 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc2 (symcount
+ 1,
8043 sizeof (*symstrtab
));
8044 if (symstrtab
== NULL
)
8046 _bfd_elf_strtab_free (stt
);
8050 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
8051 bed
->s
->sizeof_sym
);
8052 if (outbound_syms
== NULL
)
8055 _bfd_elf_strtab_free (stt
);
8059 symtab_hdr
->contents
= outbound_syms
;
8060 outbound_syms_index
= 0;
8062 outbound_shndx
= NULL
;
8063 outbound_shndx_index
= 0;
8065 if (elf_symtab_shndx_list (abfd
))
8067 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
8068 if (symtab_shndx_hdr
->sh_name
!= 0)
8070 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
8071 outbound_shndx
= (bfd_byte
*)
8072 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
8073 if (outbound_shndx
== NULL
)
8076 symtab_shndx_hdr
->contents
= outbound_shndx
;
8077 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
8078 symtab_shndx_hdr
->sh_size
= amt
;
8079 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
8080 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
8082 /* FIXME: What about any other headers in the list ? */
8085 /* Now generate the data (for "contents"). */
8087 /* Fill in zeroth symbol and swap it out. */
8088 Elf_Internal_Sym sym
;
8094 sym
.st_shndx
= SHN_UNDEF
;
8095 sym
.st_target_internal
= 0;
8096 symstrtab
[0].sym
= sym
;
8097 symstrtab
[0].dest_index
= outbound_syms_index
;
8098 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
8099 outbound_syms_index
++;
8100 if (outbound_shndx
!= NULL
)
8101 outbound_shndx_index
++;
8105 = (bed
->elf_backend_name_local_section_symbols
8106 && bed
->elf_backend_name_local_section_symbols (abfd
));
8108 syms
= bfd_get_outsymbols (abfd
);
8109 for (idx
= 0; idx
< symcount
;)
8111 Elf_Internal_Sym sym
;
8112 bfd_vma value
= syms
[idx
]->value
;
8113 elf_symbol_type
*type_ptr
;
8114 flagword flags
= syms
[idx
]->flags
;
8117 if (!name_local_sections
8118 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
8120 /* Local section symbols have no name. */
8121 sym
.st_name
= (unsigned long) -1;
8125 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
8126 to get the final offset for st_name. */
8128 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
8130 if (sym
.st_name
== (unsigned long) -1)
8134 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
8136 if ((flags
& BSF_SECTION_SYM
) == 0
8137 && bfd_is_com_section (syms
[idx
]->section
))
8139 /* ELF common symbols put the alignment into the `value' field,
8140 and the size into the `size' field. This is backwards from
8141 how BFD handles it, so reverse it here. */
8142 sym
.st_size
= value
;
8143 if (type_ptr
== NULL
8144 || type_ptr
->internal_elf_sym
.st_value
== 0)
8145 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
8147 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
8148 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
8149 (abfd
, syms
[idx
]->section
);
8153 asection
*sec
= syms
[idx
]->section
;
8156 if (sec
->output_section
)
8158 value
+= sec
->output_offset
;
8159 sec
= sec
->output_section
;
8162 /* Don't add in the section vma for relocatable output. */
8163 if (! relocatable_p
)
8165 sym
.st_value
= value
;
8166 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
8168 if (bfd_is_abs_section (sec
)
8170 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
8172 /* This symbol is in a real ELF section which we did
8173 not create as a BFD section. Undo the mapping done
8174 by copy_private_symbol_data. */
8175 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
8179 shndx
= elf_onesymtab (abfd
);
8182 shndx
= elf_dynsymtab (abfd
);
8185 shndx
= elf_strtab_sec (abfd
);
8188 shndx
= elf_shstrtab_sec (abfd
);
8191 if (elf_symtab_shndx_list (abfd
))
8192 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
8201 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
8203 if (shndx
== SHN_BAD
)
8207 /* Writing this would be a hell of a lot easier if
8208 we had some decent documentation on bfd, and
8209 knew what to expect of the library, and what to
8210 demand of applications. For example, it
8211 appears that `objcopy' might not set the
8212 section of a symbol to be a section that is
8213 actually in the output file. */
8214 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
8216 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
8217 if (shndx
== SHN_BAD
)
8219 /* xgettext:c-format */
8221 (_("unable to find equivalent output section"
8222 " for symbol '%s' from section '%s'"),
8223 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
8225 bfd_set_error (bfd_error_invalid_operation
);
8231 sym
.st_shndx
= shndx
;
8234 if ((flags
& BSF_THREAD_LOCAL
) != 0)
8236 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
8237 type
= STT_GNU_IFUNC
;
8238 else if ((flags
& BSF_FUNCTION
) != 0)
8240 else if ((flags
& BSF_OBJECT
) != 0)
8242 else if ((flags
& BSF_RELC
) != 0)
8244 else if ((flags
& BSF_SRELC
) != 0)
8249 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
8252 /* Processor-specific types. */
8253 if (type_ptr
!= NULL
8254 && bed
->elf_backend_get_symbol_type
)
8255 type
= ((*bed
->elf_backend_get_symbol_type
)
8256 (&type_ptr
->internal_elf_sym
, type
));
8258 if (flags
& BSF_SECTION_SYM
)
8260 if (flags
& BSF_GLOBAL
)
8261 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
8263 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
8265 else if (bfd_is_com_section (syms
[idx
]->section
))
8267 if (type
!= STT_TLS
)
8269 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8270 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8271 ? STT_COMMON
: STT_OBJECT
);
8273 type
= ((flags
& BSF_ELF_COMMON
) != 0
8274 ? STT_COMMON
: STT_OBJECT
);
8276 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8278 else if (bfd_is_und_section (syms
[idx
]->section
))
8279 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8283 else if (flags
& BSF_FILE
)
8284 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8287 int bind
= STB_LOCAL
;
8289 if (flags
& BSF_LOCAL
)
8291 else if (flags
& BSF_GNU_UNIQUE
)
8292 bind
= STB_GNU_UNIQUE
;
8293 else if (flags
& BSF_WEAK
)
8295 else if (flags
& BSF_GLOBAL
)
8298 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8301 if (type_ptr
!= NULL
)
8303 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8304 sym
.st_target_internal
8305 = type_ptr
->internal_elf_sym
.st_target_internal
;
8310 sym
.st_target_internal
= 0;
8314 symstrtab
[idx
].sym
= sym
;
8315 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8316 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8318 outbound_syms_index
++;
8319 if (outbound_shndx
!= NULL
)
8320 outbound_shndx_index
++;
8323 /* Finalize the .strtab section. */
8324 _bfd_elf_strtab_finalize (stt
);
8326 /* Swap out the .strtab section. */
8327 for (idx
= 0; idx
<= symcount
; idx
++)
8329 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8330 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8331 elfsym
->sym
.st_name
= 0;
8333 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8334 elfsym
->sym
.st_name
);
8335 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8337 + (elfsym
->dest_index
8338 * bed
->s
->sizeof_sym
)),
8340 + (elfsym
->destshndx_index
8341 * sizeof (Elf_External_Sym_Shndx
))));
8346 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8347 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8348 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8349 symstrtab_hdr
->sh_addr
= 0;
8350 symstrtab_hdr
->sh_entsize
= 0;
8351 symstrtab_hdr
->sh_link
= 0;
8352 symstrtab_hdr
->sh_info
= 0;
8353 symstrtab_hdr
->sh_addralign
= 1;
8358 /* Return the number of bytes required to hold the symtab vector.
8360 Note that we base it on the count plus 1, since we will null terminate
8361 the vector allocated based on this size. However, the ELF symbol table
8362 always has a dummy entry as symbol #0, so it ends up even. */
8365 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8367 bfd_size_type symcount
;
8369 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8371 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8372 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8374 bfd_set_error (bfd_error_file_too_big
);
8377 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8379 symtab_size
-= sizeof (asymbol
*);
8385 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8387 bfd_size_type symcount
;
8389 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8391 if (elf_dynsymtab (abfd
) == 0)
8393 bfd_set_error (bfd_error_invalid_operation
);
8397 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8398 if (symcount
>= LONG_MAX
/ sizeof (asymbol
*))
8400 bfd_set_error (bfd_error_file_too_big
);
8403 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8405 symtab_size
-= sizeof (asymbol
*);
8411 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
8414 #if SIZEOF_LONG == SIZEOF_INT
8415 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
8417 bfd_set_error (bfd_error_file_too_big
);
8421 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8424 /* Canonicalize the relocs. */
8427 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8434 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8436 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
8439 tblptr
= section
->relocation
;
8440 for (i
= 0; i
< section
->reloc_count
; i
++)
8441 *relptr
++ = tblptr
++;
8445 return section
->reloc_count
;
8449 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8451 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8452 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
8455 abfd
->symcount
= symcount
;
8460 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8461 asymbol
**allocation
)
8463 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8464 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
8467 abfd
->dynsymcount
= symcount
;
8471 /* Return the size required for the dynamic reloc entries. Any loadable
8472 section that was actually installed in the BFD, and has type SHT_REL
8473 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8474 dynamic reloc section. */
8477 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8479 bfd_size_type count
;
8482 if (elf_dynsymtab (abfd
) == 0)
8484 bfd_set_error (bfd_error_invalid_operation
);
8489 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8490 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8491 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8492 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8494 count
+= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8495 if (count
> LONG_MAX
/ sizeof (arelent
*))
8497 bfd_set_error (bfd_error_file_too_big
);
8501 return count
* sizeof (arelent
*);
8504 /* Canonicalize the dynamic relocation entries. Note that we return the
8505 dynamic relocations as a single block, although they are actually
8506 associated with particular sections; the interface, which was
8507 designed for SunOS style shared libraries, expects that there is only
8508 one set of dynamic relocs. Any loadable section that was actually
8509 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8510 dynamic symbol table, is considered to be a dynamic reloc section. */
8513 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8517 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8521 if (elf_dynsymtab (abfd
) == 0)
8523 bfd_set_error (bfd_error_invalid_operation
);
8527 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8529 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8531 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8532 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8533 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8538 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8540 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8542 for (i
= 0; i
< count
; i
++)
8553 /* Read in the version information. */
8556 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8558 bfd_byte
*contents
= NULL
;
8559 unsigned int freeidx
= 0;
8561 if (elf_dynverref (abfd
) != 0)
8563 Elf_Internal_Shdr
*hdr
;
8564 Elf_External_Verneed
*everneed
;
8565 Elf_Internal_Verneed
*iverneed
;
8567 bfd_byte
*contents_end
;
8569 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8571 if (hdr
->sh_info
== 0
8572 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8574 error_return_bad_verref
:
8576 (_("%pB: .gnu.version_r invalid entry"), abfd
);
8577 bfd_set_error (bfd_error_bad_value
);
8578 error_return_verref
:
8579 elf_tdata (abfd
)->verref
= NULL
;
8580 elf_tdata (abfd
)->cverrefs
= 0;
8584 ufile_ptr filesize
= bfd_get_file_size (abfd
);
8585 if (filesize
> 0 && filesize
< hdr
->sh_size
)
8587 /* PR 24708: Avoid attempts to allocate a ridiculous amount
8589 bfd_set_error (bfd_error_no_memory
);
8591 /* xgettext:c-format */
8592 (_("error: %pB version reference section is too large (%#" PRIx64
" bytes)"),
8593 abfd
, (uint64_t) hdr
->sh_size
);
8594 goto error_return_verref
;
8596 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8597 if (contents
== NULL
)
8598 goto error_return_verref
;
8600 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8601 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8602 goto error_return_verref
;
8604 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
8605 bfd_alloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
8607 if (elf_tdata (abfd
)->verref
== NULL
)
8608 goto error_return_verref
;
8610 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8611 == sizeof (Elf_External_Vernaux
));
8612 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8613 everneed
= (Elf_External_Verneed
*) contents
;
8614 iverneed
= elf_tdata (abfd
)->verref
;
8615 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8617 Elf_External_Vernaux
*evernaux
;
8618 Elf_Internal_Vernaux
*ivernaux
;
8621 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8623 iverneed
->vn_bfd
= abfd
;
8625 iverneed
->vn_filename
=
8626 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8628 if (iverneed
->vn_filename
== NULL
)
8629 goto error_return_bad_verref
;
8631 if (iverneed
->vn_cnt
== 0)
8632 iverneed
->vn_auxptr
= NULL
;
8635 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8636 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
8637 sizeof (Elf_Internal_Vernaux
));
8638 if (iverneed
->vn_auxptr
== NULL
)
8639 goto error_return_verref
;
8642 if (iverneed
->vn_aux
8643 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8644 goto error_return_bad_verref
;
8646 evernaux
= ((Elf_External_Vernaux
*)
8647 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8648 ivernaux
= iverneed
->vn_auxptr
;
8649 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8651 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8653 ivernaux
->vna_nodename
=
8654 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8655 ivernaux
->vna_name
);
8656 if (ivernaux
->vna_nodename
== NULL
)
8657 goto error_return_bad_verref
;
8659 if (ivernaux
->vna_other
> freeidx
)
8660 freeidx
= ivernaux
->vna_other
;
8662 ivernaux
->vna_nextptr
= NULL
;
8663 if (ivernaux
->vna_next
== 0)
8665 iverneed
->vn_cnt
= j
+ 1;
8668 if (j
+ 1 < iverneed
->vn_cnt
)
8669 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8671 if (ivernaux
->vna_next
8672 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8673 goto error_return_bad_verref
;
8675 evernaux
= ((Elf_External_Vernaux
*)
8676 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8679 iverneed
->vn_nextref
= NULL
;
8680 if (iverneed
->vn_next
== 0)
8682 if (i
+ 1 < hdr
->sh_info
)
8683 iverneed
->vn_nextref
= iverneed
+ 1;
8685 if (iverneed
->vn_next
8686 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8687 goto error_return_bad_verref
;
8689 everneed
= ((Elf_External_Verneed
*)
8690 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8692 elf_tdata (abfd
)->cverrefs
= i
;
8698 if (elf_dynverdef (abfd
) != 0)
8700 Elf_Internal_Shdr
*hdr
;
8701 Elf_External_Verdef
*everdef
;
8702 Elf_Internal_Verdef
*iverdef
;
8703 Elf_Internal_Verdef
*iverdefarr
;
8704 Elf_Internal_Verdef iverdefmem
;
8706 unsigned int maxidx
;
8707 bfd_byte
*contents_end_def
, *contents_end_aux
;
8709 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8711 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8713 error_return_bad_verdef
:
8715 (_("%pB: .gnu.version_d invalid entry"), abfd
);
8716 bfd_set_error (bfd_error_bad_value
);
8717 error_return_verdef
:
8718 elf_tdata (abfd
)->verdef
= NULL
;
8719 elf_tdata (abfd
)->cverdefs
= 0;
8723 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8724 if (contents
== NULL
)
8725 goto error_return_verdef
;
8726 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8727 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8728 goto error_return_verdef
;
8730 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8731 >= sizeof (Elf_External_Verdaux
));
8732 contents_end_def
= contents
+ hdr
->sh_size
8733 - sizeof (Elf_External_Verdef
);
8734 contents_end_aux
= contents
+ hdr
->sh_size
8735 - sizeof (Elf_External_Verdaux
);
8737 /* We know the number of entries in the section but not the maximum
8738 index. Therefore we have to run through all entries and find
8740 everdef
= (Elf_External_Verdef
*) contents
;
8742 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8744 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8746 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8747 goto error_return_bad_verdef
;
8748 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8749 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8751 if (iverdefmem
.vd_next
== 0)
8754 if (iverdefmem
.vd_next
8755 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8756 goto error_return_bad_verdef
;
8758 everdef
= ((Elf_External_Verdef
*)
8759 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8762 if (default_imported_symver
)
8764 if (freeidx
> maxidx
)
8770 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8771 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
8772 if (elf_tdata (abfd
)->verdef
== NULL
)
8773 goto error_return_verdef
;
8775 elf_tdata (abfd
)->cverdefs
= maxidx
;
8777 everdef
= (Elf_External_Verdef
*) contents
;
8778 iverdefarr
= elf_tdata (abfd
)->verdef
;
8779 for (i
= 0; i
< hdr
->sh_info
; i
++)
8781 Elf_External_Verdaux
*everdaux
;
8782 Elf_Internal_Verdaux
*iverdaux
;
8785 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8787 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8788 goto error_return_bad_verdef
;
8790 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8791 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8793 iverdef
->vd_bfd
= abfd
;
8795 if (iverdef
->vd_cnt
== 0)
8796 iverdef
->vd_auxptr
= NULL
;
8799 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8800 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
8801 sizeof (Elf_Internal_Verdaux
));
8802 if (iverdef
->vd_auxptr
== NULL
)
8803 goto error_return_verdef
;
8807 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8808 goto error_return_bad_verdef
;
8810 everdaux
= ((Elf_External_Verdaux
*)
8811 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8812 iverdaux
= iverdef
->vd_auxptr
;
8813 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8815 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8817 iverdaux
->vda_nodename
=
8818 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8819 iverdaux
->vda_name
);
8820 if (iverdaux
->vda_nodename
== NULL
)
8821 goto error_return_bad_verdef
;
8823 iverdaux
->vda_nextptr
= NULL
;
8824 if (iverdaux
->vda_next
== 0)
8826 iverdef
->vd_cnt
= j
+ 1;
8829 if (j
+ 1 < iverdef
->vd_cnt
)
8830 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8832 if (iverdaux
->vda_next
8833 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8834 goto error_return_bad_verdef
;
8836 everdaux
= ((Elf_External_Verdaux
*)
8837 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8840 iverdef
->vd_nodename
= NULL
;
8841 if (iverdef
->vd_cnt
)
8842 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8844 iverdef
->vd_nextdef
= NULL
;
8845 if (iverdef
->vd_next
== 0)
8847 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8848 iverdef
->vd_nextdef
= iverdef
+ 1;
8850 everdef
= ((Elf_External_Verdef
*)
8851 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8857 else if (default_imported_symver
)
8864 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8865 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8866 if (elf_tdata (abfd
)->verdef
== NULL
)
8869 elf_tdata (abfd
)->cverdefs
= freeidx
;
8872 /* Create a default version based on the soname. */
8873 if (default_imported_symver
)
8875 Elf_Internal_Verdef
*iverdef
;
8876 Elf_Internal_Verdaux
*iverdaux
;
8878 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8880 iverdef
->vd_version
= VER_DEF_CURRENT
;
8881 iverdef
->vd_flags
= 0;
8882 iverdef
->vd_ndx
= freeidx
;
8883 iverdef
->vd_cnt
= 1;
8885 iverdef
->vd_bfd
= abfd
;
8887 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8888 if (iverdef
->vd_nodename
== NULL
)
8889 goto error_return_verdef
;
8890 iverdef
->vd_nextdef
= NULL
;
8891 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8892 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8893 if (iverdef
->vd_auxptr
== NULL
)
8894 goto error_return_verdef
;
8896 iverdaux
= iverdef
->vd_auxptr
;
8897 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8903 if (contents
!= NULL
)
8909 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8911 elf_symbol_type
*newsym
;
8913 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (*newsym
));
8916 newsym
->symbol
.the_bfd
= abfd
;
8917 return &newsym
->symbol
;
8921 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8925 bfd_symbol_info (symbol
, ret
);
8928 /* Return whether a symbol name implies a local symbol. Most targets
8929 use this function for the is_local_label_name entry point, but some
8933 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8936 /* Normal local symbols start with ``.L''. */
8937 if (name
[0] == '.' && name
[1] == 'L')
8940 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8941 DWARF debugging symbols starting with ``..''. */
8942 if (name
[0] == '.' && name
[1] == '.')
8945 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8946 emitting DWARF debugging output. I suspect this is actually a
8947 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8948 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8949 underscore to be emitted on some ELF targets). For ease of use,
8950 we treat such symbols as local. */
8951 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8954 /* Treat assembler generated fake symbols, dollar local labels and
8955 forward-backward labels (aka local labels) as locals.
8956 These labels have the form:
8958 L0^A.* (fake symbols)
8960 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8962 Versions which start with .L will have already been matched above,
8963 so we only need to match the rest. */
8964 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8966 bfd_boolean ret
= FALSE
;
8970 for (p
= name
+ 2; (c
= *p
); p
++)
8972 if (c
== 1 || c
== 2)
8974 if (c
== 1 && p
== name
+ 2)
8975 /* A fake symbol. */
8978 /* FIXME: We are being paranoid here and treating symbols like
8979 L0^Bfoo as if there were non-local, on the grounds that the
8980 assembler will never generate them. But can any symbol
8981 containing an ASCII value in the range 1-31 ever be anything
8982 other than some kind of local ? */
8999 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
9000 asymbol
*symbol ATTRIBUTE_UNUSED
)
9007 _bfd_elf_set_arch_mach (bfd
*abfd
,
9008 enum bfd_architecture arch
,
9009 unsigned long machine
)
9011 /* If this isn't the right architecture for this backend, and this
9012 isn't the generic backend, fail. */
9013 if (arch
!= get_elf_backend_data (abfd
)->arch
9014 && arch
!= bfd_arch_unknown
9015 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
9018 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
9021 /* Find the nearest line to a particular section and offset,
9022 for error reporting. */
9025 _bfd_elf_find_nearest_line (bfd
*abfd
,
9029 const char **filename_ptr
,
9030 const char **functionname_ptr
,
9031 unsigned int *line_ptr
,
9032 unsigned int *discriminator_ptr
)
9036 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
9037 filename_ptr
, functionname_ptr
,
9038 line_ptr
, discriminator_ptr
,
9039 dwarf_debug_sections
,
9040 &elf_tdata (abfd
)->dwarf2_find_line_info
)
9041 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
9042 filename_ptr
, functionname_ptr
,
9045 if (!*functionname_ptr
)
9046 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9047 *filename_ptr
? NULL
: filename_ptr
,
9052 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
9053 &found
, filename_ptr
,
9054 functionname_ptr
, line_ptr
,
9055 &elf_tdata (abfd
)->line_info
))
9057 if (found
&& (*functionname_ptr
|| *line_ptr
))
9060 if (symbols
== NULL
)
9063 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
9064 filename_ptr
, functionname_ptr
))
9071 /* Find the line for a symbol. */
9074 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
9075 const char **filename_ptr
, unsigned int *line_ptr
)
9077 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
9078 filename_ptr
, NULL
, line_ptr
, NULL
,
9079 dwarf_debug_sections
,
9080 &elf_tdata (abfd
)->dwarf2_find_line_info
);
9083 /* After a call to bfd_find_nearest_line, successive calls to
9084 bfd_find_inliner_info can be used to get source information about
9085 each level of function inlining that terminated at the address
9086 passed to bfd_find_nearest_line. Currently this is only supported
9087 for DWARF2 with appropriate DWARF3 extensions. */
9090 _bfd_elf_find_inliner_info (bfd
*abfd
,
9091 const char **filename_ptr
,
9092 const char **functionname_ptr
,
9093 unsigned int *line_ptr
)
9096 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
9097 functionname_ptr
, line_ptr
,
9098 & elf_tdata (abfd
)->dwarf2_find_line_info
);
9103 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
9105 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9106 int ret
= bed
->s
->sizeof_ehdr
;
9108 if (!bfd_link_relocatable (info
))
9110 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
9112 if (phdr_size
== (bfd_size_type
) -1)
9114 struct elf_segment_map
*m
;
9117 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
9118 phdr_size
+= bed
->s
->sizeof_phdr
;
9121 phdr_size
= get_program_header_size (abfd
, info
);
9124 elf_program_header_size (abfd
) = phdr_size
;
9132 _bfd_elf_set_section_contents (bfd
*abfd
,
9134 const void *location
,
9136 bfd_size_type count
)
9138 Elf_Internal_Shdr
*hdr
;
9141 if (! abfd
->output_has_begun
9142 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
9148 hdr
= &elf_section_data (section
)->this_hdr
;
9149 if (hdr
->sh_offset
== (file_ptr
) -1)
9151 if (bfd_section_is_ctf (section
))
9152 /* Nothing to do with this section: the contents are generated
9156 /* We must compress this section. Write output to the buffer. */
9157 unsigned char *contents
= hdr
->contents
;
9158 if ((offset
+ count
) > hdr
->sh_size
9159 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
9160 || contents
== NULL
)
9162 memcpy (contents
+ offset
, location
, count
);
9165 pos
= hdr
->sh_offset
+ offset
;
9166 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
9167 || bfd_bwrite (location
, count
, abfd
) != count
)
9174 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
9175 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
9176 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
9182 /* Try to convert a non-ELF reloc into an ELF one. */
9185 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
9187 /* Check whether we really have an ELF howto. */
9189 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
9191 bfd_reloc_code_real_type code
;
9192 reloc_howto_type
*howto
;
9194 /* Alien reloc: Try to determine its type to replace it with an
9195 equivalent ELF reloc. */
9197 if (areloc
->howto
->pc_relative
)
9199 switch (areloc
->howto
->bitsize
)
9202 code
= BFD_RELOC_8_PCREL
;
9205 code
= BFD_RELOC_12_PCREL
;
9208 code
= BFD_RELOC_16_PCREL
;
9211 code
= BFD_RELOC_24_PCREL
;
9214 code
= BFD_RELOC_32_PCREL
;
9217 code
= BFD_RELOC_64_PCREL
;
9223 howto
= bfd_reloc_type_lookup (abfd
, code
);
9225 if (howto
&& areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
9227 if (howto
->pcrel_offset
)
9228 areloc
->addend
+= areloc
->address
;
9230 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
9235 switch (areloc
->howto
->bitsize
)
9241 code
= BFD_RELOC_14
;
9244 code
= BFD_RELOC_16
;
9247 code
= BFD_RELOC_26
;
9250 code
= BFD_RELOC_32
;
9253 code
= BFD_RELOC_64
;
9259 howto
= bfd_reloc_type_lookup (abfd
, code
);
9263 areloc
->howto
= howto
;
9271 /* xgettext:c-format */
9272 _bfd_error_handler (_("%pB: %s unsupported"),
9273 abfd
, areloc
->howto
->name
);
9274 bfd_set_error (bfd_error_sorry
);
9279 _bfd_elf_close_and_cleanup (bfd
*abfd
)
9281 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
9282 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
9284 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
9285 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
9286 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
9289 return _bfd_generic_close_and_cleanup (abfd
);
9292 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
9293 in the relocation's offset. Thus we cannot allow any sort of sanity
9294 range-checking to interfere. There is nothing else to do in processing
9297 bfd_reloc_status_type
9298 _bfd_elf_rel_vtable_reloc_fn
9299 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
9300 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
9301 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
9302 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
9304 return bfd_reloc_ok
;
9307 /* Elf core file support. Much of this only works on native
9308 toolchains, since we rely on knowing the
9309 machine-dependent procfs structure in order to pick
9310 out details about the corefile. */
9312 #ifdef HAVE_SYS_PROCFS_H
9313 /* Needed for new procfs interface on sparc-solaris. */
9314 # define _STRUCTURED_PROC 1
9315 # include <sys/procfs.h>
9318 /* Return a PID that identifies a "thread" for threaded cores, or the
9319 PID of the main process for non-threaded cores. */
9322 elfcore_make_pid (bfd
*abfd
)
9326 pid
= elf_tdata (abfd
)->core
->lwpid
;
9328 pid
= elf_tdata (abfd
)->core
->pid
;
9333 /* If there isn't a section called NAME, make one, using
9334 data from SECT. Note, this function will generate a
9335 reference to NAME, so you shouldn't deallocate or
9339 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9343 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9346 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9350 sect2
->size
= sect
->size
;
9351 sect2
->filepos
= sect
->filepos
;
9352 sect2
->alignment_power
= sect
->alignment_power
;
9356 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9357 actually creates up to two pseudosections:
9358 - For the single-threaded case, a section named NAME, unless
9359 such a section already exists.
9360 - For the multi-threaded case, a section named "NAME/PID", where
9361 PID is elfcore_make_pid (abfd).
9362 Both pseudosections have identical contents. */
9364 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9370 char *threaded_name
;
9374 /* Build the section name. */
9376 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9377 len
= strlen (buf
) + 1;
9378 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9379 if (threaded_name
== NULL
)
9381 memcpy (threaded_name
, buf
, len
);
9383 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9388 sect
->filepos
= filepos
;
9389 sect
->alignment_power
= 2;
9391 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9395 elfcore_make_auxv_note_section (bfd
*abfd
, Elf_Internal_Note
*note
,
9398 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9404 sect
->size
= note
->descsz
- offs
;
9405 sect
->filepos
= note
->descpos
+ offs
;
9406 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9411 /* prstatus_t exists on:
9413 linux 2.[01] + glibc
9417 #if defined (HAVE_PRSTATUS_T)
9420 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9425 if (note
->descsz
== sizeof (prstatus_t
))
9429 size
= sizeof (prstat
.pr_reg
);
9430 offset
= offsetof (prstatus_t
, pr_reg
);
9431 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9433 /* Do not overwrite the core signal if it
9434 has already been set by another thread. */
9435 if (elf_tdata (abfd
)->core
->signal
== 0)
9436 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9437 if (elf_tdata (abfd
)->core
->pid
== 0)
9438 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9440 /* pr_who exists on:
9443 pr_who doesn't exist on:
9446 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9447 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9449 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9452 #if defined (HAVE_PRSTATUS32_T)
9453 else if (note
->descsz
== sizeof (prstatus32_t
))
9455 /* 64-bit host, 32-bit corefile */
9456 prstatus32_t prstat
;
9458 size
= sizeof (prstat
.pr_reg
);
9459 offset
= offsetof (prstatus32_t
, pr_reg
);
9460 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9462 /* Do not overwrite the core signal if it
9463 has already been set by another thread. */
9464 if (elf_tdata (abfd
)->core
->signal
== 0)
9465 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9466 if (elf_tdata (abfd
)->core
->pid
== 0)
9467 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9469 /* pr_who exists on:
9472 pr_who doesn't exist on:
9475 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9476 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9478 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9481 #endif /* HAVE_PRSTATUS32_T */
9484 /* Fail - we don't know how to handle any other
9485 note size (ie. data object type). */
9489 /* Make a ".reg/999" section and a ".reg" section. */
9490 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9491 size
, note
->descpos
+ offset
);
9493 #endif /* defined (HAVE_PRSTATUS_T) */
9495 /* Create a pseudosection containing the exact contents of NOTE. */
9497 elfcore_make_note_pseudosection (bfd
*abfd
,
9499 Elf_Internal_Note
*note
)
9501 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9502 note
->descsz
, note
->descpos
);
9505 /* There isn't a consistent prfpregset_t across platforms,
9506 but it doesn't matter, because we don't have to pick this
9507 data structure apart. */
9510 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9512 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9515 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9516 type of NT_PRXFPREG. Just include the whole note's contents
9520 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9522 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9525 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9526 with a note type of NT_X86_XSTATE. Just include the whole note's
9527 contents literally. */
9530 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9532 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9536 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9538 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9542 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9544 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9548 elfcore_grok_ppc_tar (bfd
*abfd
, Elf_Internal_Note
*note
)
9550 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tar", note
);
9554 elfcore_grok_ppc_ppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9556 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ppr", note
);
9560 elfcore_grok_ppc_dscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9562 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-dscr", note
);
9566 elfcore_grok_ppc_ebb (bfd
*abfd
, Elf_Internal_Note
*note
)
9568 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-ebb", note
);
9572 elfcore_grok_ppc_pmu (bfd
*abfd
, Elf_Internal_Note
*note
)
9574 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-pmu", note
);
9578 elfcore_grok_ppc_tm_cgpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9580 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cgpr", note
);
9584 elfcore_grok_ppc_tm_cfpr (bfd
*abfd
, Elf_Internal_Note
*note
)
9586 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cfpr", note
);
9590 elfcore_grok_ppc_tm_cvmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9592 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvmx", note
);
9596 elfcore_grok_ppc_tm_cvsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9598 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cvsx", note
);
9602 elfcore_grok_ppc_tm_spr (bfd
*abfd
, Elf_Internal_Note
*note
)
9604 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-spr", note
);
9608 elfcore_grok_ppc_tm_ctar (bfd
*abfd
, Elf_Internal_Note
*note
)
9610 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-ctar", note
);
9614 elfcore_grok_ppc_tm_cppr (bfd
*abfd
, Elf_Internal_Note
*note
)
9616 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cppr", note
);
9620 elfcore_grok_ppc_tm_cdscr (bfd
*abfd
, Elf_Internal_Note
*note
)
9622 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-tm-cdscr", note
);
9626 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9628 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9632 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9634 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9638 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9640 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9644 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9646 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9650 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9652 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9656 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9658 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9662 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9664 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9668 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9670 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9674 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9676 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9680 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9682 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9686 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9688 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9692 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9694 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9698 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9700 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9704 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9706 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9710 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9712 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9716 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9718 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9722 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9724 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9728 elfcore_grok_aarch_sve (bfd
*abfd
, Elf_Internal_Note
*note
)
9730 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-sve", note
);
9734 elfcore_grok_aarch_pauth (bfd
*abfd
, Elf_Internal_Note
*note
)
9736 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-pauth", note
);
9739 #if defined (HAVE_PRPSINFO_T)
9740 typedef prpsinfo_t elfcore_psinfo_t
;
9741 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9742 typedef prpsinfo32_t elfcore_psinfo32_t
;
9746 #if defined (HAVE_PSINFO_T)
9747 typedef psinfo_t elfcore_psinfo_t
;
9748 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9749 typedef psinfo32_t elfcore_psinfo32_t
;
9753 /* return a malloc'ed copy of a string at START which is at
9754 most MAX bytes long, possibly without a terminating '\0'.
9755 the copy will always have a terminating '\0'. */
9758 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9761 char *end
= (char *) memchr (start
, '\0', max
);
9769 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9773 memcpy (dups
, start
, len
);
9779 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9781 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9783 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9785 elfcore_psinfo_t psinfo
;
9787 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9789 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9790 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9792 elf_tdata (abfd
)->core
->program
9793 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9794 sizeof (psinfo
.pr_fname
));
9796 elf_tdata (abfd
)->core
->command
9797 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9798 sizeof (psinfo
.pr_psargs
));
9800 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9801 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9803 /* 64-bit host, 32-bit corefile */
9804 elfcore_psinfo32_t psinfo
;
9806 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9808 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9809 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9811 elf_tdata (abfd
)->core
->program
9812 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9813 sizeof (psinfo
.pr_fname
));
9815 elf_tdata (abfd
)->core
->command
9816 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9817 sizeof (psinfo
.pr_psargs
));
9823 /* Fail - we don't know how to handle any other
9824 note size (ie. data object type). */
9828 /* Note that for some reason, a spurious space is tacked
9829 onto the end of the args in some (at least one anyway)
9830 implementations, so strip it off if it exists. */
9833 char *command
= elf_tdata (abfd
)->core
->command
;
9834 int n
= strlen (command
);
9836 if (0 < n
&& command
[n
- 1] == ' ')
9837 command
[n
- 1] = '\0';
9842 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9844 #if defined (HAVE_PSTATUS_T)
9846 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9848 if (note
->descsz
== sizeof (pstatus_t
)
9849 #if defined (HAVE_PXSTATUS_T)
9850 || note
->descsz
== sizeof (pxstatus_t
)
9856 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9858 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9860 #if defined (HAVE_PSTATUS32_T)
9861 else if (note
->descsz
== sizeof (pstatus32_t
))
9863 /* 64-bit host, 32-bit corefile */
9866 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9868 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9871 /* Could grab some more details from the "representative"
9872 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9873 NT_LWPSTATUS note, presumably. */
9877 #endif /* defined (HAVE_PSTATUS_T) */
9879 #if defined (HAVE_LWPSTATUS_T)
9881 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9883 lwpstatus_t lwpstat
;
9889 if (note
->descsz
!= sizeof (lwpstat
)
9890 #if defined (HAVE_LWPXSTATUS_T)
9891 && note
->descsz
!= sizeof (lwpxstatus_t
)
9896 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
9898 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
9899 /* Do not overwrite the core signal if it has already been set by
9901 if (elf_tdata (abfd
)->core
->signal
== 0)
9902 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
9904 /* Make a ".reg/999" section. */
9906 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
9907 len
= strlen (buf
) + 1;
9908 name
= bfd_alloc (abfd
, len
);
9911 memcpy (name
, buf
, len
);
9913 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9917 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9918 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
9919 sect
->filepos
= note
->descpos
9920 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
9923 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9924 sect
->size
= sizeof (lwpstat
.pr_reg
);
9925 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
9928 sect
->alignment_power
= 2;
9930 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9933 /* Make a ".reg2/999" section */
9935 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
9936 len
= strlen (buf
) + 1;
9937 name
= bfd_alloc (abfd
, len
);
9940 memcpy (name
, buf
, len
);
9942 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9946 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9947 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
9948 sect
->filepos
= note
->descpos
9949 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
9952 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9953 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9954 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9957 sect
->alignment_power
= 2;
9959 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9961 #endif /* defined (HAVE_LWPSTATUS_T) */
9964 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9971 int is_active_thread
;
9974 if (note
->descsz
< 728)
9977 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9980 type
= bfd_get_32 (abfd
, note
->descdata
);
9984 case 1 /* NOTE_INFO_PROCESS */:
9985 /* FIXME: need to add ->core->command. */
9986 /* process_info.pid */
9987 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9988 /* process_info.signal */
9989 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
9992 case 2 /* NOTE_INFO_THREAD */:
9993 /* Make a ".reg/999" section. */
9994 /* thread_info.tid */
9995 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
9997 len
= strlen (buf
) + 1;
9998 name
= (char *) bfd_alloc (abfd
, len
);
10002 memcpy (name
, buf
, len
);
10004 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10008 /* sizeof (thread_info.thread_context) */
10010 /* offsetof (thread_info.thread_context) */
10011 sect
->filepos
= note
->descpos
+ 12;
10012 sect
->alignment_power
= 2;
10014 /* thread_info.is_active_thread */
10015 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
10017 if (is_active_thread
)
10018 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
10022 case 3 /* NOTE_INFO_MODULE */:
10023 /* Make a ".module/xxxxxxxx" section. */
10024 /* module_info.base_address */
10025 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
10026 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
10028 len
= strlen (buf
) + 1;
10029 name
= (char *) bfd_alloc (abfd
, len
);
10033 memcpy (name
, buf
, len
);
10035 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10040 sect
->size
= note
->descsz
;
10041 sect
->filepos
= note
->descpos
;
10042 sect
->alignment_power
= 2;
10053 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10055 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10057 switch (note
->type
)
10063 if (bed
->elf_backend_grok_prstatus
)
10064 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
10066 #if defined (HAVE_PRSTATUS_T)
10067 return elfcore_grok_prstatus (abfd
, note
);
10072 #if defined (HAVE_PSTATUS_T)
10074 return elfcore_grok_pstatus (abfd
, note
);
10077 #if defined (HAVE_LWPSTATUS_T)
10079 return elfcore_grok_lwpstatus (abfd
, note
);
10082 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
10083 return elfcore_grok_prfpreg (abfd
, note
);
10085 case NT_WIN32PSTATUS
:
10086 return elfcore_grok_win32pstatus (abfd
, note
);
10088 case NT_PRXFPREG
: /* Linux SSE extension */
10089 if (note
->namesz
== 6
10090 && strcmp (note
->namedata
, "LINUX") == 0)
10091 return elfcore_grok_prxfpreg (abfd
, note
);
10095 case NT_X86_XSTATE
: /* Linux XSAVE extension */
10096 if (note
->namesz
== 6
10097 && strcmp (note
->namedata
, "LINUX") == 0)
10098 return elfcore_grok_xstatereg (abfd
, note
);
10103 if (note
->namesz
== 6
10104 && strcmp (note
->namedata
, "LINUX") == 0)
10105 return elfcore_grok_ppc_vmx (abfd
, note
);
10110 if (note
->namesz
== 6
10111 && strcmp (note
->namedata
, "LINUX") == 0)
10112 return elfcore_grok_ppc_vsx (abfd
, note
);
10117 if (note
->namesz
== 6
10118 && strcmp (note
->namedata
, "LINUX") == 0)
10119 return elfcore_grok_ppc_tar (abfd
, note
);
10124 if (note
->namesz
== 6
10125 && strcmp (note
->namedata
, "LINUX") == 0)
10126 return elfcore_grok_ppc_ppr (abfd
, note
);
10131 if (note
->namesz
== 6
10132 && strcmp (note
->namedata
, "LINUX") == 0)
10133 return elfcore_grok_ppc_dscr (abfd
, note
);
10138 if (note
->namesz
== 6
10139 && strcmp (note
->namedata
, "LINUX") == 0)
10140 return elfcore_grok_ppc_ebb (abfd
, note
);
10145 if (note
->namesz
== 6
10146 && strcmp (note
->namedata
, "LINUX") == 0)
10147 return elfcore_grok_ppc_pmu (abfd
, note
);
10151 case NT_PPC_TM_CGPR
:
10152 if (note
->namesz
== 6
10153 && strcmp (note
->namedata
, "LINUX") == 0)
10154 return elfcore_grok_ppc_tm_cgpr (abfd
, note
);
10158 case NT_PPC_TM_CFPR
:
10159 if (note
->namesz
== 6
10160 && strcmp (note
->namedata
, "LINUX") == 0)
10161 return elfcore_grok_ppc_tm_cfpr (abfd
, note
);
10165 case NT_PPC_TM_CVMX
:
10166 if (note
->namesz
== 6
10167 && strcmp (note
->namedata
, "LINUX") == 0)
10168 return elfcore_grok_ppc_tm_cvmx (abfd
, note
);
10172 case NT_PPC_TM_CVSX
:
10173 if (note
->namesz
== 6
10174 && strcmp (note
->namedata
, "LINUX") == 0)
10175 return elfcore_grok_ppc_tm_cvsx (abfd
, note
);
10179 case NT_PPC_TM_SPR
:
10180 if (note
->namesz
== 6
10181 && strcmp (note
->namedata
, "LINUX") == 0)
10182 return elfcore_grok_ppc_tm_spr (abfd
, note
);
10186 case NT_PPC_TM_CTAR
:
10187 if (note
->namesz
== 6
10188 && strcmp (note
->namedata
, "LINUX") == 0)
10189 return elfcore_grok_ppc_tm_ctar (abfd
, note
);
10193 case NT_PPC_TM_CPPR
:
10194 if (note
->namesz
== 6
10195 && strcmp (note
->namedata
, "LINUX") == 0)
10196 return elfcore_grok_ppc_tm_cppr (abfd
, note
);
10200 case NT_PPC_TM_CDSCR
:
10201 if (note
->namesz
== 6
10202 && strcmp (note
->namedata
, "LINUX") == 0)
10203 return elfcore_grok_ppc_tm_cdscr (abfd
, note
);
10207 case NT_S390_HIGH_GPRS
:
10208 if (note
->namesz
== 6
10209 && strcmp (note
->namedata
, "LINUX") == 0)
10210 return elfcore_grok_s390_high_gprs (abfd
, note
);
10214 case NT_S390_TIMER
:
10215 if (note
->namesz
== 6
10216 && strcmp (note
->namedata
, "LINUX") == 0)
10217 return elfcore_grok_s390_timer (abfd
, note
);
10221 case NT_S390_TODCMP
:
10222 if (note
->namesz
== 6
10223 && strcmp (note
->namedata
, "LINUX") == 0)
10224 return elfcore_grok_s390_todcmp (abfd
, note
);
10228 case NT_S390_TODPREG
:
10229 if (note
->namesz
== 6
10230 && strcmp (note
->namedata
, "LINUX") == 0)
10231 return elfcore_grok_s390_todpreg (abfd
, note
);
10236 if (note
->namesz
== 6
10237 && strcmp (note
->namedata
, "LINUX") == 0)
10238 return elfcore_grok_s390_ctrs (abfd
, note
);
10242 case NT_S390_PREFIX
:
10243 if (note
->namesz
== 6
10244 && strcmp (note
->namedata
, "LINUX") == 0)
10245 return elfcore_grok_s390_prefix (abfd
, note
);
10249 case NT_S390_LAST_BREAK
:
10250 if (note
->namesz
== 6
10251 && strcmp (note
->namedata
, "LINUX") == 0)
10252 return elfcore_grok_s390_last_break (abfd
, note
);
10256 case NT_S390_SYSTEM_CALL
:
10257 if (note
->namesz
== 6
10258 && strcmp (note
->namedata
, "LINUX") == 0)
10259 return elfcore_grok_s390_system_call (abfd
, note
);
10264 if (note
->namesz
== 6
10265 && strcmp (note
->namedata
, "LINUX") == 0)
10266 return elfcore_grok_s390_tdb (abfd
, note
);
10270 case NT_S390_VXRS_LOW
:
10271 if (note
->namesz
== 6
10272 && strcmp (note
->namedata
, "LINUX") == 0)
10273 return elfcore_grok_s390_vxrs_low (abfd
, note
);
10277 case NT_S390_VXRS_HIGH
:
10278 if (note
->namesz
== 6
10279 && strcmp (note
->namedata
, "LINUX") == 0)
10280 return elfcore_grok_s390_vxrs_high (abfd
, note
);
10284 case NT_S390_GS_CB
:
10285 if (note
->namesz
== 6
10286 && strcmp (note
->namedata
, "LINUX") == 0)
10287 return elfcore_grok_s390_gs_cb (abfd
, note
);
10291 case NT_S390_GS_BC
:
10292 if (note
->namesz
== 6
10293 && strcmp (note
->namedata
, "LINUX") == 0)
10294 return elfcore_grok_s390_gs_bc (abfd
, note
);
10299 if (note
->namesz
== 6
10300 && strcmp (note
->namedata
, "LINUX") == 0)
10301 return elfcore_grok_arm_vfp (abfd
, note
);
10306 if (note
->namesz
== 6
10307 && strcmp (note
->namedata
, "LINUX") == 0)
10308 return elfcore_grok_aarch_tls (abfd
, note
);
10312 case NT_ARM_HW_BREAK
:
10313 if (note
->namesz
== 6
10314 && strcmp (note
->namedata
, "LINUX") == 0)
10315 return elfcore_grok_aarch_hw_break (abfd
, note
);
10319 case NT_ARM_HW_WATCH
:
10320 if (note
->namesz
== 6
10321 && strcmp (note
->namedata
, "LINUX") == 0)
10322 return elfcore_grok_aarch_hw_watch (abfd
, note
);
10327 if (note
->namesz
== 6
10328 && strcmp (note
->namedata
, "LINUX") == 0)
10329 return elfcore_grok_aarch_sve (abfd
, note
);
10333 case NT_ARM_PAC_MASK
:
10334 if (note
->namesz
== 6
10335 && strcmp (note
->namedata
, "LINUX") == 0)
10336 return elfcore_grok_aarch_pauth (abfd
, note
);
10342 if (bed
->elf_backend_grok_psinfo
)
10343 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
10345 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10346 return elfcore_grok_psinfo (abfd
, note
);
10352 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10355 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
10359 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
10366 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
10368 struct bfd_build_id
* build_id
;
10370 if (note
->descsz
== 0)
10373 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
10374 if (build_id
== NULL
)
10377 build_id
->size
= note
->descsz
;
10378 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
10379 abfd
->build_id
= build_id
;
10385 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10387 switch (note
->type
)
10392 case NT_GNU_PROPERTY_TYPE_0
:
10393 return _bfd_elf_parse_gnu_properties (abfd
, note
);
10395 case NT_GNU_BUILD_ID
:
10396 return elfobj_grok_gnu_build_id (abfd
, note
);
10401 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
10403 struct sdt_note
*cur
=
10404 (struct sdt_note
*) bfd_alloc (abfd
,
10405 sizeof (struct sdt_note
) + note
->descsz
);
10407 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
10408 cur
->size
= (bfd_size_type
) note
->descsz
;
10409 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
10411 elf_tdata (abfd
)->sdt_note_head
= cur
;
10417 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10419 switch (note
->type
)
10422 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
10430 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10434 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10437 if (note
->descsz
< 108)
10442 if (note
->descsz
< 120)
10450 /* Check for version 1 in pr_version. */
10451 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10456 /* Skip over pr_psinfosz. */
10457 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10461 offset
+= 4; /* Padding before pr_psinfosz. */
10465 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
10466 elf_tdata (abfd
)->core
->program
10467 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
10470 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
10471 elf_tdata (abfd
)->core
->command
10472 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
10475 /* Padding before pr_pid. */
10478 /* The pr_pid field was added in version "1a". */
10479 if (note
->descsz
< offset
+ 4)
10482 elf_tdata (abfd
)->core
->pid
10483 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10489 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
10495 /* Compute offset of pr_getregsz, skipping over pr_statussz.
10496 Also compute minimum size of this note. */
10497 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
10501 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
10505 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
10506 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10513 if (note
->descsz
< min_size
)
10516 /* Check for version 1 in pr_version. */
10517 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10520 /* Extract size of pr_reg from pr_gregsetsz. */
10521 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10522 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10524 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10529 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10533 /* Skip over pr_osreldate. */
10536 /* Read signal from pr_cursig. */
10537 if (elf_tdata (abfd
)->core
->signal
== 0)
10538 elf_tdata (abfd
)->core
->signal
10539 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10542 /* Read TID from pr_pid. */
10543 elf_tdata (abfd
)->core
->lwpid
10544 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10547 /* Padding before pr_reg. */
10548 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10551 /* Make sure that there is enough data remaining in the note. */
10552 if ((note
->descsz
- offset
) < size
)
10555 /* Make a ".reg/999" section and a ".reg" section. */
10556 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10557 size
, note
->descpos
+ offset
);
10561 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10563 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10565 switch (note
->type
)
10568 if (bed
->elf_backend_grok_freebsd_prstatus
)
10569 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10571 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10574 return elfcore_grok_prfpreg (abfd
, note
);
10577 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10579 case NT_FREEBSD_THRMISC
:
10580 if (note
->namesz
== 8)
10581 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10585 case NT_FREEBSD_PROCSTAT_PROC
:
10586 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10589 case NT_FREEBSD_PROCSTAT_FILES
:
10590 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10593 case NT_FREEBSD_PROCSTAT_VMMAP
:
10594 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10597 case NT_FREEBSD_PROCSTAT_AUXV
:
10598 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10600 case NT_X86_XSTATE
:
10601 if (note
->namesz
== 8)
10602 return elfcore_grok_xstatereg (abfd
, note
);
10606 case NT_FREEBSD_PTLWPINFO
:
10607 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10611 return elfcore_grok_arm_vfp (abfd
, note
);
10619 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10623 cp
= strchr (note
->namedata
, '@');
10626 *lwpidp
= atoi(cp
+ 1);
10633 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10635 if (note
->descsz
<= 0x7c + 31)
10638 /* Signal number at offset 0x08. */
10639 elf_tdata (abfd
)->core
->signal
10640 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10642 /* Process ID at offset 0x50. */
10643 elf_tdata (abfd
)->core
->pid
10644 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10646 /* Command name at 0x7c (max 32 bytes, including nul). */
10647 elf_tdata (abfd
)->core
->command
10648 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10650 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10655 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10659 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10660 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10662 switch (note
->type
)
10664 case NT_NETBSDCORE_PROCINFO
:
10665 /* NetBSD-specific core "procinfo". Note that we expect to
10666 find this note before any of the others, which is fine,
10667 since the kernel writes this note out first when it
10668 creates a core file. */
10669 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10670 #ifdef NT_NETBSDCORE_AUXV
10671 case NT_NETBSDCORE_AUXV
:
10672 /* NetBSD-specific Elf Auxiliary Vector data. */
10673 return elfcore_make_auxv_note_section (abfd
, note
, 4);
10679 /* As of March 2017 there are no other machine-independent notes
10680 defined for NetBSD core files. If the note type is less
10681 than the start of the machine-dependent note types, we don't
10684 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10688 switch (bfd_get_arch (abfd
))
10690 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10691 PT_GETFPREGS == mach+2. */
10693 case bfd_arch_alpha
:
10694 case bfd_arch_sparc
:
10695 switch (note
->type
)
10697 case NT_NETBSDCORE_FIRSTMACH
+0:
10698 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10700 case NT_NETBSDCORE_FIRSTMACH
+2:
10701 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10707 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
10708 There's also old PT___GETREGS40 == mach + 1 for old reg
10709 structure which lacks GBR. */
10712 switch (note
->type
)
10714 case NT_NETBSDCORE_FIRSTMACH
+3:
10715 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10717 case NT_NETBSDCORE_FIRSTMACH
+5:
10718 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10724 /* On all other arch's, PT_GETREGS == mach+1 and
10725 PT_GETFPREGS == mach+3. */
10728 switch (note
->type
)
10730 case NT_NETBSDCORE_FIRSTMACH
+1:
10731 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10733 case NT_NETBSDCORE_FIRSTMACH
+3:
10734 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10744 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10746 if (note
->descsz
<= 0x48 + 31)
10749 /* Signal number at offset 0x08. */
10750 elf_tdata (abfd
)->core
->signal
10751 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10753 /* Process ID at offset 0x20. */
10754 elf_tdata (abfd
)->core
->pid
10755 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
10757 /* Command name at 0x48 (max 32 bytes, including nul). */
10758 elf_tdata (abfd
)->core
->command
10759 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
10765 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10767 if (note
->type
== NT_OPENBSD_PROCINFO
)
10768 return elfcore_grok_openbsd_procinfo (abfd
, note
);
10770 if (note
->type
== NT_OPENBSD_REGS
)
10771 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10773 if (note
->type
== NT_OPENBSD_FPREGS
)
10774 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10776 if (note
->type
== NT_OPENBSD_XFPREGS
)
10777 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
10779 if (note
->type
== NT_OPENBSD_AUXV
)
10780 return elfcore_make_auxv_note_section (abfd
, note
, 0);
10782 if (note
->type
== NT_OPENBSD_WCOOKIE
)
10784 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
10789 sect
->size
= note
->descsz
;
10790 sect
->filepos
= note
->descpos
;
10791 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10800 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
10802 void *ddata
= note
->descdata
;
10809 if (note
->descsz
< 16)
10812 /* nto_procfs_status 'pid' field is at offset 0. */
10813 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
10815 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10816 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
10818 /* nto_procfs_status 'flags' field is at offset 8. */
10819 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
10821 /* nto_procfs_status 'what' field is at offset 14. */
10822 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
10824 elf_tdata (abfd
)->core
->signal
= sig
;
10825 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10828 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10829 do not come from signals so we make sure we set the current
10830 thread just in case. */
10831 if (flags
& 0x00000080)
10832 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10834 /* Make a ".qnx_core_status/%d" section. */
10835 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
10837 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10840 strcpy (name
, buf
);
10842 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10846 sect
->size
= note
->descsz
;
10847 sect
->filepos
= note
->descpos
;
10848 sect
->alignment_power
= 2;
10850 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
10854 elfcore_grok_nto_regs (bfd
*abfd
,
10855 Elf_Internal_Note
*note
,
10863 /* Make a "(base)/%d" section. */
10864 sprintf (buf
, "%s/%ld", base
, tid
);
10866 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10869 strcpy (name
, buf
);
10871 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10875 sect
->size
= note
->descsz
;
10876 sect
->filepos
= note
->descpos
;
10877 sect
->alignment_power
= 2;
10879 /* This is the current thread. */
10880 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
10881 return elfcore_maybe_make_sect (abfd
, base
, sect
);
10886 #define BFD_QNT_CORE_INFO 7
10887 #define BFD_QNT_CORE_STATUS 8
10888 #define BFD_QNT_CORE_GREG 9
10889 #define BFD_QNT_CORE_FPREG 10
10892 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10894 /* Every GREG section has a STATUS section before it. Store the
10895 tid from the previous call to pass down to the next gregs
10897 static long tid
= 1;
10899 switch (note
->type
)
10901 case BFD_QNT_CORE_INFO
:
10902 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
10903 case BFD_QNT_CORE_STATUS
:
10904 return elfcore_grok_nto_status (abfd
, note
, &tid
);
10905 case BFD_QNT_CORE_GREG
:
10906 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
10907 case BFD_QNT_CORE_FPREG
:
10908 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
10915 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10921 /* Use note name as section name. */
10922 len
= note
->namesz
;
10923 name
= (char *) bfd_alloc (abfd
, len
);
10926 memcpy (name
, note
->namedata
, len
);
10927 name
[len
- 1] = '\0';
10929 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10933 sect
->size
= note
->descsz
;
10934 sect
->filepos
= note
->descpos
;
10935 sect
->alignment_power
= 1;
10940 /* Function: elfcore_write_note
10943 buffer to hold note, and current size of buffer
10947 size of data for note
10949 Writes note to end of buffer. ELF64 notes are written exactly as
10950 for ELF32, despite the current (as of 2006) ELF gabi specifying
10951 that they ought to have 8-byte namesz and descsz field, and have
10952 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10955 Pointer to realloc'd buffer, *BUFSIZ updated. */
10958 elfcore_write_note (bfd
*abfd
,
10966 Elf_External_Note
*xnp
;
10973 namesz
= strlen (name
) + 1;
10975 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
10977 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
10980 dest
= buf
+ *bufsiz
;
10981 *bufsiz
+= newspace
;
10982 xnp
= (Elf_External_Note
*) dest
;
10983 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
10984 H_PUT_32 (abfd
, size
, xnp
->descsz
);
10985 H_PUT_32 (abfd
, type
, xnp
->type
);
10989 memcpy (dest
, name
, namesz
);
10997 memcpy (dest
, input
, size
);
11007 /* gcc-8 warns (*) on all the strncpy calls in this function about
11008 possible string truncation. The "truncation" is not a bug. We
11009 have an external representation of structs with fields that are not
11010 necessarily NULL terminated and corresponding internal
11011 representation fields that are one larger so that they can always
11012 be NULL terminated.
11013 gcc versions between 4.2 and 4.6 do not allow pragma control of
11014 diagnostics inside functions, giving a hard error if you try to use
11015 the finer control available with later versions.
11016 gcc prior to 4.2 warns about diagnostic push and pop.
11017 gcc-5, gcc-6 and gcc-7 warn that -Wstringop-truncation is unknown,
11018 unless you also add #pragma GCC diagnostic ignored "-Wpragma".
11019 (*) Depending on your system header files! */
11020 #if GCC_VERSION >= 8000
11021 # pragma GCC diagnostic push
11022 # pragma GCC diagnostic ignored "-Wstringop-truncation"
11025 elfcore_write_prpsinfo (bfd
*abfd
,
11029 const char *psargs
)
11031 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11033 if (bed
->elf_backend_write_core_note
!= NULL
)
11036 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11037 NT_PRPSINFO
, fname
, psargs
);
11042 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
11043 # if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
11044 if (bed
->s
->elfclass
== ELFCLASS32
)
11046 # if defined (HAVE_PSINFO32_T)
11048 int note_type
= NT_PSINFO
;
11051 int note_type
= NT_PRPSINFO
;
11054 memset (&data
, 0, sizeof (data
));
11055 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11056 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11057 return elfcore_write_note (abfd
, buf
, bufsiz
,
11058 "CORE", note_type
, &data
, sizeof (data
));
11063 # if defined (HAVE_PSINFO_T)
11065 int note_type
= NT_PSINFO
;
11068 int note_type
= NT_PRPSINFO
;
11071 memset (&data
, 0, sizeof (data
));
11072 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
11073 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
11074 return elfcore_write_note (abfd
, buf
, bufsiz
,
11075 "CORE", note_type
, &data
, sizeof (data
));
11077 #endif /* PSINFO_T or PRPSINFO_T */
11082 #if GCC_VERSION >= 8000
11083 # pragma GCC diagnostic pop
11087 elfcore_write_linux_prpsinfo32
11088 (bfd
*abfd
, char *buf
, int *bufsiz
,
11089 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11091 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
11093 struct elf_external_linux_prpsinfo32_ugid16 data
;
11095 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
11096 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11097 &data
, sizeof (data
));
11101 struct elf_external_linux_prpsinfo32_ugid32 data
;
11103 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
11104 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
11105 &data
, sizeof (data
));
11110 elfcore_write_linux_prpsinfo64
11111 (bfd
*abfd
, char *buf
, int *bufsiz
,
11112 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
11114 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
11116 struct elf_external_linux_prpsinfo64_ugid16 data
;
11118 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
11119 return elfcore_write_note (abfd
, buf
, bufsiz
,
11120 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11124 struct elf_external_linux_prpsinfo64_ugid32 data
;
11126 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
11127 return elfcore_write_note (abfd
, buf
, bufsiz
,
11128 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
11133 elfcore_write_prstatus (bfd
*abfd
,
11140 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11142 if (bed
->elf_backend_write_core_note
!= NULL
)
11145 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
11147 pid
, cursig
, gregs
);
11152 #if defined (HAVE_PRSTATUS_T)
11153 #if defined (HAVE_PRSTATUS32_T)
11154 if (bed
->s
->elfclass
== ELFCLASS32
)
11156 prstatus32_t prstat
;
11158 memset (&prstat
, 0, sizeof (prstat
));
11159 prstat
.pr_pid
= pid
;
11160 prstat
.pr_cursig
= cursig
;
11161 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11162 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11163 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11170 memset (&prstat
, 0, sizeof (prstat
));
11171 prstat
.pr_pid
= pid
;
11172 prstat
.pr_cursig
= cursig
;
11173 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
11174 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
11175 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
11177 #endif /* HAVE_PRSTATUS_T */
11183 #if defined (HAVE_LWPSTATUS_T)
11185 elfcore_write_lwpstatus (bfd
*abfd
,
11192 lwpstatus_t lwpstat
;
11193 const char *note_name
= "CORE";
11195 memset (&lwpstat
, 0, sizeof (lwpstat
));
11196 lwpstat
.pr_lwpid
= pid
>> 16;
11197 lwpstat
.pr_cursig
= cursig
;
11198 #if defined (HAVE_LWPSTATUS_T_PR_REG)
11199 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
11200 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
11201 #if !defined(gregs)
11202 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
11203 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
11205 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
11206 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
11209 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11210 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
11212 #endif /* HAVE_LWPSTATUS_T */
11214 #if defined (HAVE_PSTATUS_T)
11216 elfcore_write_pstatus (bfd
*abfd
,
11220 int cursig ATTRIBUTE_UNUSED
,
11221 const void *gregs ATTRIBUTE_UNUSED
)
11223 const char *note_name
= "CORE";
11224 #if defined (HAVE_PSTATUS32_T)
11225 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11227 if (bed
->s
->elfclass
== ELFCLASS32
)
11231 memset (&pstat
, 0, sizeof (pstat
));
11232 pstat
.pr_pid
= pid
& 0xffff;
11233 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11234 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11242 memset (&pstat
, 0, sizeof (pstat
));
11243 pstat
.pr_pid
= pid
& 0xffff;
11244 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
11245 NT_PSTATUS
, &pstat
, sizeof (pstat
));
11249 #endif /* HAVE_PSTATUS_T */
11252 elfcore_write_prfpreg (bfd
*abfd
,
11255 const void *fpregs
,
11258 const char *note_name
= "CORE";
11259 return elfcore_write_note (abfd
, buf
, bufsiz
,
11260 note_name
, NT_FPREGSET
, fpregs
, size
);
11264 elfcore_write_prxfpreg (bfd
*abfd
,
11267 const void *xfpregs
,
11270 char *note_name
= "LINUX";
11271 return elfcore_write_note (abfd
, buf
, bufsiz
,
11272 note_name
, NT_PRXFPREG
, xfpregs
, size
);
11276 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
11277 const void *xfpregs
, int size
)
11280 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
11281 note_name
= "FreeBSD";
11283 note_name
= "LINUX";
11284 return elfcore_write_note (abfd
, buf
, bufsiz
,
11285 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
11289 elfcore_write_ppc_vmx (bfd
*abfd
,
11292 const void *ppc_vmx
,
11295 char *note_name
= "LINUX";
11296 return elfcore_write_note (abfd
, buf
, bufsiz
,
11297 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
11301 elfcore_write_ppc_vsx (bfd
*abfd
,
11304 const void *ppc_vsx
,
11307 char *note_name
= "LINUX";
11308 return elfcore_write_note (abfd
, buf
, bufsiz
,
11309 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
11313 elfcore_write_ppc_tar (bfd
*abfd
,
11316 const void *ppc_tar
,
11319 char *note_name
= "LINUX";
11320 return elfcore_write_note (abfd
, buf
, bufsiz
,
11321 note_name
, NT_PPC_TAR
, ppc_tar
, size
);
11325 elfcore_write_ppc_ppr (bfd
*abfd
,
11328 const void *ppc_ppr
,
11331 char *note_name
= "LINUX";
11332 return elfcore_write_note (abfd
, buf
, bufsiz
,
11333 note_name
, NT_PPC_PPR
, ppc_ppr
, size
);
11337 elfcore_write_ppc_dscr (bfd
*abfd
,
11340 const void *ppc_dscr
,
11343 char *note_name
= "LINUX";
11344 return elfcore_write_note (abfd
, buf
, bufsiz
,
11345 note_name
, NT_PPC_DSCR
, ppc_dscr
, size
);
11349 elfcore_write_ppc_ebb (bfd
*abfd
,
11352 const void *ppc_ebb
,
11355 char *note_name
= "LINUX";
11356 return elfcore_write_note (abfd
, buf
, bufsiz
,
11357 note_name
, NT_PPC_EBB
, ppc_ebb
, size
);
11361 elfcore_write_ppc_pmu (bfd
*abfd
,
11364 const void *ppc_pmu
,
11367 char *note_name
= "LINUX";
11368 return elfcore_write_note (abfd
, buf
, bufsiz
,
11369 note_name
, NT_PPC_PMU
, ppc_pmu
, size
);
11373 elfcore_write_ppc_tm_cgpr (bfd
*abfd
,
11376 const void *ppc_tm_cgpr
,
11379 char *note_name
= "LINUX";
11380 return elfcore_write_note (abfd
, buf
, bufsiz
,
11381 note_name
, NT_PPC_TM_CGPR
, ppc_tm_cgpr
, size
);
11385 elfcore_write_ppc_tm_cfpr (bfd
*abfd
,
11388 const void *ppc_tm_cfpr
,
11391 char *note_name
= "LINUX";
11392 return elfcore_write_note (abfd
, buf
, bufsiz
,
11393 note_name
, NT_PPC_TM_CFPR
, ppc_tm_cfpr
, size
);
11397 elfcore_write_ppc_tm_cvmx (bfd
*abfd
,
11400 const void *ppc_tm_cvmx
,
11403 char *note_name
= "LINUX";
11404 return elfcore_write_note (abfd
, buf
, bufsiz
,
11405 note_name
, NT_PPC_TM_CVMX
, ppc_tm_cvmx
, size
);
11409 elfcore_write_ppc_tm_cvsx (bfd
*abfd
,
11412 const void *ppc_tm_cvsx
,
11415 char *note_name
= "LINUX";
11416 return elfcore_write_note (abfd
, buf
, bufsiz
,
11417 note_name
, NT_PPC_TM_CVSX
, ppc_tm_cvsx
, size
);
11421 elfcore_write_ppc_tm_spr (bfd
*abfd
,
11424 const void *ppc_tm_spr
,
11427 char *note_name
= "LINUX";
11428 return elfcore_write_note (abfd
, buf
, bufsiz
,
11429 note_name
, NT_PPC_TM_SPR
, ppc_tm_spr
, size
);
11433 elfcore_write_ppc_tm_ctar (bfd
*abfd
,
11436 const void *ppc_tm_ctar
,
11439 char *note_name
= "LINUX";
11440 return elfcore_write_note (abfd
, buf
, bufsiz
,
11441 note_name
, NT_PPC_TM_CTAR
, ppc_tm_ctar
, size
);
11445 elfcore_write_ppc_tm_cppr (bfd
*abfd
,
11448 const void *ppc_tm_cppr
,
11451 char *note_name
= "LINUX";
11452 return elfcore_write_note (abfd
, buf
, bufsiz
,
11453 note_name
, NT_PPC_TM_CPPR
, ppc_tm_cppr
, size
);
11457 elfcore_write_ppc_tm_cdscr (bfd
*abfd
,
11460 const void *ppc_tm_cdscr
,
11463 char *note_name
= "LINUX";
11464 return elfcore_write_note (abfd
, buf
, bufsiz
,
11465 note_name
, NT_PPC_TM_CDSCR
, ppc_tm_cdscr
, size
);
11469 elfcore_write_s390_high_gprs (bfd
*abfd
,
11472 const void *s390_high_gprs
,
11475 char *note_name
= "LINUX";
11476 return elfcore_write_note (abfd
, buf
, bufsiz
,
11477 note_name
, NT_S390_HIGH_GPRS
,
11478 s390_high_gprs
, size
);
11482 elfcore_write_s390_timer (bfd
*abfd
,
11485 const void *s390_timer
,
11488 char *note_name
= "LINUX";
11489 return elfcore_write_note (abfd
, buf
, bufsiz
,
11490 note_name
, NT_S390_TIMER
, s390_timer
, size
);
11494 elfcore_write_s390_todcmp (bfd
*abfd
,
11497 const void *s390_todcmp
,
11500 char *note_name
= "LINUX";
11501 return elfcore_write_note (abfd
, buf
, bufsiz
,
11502 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
11506 elfcore_write_s390_todpreg (bfd
*abfd
,
11509 const void *s390_todpreg
,
11512 char *note_name
= "LINUX";
11513 return elfcore_write_note (abfd
, buf
, bufsiz
,
11514 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
11518 elfcore_write_s390_ctrs (bfd
*abfd
,
11521 const void *s390_ctrs
,
11524 char *note_name
= "LINUX";
11525 return elfcore_write_note (abfd
, buf
, bufsiz
,
11526 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
11530 elfcore_write_s390_prefix (bfd
*abfd
,
11533 const void *s390_prefix
,
11536 char *note_name
= "LINUX";
11537 return elfcore_write_note (abfd
, buf
, bufsiz
,
11538 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
11542 elfcore_write_s390_last_break (bfd
*abfd
,
11545 const void *s390_last_break
,
11548 char *note_name
= "LINUX";
11549 return elfcore_write_note (abfd
, buf
, bufsiz
,
11550 note_name
, NT_S390_LAST_BREAK
,
11551 s390_last_break
, size
);
11555 elfcore_write_s390_system_call (bfd
*abfd
,
11558 const void *s390_system_call
,
11561 char *note_name
= "LINUX";
11562 return elfcore_write_note (abfd
, buf
, bufsiz
,
11563 note_name
, NT_S390_SYSTEM_CALL
,
11564 s390_system_call
, size
);
11568 elfcore_write_s390_tdb (bfd
*abfd
,
11571 const void *s390_tdb
,
11574 char *note_name
= "LINUX";
11575 return elfcore_write_note (abfd
, buf
, bufsiz
,
11576 note_name
, NT_S390_TDB
, s390_tdb
, size
);
11580 elfcore_write_s390_vxrs_low (bfd
*abfd
,
11583 const void *s390_vxrs_low
,
11586 char *note_name
= "LINUX";
11587 return elfcore_write_note (abfd
, buf
, bufsiz
,
11588 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
11592 elfcore_write_s390_vxrs_high (bfd
*abfd
,
11595 const void *s390_vxrs_high
,
11598 char *note_name
= "LINUX";
11599 return elfcore_write_note (abfd
, buf
, bufsiz
,
11600 note_name
, NT_S390_VXRS_HIGH
,
11601 s390_vxrs_high
, size
);
11605 elfcore_write_s390_gs_cb (bfd
*abfd
,
11608 const void *s390_gs_cb
,
11611 char *note_name
= "LINUX";
11612 return elfcore_write_note (abfd
, buf
, bufsiz
,
11613 note_name
, NT_S390_GS_CB
,
11618 elfcore_write_s390_gs_bc (bfd
*abfd
,
11621 const void *s390_gs_bc
,
11624 char *note_name
= "LINUX";
11625 return elfcore_write_note (abfd
, buf
, bufsiz
,
11626 note_name
, NT_S390_GS_BC
,
11631 elfcore_write_arm_vfp (bfd
*abfd
,
11634 const void *arm_vfp
,
11637 char *note_name
= "LINUX";
11638 return elfcore_write_note (abfd
, buf
, bufsiz
,
11639 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
11643 elfcore_write_aarch_tls (bfd
*abfd
,
11646 const void *aarch_tls
,
11649 char *note_name
= "LINUX";
11650 return elfcore_write_note (abfd
, buf
, bufsiz
,
11651 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
11655 elfcore_write_aarch_hw_break (bfd
*abfd
,
11658 const void *aarch_hw_break
,
11661 char *note_name
= "LINUX";
11662 return elfcore_write_note (abfd
, buf
, bufsiz
,
11663 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
11667 elfcore_write_aarch_hw_watch (bfd
*abfd
,
11670 const void *aarch_hw_watch
,
11673 char *note_name
= "LINUX";
11674 return elfcore_write_note (abfd
, buf
, bufsiz
,
11675 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
11679 elfcore_write_aarch_sve (bfd
*abfd
,
11682 const void *aarch_sve
,
11685 char *note_name
= "LINUX";
11686 return elfcore_write_note (abfd
, buf
, bufsiz
,
11687 note_name
, NT_ARM_SVE
, aarch_sve
, size
);
11691 elfcore_write_aarch_pauth (bfd
*abfd
,
11694 const void *aarch_pauth
,
11697 char *note_name
= "LINUX";
11698 return elfcore_write_note (abfd
, buf
, bufsiz
,
11699 note_name
, NT_ARM_PAC_MASK
, aarch_pauth
, size
);
11703 elfcore_write_register_note (bfd
*abfd
,
11706 const char *section
,
11710 if (strcmp (section
, ".reg2") == 0)
11711 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
11712 if (strcmp (section
, ".reg-xfp") == 0)
11713 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
11714 if (strcmp (section
, ".reg-xstate") == 0)
11715 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
11716 if (strcmp (section
, ".reg-ppc-vmx") == 0)
11717 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
11718 if (strcmp (section
, ".reg-ppc-vsx") == 0)
11719 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
11720 if (strcmp (section
, ".reg-ppc-tar") == 0)
11721 return elfcore_write_ppc_tar (abfd
, buf
, bufsiz
, data
, size
);
11722 if (strcmp (section
, ".reg-ppc-ppr") == 0)
11723 return elfcore_write_ppc_ppr (abfd
, buf
, bufsiz
, data
, size
);
11724 if (strcmp (section
, ".reg-ppc-dscr") == 0)
11725 return elfcore_write_ppc_dscr (abfd
, buf
, bufsiz
, data
, size
);
11726 if (strcmp (section
, ".reg-ppc-ebb") == 0)
11727 return elfcore_write_ppc_ebb (abfd
, buf
, bufsiz
, data
, size
);
11728 if (strcmp (section
, ".reg-ppc-pmu") == 0)
11729 return elfcore_write_ppc_pmu (abfd
, buf
, bufsiz
, data
, size
);
11730 if (strcmp (section
, ".reg-ppc-tm-cgpr") == 0)
11731 return elfcore_write_ppc_tm_cgpr (abfd
, buf
, bufsiz
, data
, size
);
11732 if (strcmp (section
, ".reg-ppc-tm-cfpr") == 0)
11733 return elfcore_write_ppc_tm_cfpr (abfd
, buf
, bufsiz
, data
, size
);
11734 if (strcmp (section
, ".reg-ppc-tm-cvmx") == 0)
11735 return elfcore_write_ppc_tm_cvmx (abfd
, buf
, bufsiz
, data
, size
);
11736 if (strcmp (section
, ".reg-ppc-tm-cvsx") == 0)
11737 return elfcore_write_ppc_tm_cvsx (abfd
, buf
, bufsiz
, data
, size
);
11738 if (strcmp (section
, ".reg-ppc-tm-spr") == 0)
11739 return elfcore_write_ppc_tm_spr (abfd
, buf
, bufsiz
, data
, size
);
11740 if (strcmp (section
, ".reg-ppc-tm-ctar") == 0)
11741 return elfcore_write_ppc_tm_ctar (abfd
, buf
, bufsiz
, data
, size
);
11742 if (strcmp (section
, ".reg-ppc-tm-cppr") == 0)
11743 return elfcore_write_ppc_tm_cppr (abfd
, buf
, bufsiz
, data
, size
);
11744 if (strcmp (section
, ".reg-ppc-tm-cdscr") == 0)
11745 return elfcore_write_ppc_tm_cdscr (abfd
, buf
, bufsiz
, data
, size
);
11746 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
11747 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
11748 if (strcmp (section
, ".reg-s390-timer") == 0)
11749 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
11750 if (strcmp (section
, ".reg-s390-todcmp") == 0)
11751 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
11752 if (strcmp (section
, ".reg-s390-todpreg") == 0)
11753 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
11754 if (strcmp (section
, ".reg-s390-ctrs") == 0)
11755 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
11756 if (strcmp (section
, ".reg-s390-prefix") == 0)
11757 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
11758 if (strcmp (section
, ".reg-s390-last-break") == 0)
11759 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
11760 if (strcmp (section
, ".reg-s390-system-call") == 0)
11761 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
11762 if (strcmp (section
, ".reg-s390-tdb") == 0)
11763 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
11764 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
11765 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
11766 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
11767 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
11768 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
11769 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
11770 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
11771 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
11772 if (strcmp (section
, ".reg-arm-vfp") == 0)
11773 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
11774 if (strcmp (section
, ".reg-aarch-tls") == 0)
11775 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
11776 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
11777 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
11778 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
11779 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
11780 if (strcmp (section
, ".reg-aarch-sve") == 0)
11781 return elfcore_write_aarch_sve (abfd
, buf
, bufsiz
, data
, size
);
11782 if (strcmp (section
, ".reg-aarch-pauth") == 0)
11783 return elfcore_write_aarch_pauth (abfd
, buf
, bufsiz
, data
, size
);
11788 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
11793 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11794 gABI specifies that PT_NOTE alignment should be aligned to 4
11795 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11796 align is less than 4, we use 4 byte alignment. */
11799 if (align
!= 4 && align
!= 8)
11803 while (p
< buf
+ size
)
11805 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
11806 Elf_Internal_Note in
;
11808 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
11811 in
.type
= H_GET_32 (abfd
, xnp
->type
);
11813 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
11814 in
.namedata
= xnp
->name
;
11815 if (in
.namesz
> buf
- in
.namedata
+ size
)
11818 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
11819 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
11820 in
.descpos
= offset
+ (in
.descdata
- buf
);
11822 && (in
.descdata
>= buf
+ size
11823 || in
.descsz
> buf
- in
.descdata
+ size
))
11826 switch (bfd_get_format (abfd
))
11833 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11836 const char * string
;
11838 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
11842 GROKER_ELEMENT ("", elfcore_grok_note
),
11843 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
11844 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
11845 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
11846 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
11847 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
),
11848 GROKER_ELEMENT ("GNU", elfobj_grok_gnu_note
)
11850 #undef GROKER_ELEMENT
11853 for (i
= ARRAY_SIZE (grokers
); i
--;)
11855 if (in
.namesz
>= grokers
[i
].len
11856 && strncmp (in
.namedata
, grokers
[i
].string
,
11857 grokers
[i
].len
) == 0)
11859 if (! grokers
[i
].func (abfd
, & in
))
11868 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
11870 if (! elfobj_grok_gnu_note (abfd
, &in
))
11873 else if (in
.namesz
== sizeof "stapsdt"
11874 && strcmp (in
.namedata
, "stapsdt") == 0)
11876 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
11882 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
11889 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
11894 if (size
== 0 || (size
+ 1) == 0)
11897 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
11900 buf
= (char *) bfd_malloc (size
+ 1);
11904 /* PR 17512: file: ec08f814
11905 0-termintate the buffer so that string searches will not overflow. */
11908 if (bfd_bread (buf
, size
, abfd
) != size
11909 || !elf_parse_notes (abfd
, buf
, size
, offset
, align
))
11919 /* Providing external access to the ELF program header table. */
11921 /* Return an upper bound on the number of bytes required to store a
11922 copy of ABFD's program header table entries. Return -1 if an error
11923 occurs; bfd_get_error will return an appropriate code. */
11926 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
11928 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11930 bfd_set_error (bfd_error_wrong_format
);
11934 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
11937 /* Copy ABFD's program header table entries to *PHDRS. The entries
11938 will be stored as an array of Elf_Internal_Phdr structures, as
11939 defined in include/elf/internal.h. To find out how large the
11940 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11942 Return the number of program header table entries read, or -1 if an
11943 error occurs; bfd_get_error will return an appropriate code. */
11946 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
11950 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11952 bfd_set_error (bfd_error_wrong_format
);
11956 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
11957 if (num_phdrs
!= 0)
11958 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
11959 num_phdrs
* sizeof (Elf_Internal_Phdr
));
11964 enum elf_reloc_type_class
11965 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11966 const asection
*rel_sec ATTRIBUTE_UNUSED
,
11967 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
11969 return reloc_class_normal
;
11972 /* For RELA architectures, return the relocation value for a
11973 relocation against a local symbol. */
11976 _bfd_elf_rela_local_sym (bfd
*abfd
,
11977 Elf_Internal_Sym
*sym
,
11979 Elf_Internal_Rela
*rel
)
11981 asection
*sec
= *psec
;
11982 bfd_vma relocation
;
11984 relocation
= (sec
->output_section
->vma
11985 + sec
->output_offset
11987 if ((sec
->flags
& SEC_MERGE
)
11988 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
11989 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
11992 _bfd_merged_section_offset (abfd
, psec
,
11993 elf_section_data (sec
)->sec_info
,
11994 sym
->st_value
+ rel
->r_addend
);
11997 /* If we have changed the section, and our original section is
11998 marked with SEC_EXCLUDE, it means that the original
11999 SEC_MERGE section has been completely subsumed in some
12000 other SEC_MERGE section. In this case, we need to leave
12001 some info around for --emit-relocs. */
12002 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
12003 sec
->kept_section
= *psec
;
12006 rel
->r_addend
-= relocation
;
12007 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
12013 _bfd_elf_rel_local_sym (bfd
*abfd
,
12014 Elf_Internal_Sym
*sym
,
12018 asection
*sec
= *psec
;
12020 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
12021 return sym
->st_value
+ addend
;
12023 return _bfd_merged_section_offset (abfd
, psec
,
12024 elf_section_data (sec
)->sec_info
,
12025 sym
->st_value
+ addend
);
12028 /* Adjust an address within a section. Given OFFSET within SEC, return
12029 the new offset within the section, based upon changes made to the
12030 section. Returns -1 if the offset is now invalid.
12031 The offset (in abnd out) is in target sized bytes, however big a
12035 _bfd_elf_section_offset (bfd
*abfd
,
12036 struct bfd_link_info
*info
,
12040 switch (sec
->sec_info_type
)
12042 case SEC_INFO_TYPE_STABS
:
12043 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
12045 case SEC_INFO_TYPE_EH_FRAME
:
12046 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
12049 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
12051 /* Reverse the offset. */
12052 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12053 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
12055 /* address_size and sec->size are in octets. Convert
12056 to bytes before subtracting the original offset. */
12057 offset
= (sec
->size
- address_size
) / bfd_octets_per_byte (abfd
) - offset
;
12063 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
12064 reconstruct an ELF file by reading the segments out of remote memory
12065 based on the ELF file header at EHDR_VMA and the ELF program headers it
12066 points to. If not null, *LOADBASEP is filled in with the difference
12067 between the VMAs from which the segments were read, and the VMAs the
12068 file headers (and hence BFD's idea of each section's VMA) put them at.
12070 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
12071 remote memory at target address VMA into the local buffer at MYADDR; it
12072 should return zero on success or an `errno' code on failure. TEMPL must
12073 be a BFD for an ELF target with the word size and byte order found in
12074 the remote memory. */
12077 bfd_elf_bfd_from_remote_memory
12080 bfd_size_type size
,
12081 bfd_vma
*loadbasep
,
12082 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
12084 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
12085 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
12089 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
12090 long symcount ATTRIBUTE_UNUSED
,
12091 asymbol
**syms ATTRIBUTE_UNUSED
,
12096 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
12099 const char *relplt_name
;
12100 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
12104 Elf_Internal_Shdr
*hdr
;
12110 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
12113 if (dynsymcount
<= 0)
12116 if (!bed
->plt_sym_val
)
12119 relplt_name
= bed
->relplt_name
;
12120 if (relplt_name
== NULL
)
12121 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
12122 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
12123 if (relplt
== NULL
)
12126 hdr
= &elf_section_data (relplt
)->this_hdr
;
12127 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
12128 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
12131 plt
= bfd_get_section_by_name (abfd
, ".plt");
12135 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
12136 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
12139 count
= relplt
->size
/ hdr
->sh_entsize
;
12140 size
= count
* sizeof (asymbol
);
12141 p
= relplt
->relocation
;
12142 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12144 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
12145 if (p
->addend
!= 0)
12148 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
12150 size
+= sizeof ("+0x") - 1 + 8;
12155 s
= *ret
= (asymbol
*) bfd_malloc (size
);
12159 names
= (char *) (s
+ count
);
12160 p
= relplt
->relocation
;
12162 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
12167 addr
= bed
->plt_sym_val (i
, plt
, p
);
12168 if (addr
== (bfd_vma
) -1)
12171 *s
= **p
->sym_ptr_ptr
;
12172 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
12173 we are defining a symbol, ensure one of them is set. */
12174 if ((s
->flags
& BSF_LOCAL
) == 0)
12175 s
->flags
|= BSF_GLOBAL
;
12176 s
->flags
|= BSF_SYNTHETIC
;
12178 s
->value
= addr
- plt
->vma
;
12181 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
12182 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
12184 if (p
->addend
!= 0)
12188 memcpy (names
, "+0x", sizeof ("+0x") - 1);
12189 names
+= sizeof ("+0x") - 1;
12190 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
12191 for (a
= buf
; *a
== '0'; ++a
)
12194 memcpy (names
, a
, len
);
12197 memcpy (names
, "@plt", sizeof ("@plt"));
12198 names
+= sizeof ("@plt");
12205 /* It is only used by x86-64 so far.
12206 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
12207 but current usage would allow all of _bfd_std_section to be zero. */
12208 static const asymbol lcomm_sym
12209 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
12210 asection _bfd_elf_large_com_section
12211 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
12212 "LARGE_COMMON", 0, SEC_IS_COMMON
);
12215 _bfd_elf_final_write_processing (bfd
*abfd
)
12217 Elf_Internal_Ehdr
*i_ehdrp
; /* ELF file header, internal form. */
12219 i_ehdrp
= elf_elfheader (abfd
);
12221 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12222 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
12224 /* Set the osabi field to ELFOSABI_GNU if the binary contains
12225 SHF_GNU_MBIND sections or symbols of STT_GNU_IFUNC type or
12226 STB_GNU_UNIQUE binding. */
12227 if (elf_tdata (abfd
)->has_gnu_osabi
!= 0)
12229 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
)
12230 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
12231 else if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
12232 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_FREEBSD
)
12234 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_mbind
)
12235 _bfd_error_handler (_("GNU_MBIND section is unsupported"));
12236 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_ifunc
)
12237 _bfd_error_handler (_("symbol type STT_GNU_IFUNC is unsupported"));
12238 if (elf_tdata (abfd
)->has_gnu_osabi
& elf_gnu_osabi_unique
)
12239 _bfd_error_handler (_("symbol binding STB_GNU_UNIQUE is unsupported"));
12240 bfd_set_error (bfd_error_sorry
);
12248 /* Return TRUE for ELF symbol types that represent functions.
12249 This is the default version of this function, which is sufficient for
12250 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
12253 _bfd_elf_is_function_type (unsigned int type
)
12255 return (type
== STT_FUNC
12256 || type
== STT_GNU_IFUNC
);
12259 /* If the ELF symbol SYM might be a function in SEC, return the
12260 function size and set *CODE_OFF to the function's entry point,
12261 otherwise return zero. */
12264 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
12267 bfd_size_type size
;
12269 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
12270 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
12271 || sym
->section
!= sec
)
12274 *code_off
= sym
->value
;
12276 if (!(sym
->flags
& BSF_SYNTHETIC
))
12277 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;