1 /* ELF executable support for BFD.
3 Copyright (C) 1993-2018 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. */
43 #include "libiberty.h"
44 #include "safe-ctype.h"
45 #include "elf-linux-core.h"
51 static int elf_sort_sections (const void *, const void *);
52 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
53 static bfd_boolean
prep_headers (bfd
*);
54 static bfd_boolean
swap_out_syms (bfd
*, struct elf_strtab_hash
**, int) ;
55 static bfd_boolean
elf_read_notes (bfd
*, file_ptr
, bfd_size_type
,
57 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
58 file_ptr offset
, size_t align
);
60 /* Swap version information in and out. The version information is
61 currently size independent. If that ever changes, this code will
62 need to move into elfcode.h. */
64 /* Swap in a Verdef structure. */
67 _bfd_elf_swap_verdef_in (bfd
*abfd
,
68 const Elf_External_Verdef
*src
,
69 Elf_Internal_Verdef
*dst
)
71 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
72 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
73 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
74 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
75 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
76 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
77 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
80 /* Swap out a Verdef structure. */
83 _bfd_elf_swap_verdef_out (bfd
*abfd
,
84 const Elf_Internal_Verdef
*src
,
85 Elf_External_Verdef
*dst
)
87 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
88 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
89 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
90 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
91 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
92 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
93 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
96 /* Swap in a Verdaux structure. */
99 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
100 const Elf_External_Verdaux
*src
,
101 Elf_Internal_Verdaux
*dst
)
103 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
104 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
111 const Elf_Internal_Verdaux
*src
,
112 Elf_External_Verdaux
*dst
)
114 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
115 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
118 /* Swap in a Verneed structure. */
121 _bfd_elf_swap_verneed_in (bfd
*abfd
,
122 const Elf_External_Verneed
*src
,
123 Elf_Internal_Verneed
*dst
)
125 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
126 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
127 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
128 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
129 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
132 /* Swap out a Verneed structure. */
135 _bfd_elf_swap_verneed_out (bfd
*abfd
,
136 const Elf_Internal_Verneed
*src
,
137 Elf_External_Verneed
*dst
)
139 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
140 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
141 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
142 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
143 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
146 /* Swap in a Vernaux structure. */
149 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
150 const Elf_External_Vernaux
*src
,
151 Elf_Internal_Vernaux
*dst
)
153 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
154 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
155 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
156 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
157 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
160 /* Swap out a Vernaux structure. */
163 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
164 const Elf_Internal_Vernaux
*src
,
165 Elf_External_Vernaux
*dst
)
167 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
168 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
169 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
170 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
171 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
174 /* Swap in a Versym structure. */
177 _bfd_elf_swap_versym_in (bfd
*abfd
,
178 const Elf_External_Versym
*src
,
179 Elf_Internal_Versym
*dst
)
181 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
184 /* Swap out a Versym structure. */
187 _bfd_elf_swap_versym_out (bfd
*abfd
,
188 const Elf_Internal_Versym
*src
,
189 Elf_External_Versym
*dst
)
191 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
194 /* Standard ELF hash function. Do not change this function; you will
195 cause invalid hash tables to be generated. */
198 bfd_elf_hash (const char *namearg
)
200 const unsigned char *name
= (const unsigned char *) namearg
;
205 while ((ch
= *name
++) != '\0')
208 if ((g
= (h
& 0xf0000000)) != 0)
211 /* The ELF ABI says `h &= ~g', but this is equivalent in
212 this case and on some machines one insn instead of two. */
216 return h
& 0xffffffff;
219 /* DT_GNU_HASH hash function. Do not change this function; you will
220 cause invalid hash tables to be generated. */
223 bfd_elf_gnu_hash (const char *namearg
)
225 const unsigned char *name
= (const unsigned char *) namearg
;
226 unsigned long h
= 5381;
229 while ((ch
= *name
++) != '\0')
230 h
= (h
<< 5) + h
+ ch
;
231 return h
& 0xffffffff;
234 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
235 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
237 bfd_elf_allocate_object (bfd
*abfd
,
239 enum elf_target_id object_id
)
241 BFD_ASSERT (object_size
>= sizeof (struct elf_obj_tdata
));
242 abfd
->tdata
.any
= bfd_zalloc (abfd
, object_size
);
243 if (abfd
->tdata
.any
== NULL
)
246 elf_object_id (abfd
) = object_id
;
247 if (abfd
->direction
!= read_direction
)
249 struct output_elf_obj_tdata
*o
= bfd_zalloc (abfd
, sizeof *o
);
252 elf_tdata (abfd
)->o
= o
;
253 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
260 bfd_elf_make_object (bfd
*abfd
)
262 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
263 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
268 bfd_elf_mkcorefile (bfd
*abfd
)
270 /* I think this can be done just like an object file. */
271 if (!abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
))
273 elf_tdata (abfd
)->core
= bfd_zalloc (abfd
, sizeof (*elf_tdata (abfd
)->core
));
274 return elf_tdata (abfd
)->core
!= NULL
;
278 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
280 Elf_Internal_Shdr
**i_shdrp
;
281 bfd_byte
*shstrtab
= NULL
;
283 bfd_size_type shstrtabsize
;
285 i_shdrp
= elf_elfsections (abfd
);
287 || shindex
>= elf_numsections (abfd
)
288 || i_shdrp
[shindex
] == 0)
291 shstrtab
= i_shdrp
[shindex
]->contents
;
292 if (shstrtab
== NULL
)
294 /* No cached one, attempt to read, and cache what we read. */
295 offset
= i_shdrp
[shindex
]->sh_offset
;
296 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
298 /* Allocate and clear an extra byte at the end, to prevent crashes
299 in case the string table is not terminated. */
300 if (shstrtabsize
+ 1 <= 1
301 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0
302 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
)
304 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
306 if (bfd_get_error () != bfd_error_system_call
)
307 bfd_set_error (bfd_error_file_truncated
);
308 bfd_release (abfd
, shstrtab
);
310 /* Once we've failed to read it, make sure we don't keep
311 trying. Otherwise, we'll keep allocating space for
312 the string table over and over. */
313 i_shdrp
[shindex
]->sh_size
= 0;
316 shstrtab
[shstrtabsize
] = '\0';
317 i_shdrp
[shindex
]->contents
= shstrtab
;
319 return (char *) shstrtab
;
323 bfd_elf_string_from_elf_section (bfd
*abfd
,
324 unsigned int shindex
,
325 unsigned int strindex
)
327 Elf_Internal_Shdr
*hdr
;
332 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
335 hdr
= elf_elfsections (abfd
)[shindex
];
337 if (hdr
->contents
== NULL
)
339 if (hdr
->sh_type
!= SHT_STRTAB
&& hdr
->sh_type
< SHT_LOOS
)
341 /* PR 17512: file: f057ec89. */
342 /* xgettext:c-format */
343 _bfd_error_handler (_("%B: attempt to load strings from"
344 " a non-string section (number %d)"),
349 if (bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
353 if (strindex
>= hdr
->sh_size
)
355 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
357 /* xgettext:c-format */
358 (_("%B: invalid string offset %u >= %Lu for section `%s'"),
359 abfd
, strindex
, hdr
->sh_size
,
360 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
362 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
366 return ((char *) hdr
->contents
) + strindex
;
369 /* Read and convert symbols to internal format.
370 SYMCOUNT specifies the number of symbols to read, starting from
371 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
372 are non-NULL, they are used to store the internal symbols, external
373 symbols, and symbol section index extensions, respectively.
374 Returns a pointer to the internal symbol buffer (malloced if necessary)
375 or NULL if there were no symbols or some kind of problem. */
378 bfd_elf_get_elf_syms (bfd
*ibfd
,
379 Elf_Internal_Shdr
*symtab_hdr
,
382 Elf_Internal_Sym
*intsym_buf
,
384 Elf_External_Sym_Shndx
*extshndx_buf
)
386 Elf_Internal_Shdr
*shndx_hdr
;
388 const bfd_byte
*esym
;
389 Elf_External_Sym_Shndx
*alloc_extshndx
;
390 Elf_External_Sym_Shndx
*shndx
;
391 Elf_Internal_Sym
*alloc_intsym
;
392 Elf_Internal_Sym
*isym
;
393 Elf_Internal_Sym
*isymend
;
394 const struct elf_backend_data
*bed
;
399 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
405 /* Normal syms might have section extension entries. */
407 if (elf_symtab_shndx_list (ibfd
) != NULL
)
409 elf_section_list
* entry
;
410 Elf_Internal_Shdr
**sections
= elf_elfsections (ibfd
);
412 /* Find an index section that is linked to this symtab section. */
413 for (entry
= elf_symtab_shndx_list (ibfd
); entry
!= NULL
; entry
= entry
->next
)
416 if (entry
->hdr
.sh_link
>= elf_numsections (ibfd
))
419 if (sections
[entry
->hdr
.sh_link
] == symtab_hdr
)
421 shndx_hdr
= & entry
->hdr
;
426 if (shndx_hdr
== NULL
)
428 if (symtab_hdr
== & elf_symtab_hdr (ibfd
))
429 /* Not really accurate, but this was how the old code used to work. */
430 shndx_hdr
= & elf_symtab_shndx_list (ibfd
)->hdr
;
431 /* Otherwise we do nothing. The assumption is that
432 the index table will not be needed. */
436 /* Read the symbols. */
438 alloc_extshndx
= NULL
;
440 bed
= get_elf_backend_data (ibfd
);
441 extsym_size
= bed
->s
->sizeof_sym
;
442 amt
= (bfd_size_type
) symcount
* extsym_size
;
443 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
444 if (extsym_buf
== NULL
)
446 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
447 extsym_buf
= alloc_ext
;
449 if (extsym_buf
== NULL
450 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
451 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
457 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
461 amt
= (bfd_size_type
) symcount
* sizeof (Elf_External_Sym_Shndx
);
462 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
463 if (extshndx_buf
== NULL
)
465 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
466 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
467 extshndx_buf
= alloc_extshndx
;
469 if (extshndx_buf
== NULL
470 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
471 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
478 if (intsym_buf
== NULL
)
480 alloc_intsym
= (Elf_Internal_Sym
*)
481 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
482 intsym_buf
= alloc_intsym
;
483 if (intsym_buf
== NULL
)
487 /* Convert the symbols to internal form. */
488 isymend
= intsym_buf
+ symcount
;
489 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
490 shndx
= extshndx_buf
;
492 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
493 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
495 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
496 /* xgettext:c-format */
497 _bfd_error_handler (_("%B symbol number %lu references"
498 " nonexistent SHT_SYMTAB_SHNDX section"),
499 ibfd
, (unsigned long) symoffset
);
500 if (alloc_intsym
!= NULL
)
507 if (alloc_ext
!= NULL
)
509 if (alloc_extshndx
!= NULL
)
510 free (alloc_extshndx
);
515 /* Look up a symbol name. */
517 bfd_elf_sym_name (bfd
*abfd
,
518 Elf_Internal_Shdr
*symtab_hdr
,
519 Elf_Internal_Sym
*isym
,
523 unsigned int iname
= isym
->st_name
;
524 unsigned int shindex
= symtab_hdr
->sh_link
;
526 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
527 /* Check for a bogus st_shndx to avoid crashing. */
528 && isym
->st_shndx
< elf_numsections (abfd
))
530 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
531 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
534 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
537 else if (sym_sec
&& *name
== '\0')
538 name
= bfd_section_name (abfd
, sym_sec
);
543 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
544 sections. The first element is the flags, the rest are section
547 typedef union elf_internal_group
{
548 Elf_Internal_Shdr
*shdr
;
550 } Elf_Internal_Group
;
552 /* Return the name of the group signature symbol. Why isn't the
553 signature just a string? */
556 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
558 Elf_Internal_Shdr
*hdr
;
559 unsigned char esym
[sizeof (Elf64_External_Sym
)];
560 Elf_External_Sym_Shndx eshndx
;
561 Elf_Internal_Sym isym
;
563 /* First we need to ensure the symbol table is available. Make sure
564 that it is a symbol table section. */
565 if (ghdr
->sh_link
>= elf_numsections (abfd
))
567 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
568 if (hdr
->sh_type
!= SHT_SYMTAB
569 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
572 /* Go read the symbol. */
573 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
574 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
575 &isym
, esym
, &eshndx
) == NULL
)
578 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
581 /* Set next_in_group list pointer, and group name for NEWSECT. */
584 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
586 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
588 /* If num_group is zero, read in all SHT_GROUP sections. The count
589 is set to -1 if there are no SHT_GROUP sections. */
592 unsigned int i
, shnum
;
594 /* First count the number of groups. If we have a SHT_GROUP
595 section with just a flag word (ie. sh_size is 4), ignore it. */
596 shnum
= elf_numsections (abfd
);
599 #define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
600 ( (shdr)->sh_type == SHT_GROUP \
601 && (shdr)->sh_size >= minsize \
602 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
603 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
605 for (i
= 0; i
< shnum
; i
++)
607 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
609 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
615 num_group
= (unsigned) -1;
616 elf_tdata (abfd
)->num_group
= num_group
;
617 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
621 /* We keep a list of elf section headers for group sections,
622 so we can find them quickly. */
625 elf_tdata (abfd
)->num_group
= num_group
;
626 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
627 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
628 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
630 memset (elf_tdata (abfd
)->group_sect_ptr
, 0, num_group
* sizeof (Elf_Internal_Shdr
*));
633 for (i
= 0; i
< shnum
; i
++)
635 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
637 if (IS_VALID_GROUP_SECTION_HEADER (shdr
, 2 * GRP_ENTRY_SIZE
))
640 Elf_Internal_Group
*dest
;
642 /* Make sure the group section has a BFD section
644 if (!bfd_section_from_shdr (abfd
, i
))
647 /* Add to list of sections. */
648 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
651 /* Read the raw contents. */
652 BFD_ASSERT (sizeof (*dest
) >= 4);
653 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
654 shdr
->contents
= (unsigned char *)
655 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
656 /* PR binutils/4110: Handle corrupt group headers. */
657 if (shdr
->contents
== NULL
)
660 /* xgettext:c-format */
661 (_("%B: corrupt size field in group section"
662 " header: %#Lx"), abfd
, shdr
->sh_size
);
663 bfd_set_error (bfd_error_bad_value
);
668 memset (shdr
->contents
, 0, amt
);
670 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
671 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
675 /* xgettext:c-format */
676 (_("%B: invalid size field in group section"
677 " header: %#Lx"), abfd
, shdr
->sh_size
);
678 bfd_set_error (bfd_error_bad_value
);
680 /* PR 17510: If the group contents are even
681 partially corrupt, do not allow any of the
682 contents to be used. */
683 memset (shdr
->contents
, 0, amt
);
687 /* Translate raw contents, a flag word followed by an
688 array of elf section indices all in target byte order,
689 to the flag word followed by an array of elf section
691 src
= shdr
->contents
+ shdr
->sh_size
;
692 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
700 idx
= H_GET_32 (abfd
, src
);
701 if (src
== shdr
->contents
)
704 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
705 shdr
->bfd_section
->flags
706 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
712 (_("%B: invalid SHT_GROUP entry"), abfd
);
715 dest
->shdr
= elf_elfsections (abfd
)[idx
];
720 /* PR 17510: Corrupt binaries might contain invalid groups. */
721 if (num_group
!= (unsigned) elf_tdata (abfd
)->num_group
)
723 elf_tdata (abfd
)->num_group
= num_group
;
725 /* If all groups are invalid then fail. */
728 elf_tdata (abfd
)->group_sect_ptr
= NULL
;
729 elf_tdata (abfd
)->num_group
= num_group
= -1;
731 (_("%B: no valid group sections found"), abfd
);
732 bfd_set_error (bfd_error_bad_value
);
738 if (num_group
!= (unsigned) -1)
740 unsigned int search_offset
= elf_tdata (abfd
)->group_search_offset
;
743 for (j
= 0; j
< num_group
; j
++)
745 /* Begin search from previous found group. */
746 unsigned i
= (j
+ search_offset
) % num_group
;
748 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
749 Elf_Internal_Group
*idx
;
755 idx
= (Elf_Internal_Group
*) shdr
->contents
;
756 if (idx
== NULL
|| shdr
->sh_size
< 4)
758 /* See PR 21957 for a reproducer. */
759 /* xgettext:c-format */
760 _bfd_error_handler (_("%B: group section '%A' has no contents"),
761 abfd
, shdr
->bfd_section
);
762 elf_tdata (abfd
)->group_sect_ptr
[i
] = NULL
;
763 bfd_set_error (bfd_error_bad_value
);
766 n_elt
= shdr
->sh_size
/ 4;
768 /* Look through this group's sections to see if current
769 section is a member. */
771 if ((++idx
)->shdr
== hdr
)
775 /* We are a member of this group. Go looking through
776 other members to see if any others are linked via
778 idx
= (Elf_Internal_Group
*) shdr
->contents
;
779 n_elt
= shdr
->sh_size
/ 4;
781 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
782 && elf_next_in_group (s
) != NULL
)
786 /* Snarf the group name from other member, and
787 insert current section in circular list. */
788 elf_group_name (newsect
) = elf_group_name (s
);
789 elf_next_in_group (newsect
) = elf_next_in_group (s
);
790 elf_next_in_group (s
) = newsect
;
796 gname
= group_signature (abfd
, shdr
);
799 elf_group_name (newsect
) = gname
;
801 /* Start a circular list with one element. */
802 elf_next_in_group (newsect
) = newsect
;
805 /* If the group section has been created, point to the
807 if (shdr
->bfd_section
!= NULL
)
808 elf_next_in_group (shdr
->bfd_section
) = newsect
;
810 elf_tdata (abfd
)->group_search_offset
= i
;
817 if (elf_group_name (newsect
) == NULL
)
819 /* xgettext:c-format */
820 _bfd_error_handler (_("%B: no group info for section '%A'"),
828 _bfd_elf_setup_sections (bfd
*abfd
)
831 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
832 bfd_boolean result
= TRUE
;
835 /* Process SHF_LINK_ORDER. */
836 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
838 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
839 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
841 unsigned int elfsec
= this_hdr
->sh_link
;
842 /* FIXME: The old Intel compiler and old strip/objcopy may
843 not set the sh_link or sh_info fields. Hence we could
844 get the situation where elfsec is 0. */
847 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
848 if (bed
->link_order_error_handler
)
849 bed
->link_order_error_handler
850 /* xgettext:c-format */
851 (_("%B: warning: sh_link not set for section `%A'"),
856 asection
*linksec
= NULL
;
858 if (elfsec
< elf_numsections (abfd
))
860 this_hdr
= elf_elfsections (abfd
)[elfsec
];
861 linksec
= this_hdr
->bfd_section
;
865 Some strip/objcopy may leave an incorrect value in
866 sh_link. We don't want to proceed. */
870 /* xgettext:c-format */
871 (_("%B: sh_link [%d] in section `%A' is incorrect"),
872 s
->owner
, elfsec
, s
);
876 elf_linked_to_section (s
) = linksec
;
879 else if (this_hdr
->sh_type
== SHT_GROUP
880 && elf_next_in_group (s
) == NULL
)
883 /* xgettext:c-format */
884 (_("%B: SHT_GROUP section [index %d] has no SHF_GROUP sections"),
885 abfd
, elf_section_data (s
)->this_idx
);
890 /* Process section groups. */
891 if (num_group
== (unsigned) -1)
894 for (i
= 0; i
< num_group
; i
++)
896 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
897 Elf_Internal_Group
*idx
;
900 /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */
901 if (shdr
== NULL
|| shdr
->bfd_section
== NULL
|| shdr
->contents
== NULL
)
904 /* xgettext:c-format */
905 (_("%B: section group entry number %u is corrupt"),
911 idx
= (Elf_Internal_Group
*) shdr
->contents
;
912 n_elt
= shdr
->sh_size
/ 4;
918 if (idx
->shdr
== NULL
)
920 else if (idx
->shdr
->bfd_section
)
921 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
922 else if (idx
->shdr
->sh_type
!= SHT_RELA
923 && idx
->shdr
->sh_type
!= SHT_REL
)
925 /* There are some unknown sections in the group. */
927 /* xgettext:c-format */
928 (_("%B: unknown type [%#x] section `%s' in group [%A]"),
931 bfd_elf_string_from_elf_section (abfd
,
932 (elf_elfheader (abfd
)
945 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
947 return elf_next_in_group (sec
) != NULL
;
951 convert_debug_to_zdebug (bfd
*abfd
, const char *name
)
953 unsigned int len
= strlen (name
);
954 char *new_name
= bfd_alloc (abfd
, len
+ 2);
955 if (new_name
== NULL
)
959 memcpy (new_name
+ 2, name
+ 1, len
);
964 convert_zdebug_to_debug (bfd
*abfd
, const char *name
)
966 unsigned int len
= strlen (name
);
967 char *new_name
= bfd_alloc (abfd
, len
);
968 if (new_name
== NULL
)
971 memcpy (new_name
+ 1, name
+ 2, len
- 1);
975 /* Make a BFD section from an ELF section. We store a pointer to the
976 BFD section in the bfd_section field of the header. */
979 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
980 Elf_Internal_Shdr
*hdr
,
986 const struct elf_backend_data
*bed
;
988 if (hdr
->bfd_section
!= NULL
)
991 newsect
= bfd_make_section_anyway (abfd
, name
);
995 hdr
->bfd_section
= newsect
;
996 elf_section_data (newsect
)->this_hdr
= *hdr
;
997 elf_section_data (newsect
)->this_idx
= shindex
;
999 /* Always use the real type/flags. */
1000 elf_section_type (newsect
) = hdr
->sh_type
;
1001 elf_section_flags (newsect
) = hdr
->sh_flags
;
1003 newsect
->filepos
= hdr
->sh_offset
;
1005 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
1006 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
1007 || ! bfd_set_section_alignment (abfd
, newsect
,
1008 bfd_log2 (hdr
->sh_addralign
)))
1011 flags
= SEC_NO_FLAGS
;
1012 if (hdr
->sh_type
!= SHT_NOBITS
)
1013 flags
|= SEC_HAS_CONTENTS
;
1014 if (hdr
->sh_type
== SHT_GROUP
)
1016 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1019 if (hdr
->sh_type
!= SHT_NOBITS
)
1022 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
1023 flags
|= SEC_READONLY
;
1024 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
1026 else if ((flags
& SEC_LOAD
) != 0)
1028 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
1031 newsect
->entsize
= hdr
->sh_entsize
;
1033 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
1034 flags
|= SEC_STRINGS
;
1035 if (hdr
->sh_flags
& SHF_GROUP
)
1036 if (!setup_group (abfd
, hdr
, newsect
))
1038 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
1039 flags
|= SEC_THREAD_LOCAL
;
1040 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
1041 flags
|= SEC_EXCLUDE
;
1043 if ((flags
& SEC_ALLOC
) == 0)
1045 /* The debugging sections appear to be recognized only by name,
1046 not any sort of flag. Their SEC_ALLOC bits are cleared. */
1047 if (name
[0] == '.')
1052 p
= ".debug", n
= 6;
1053 else if (name
[1] == 'g' && name
[2] == 'n')
1054 p
= ".gnu.linkonce.wi.", n
= 17;
1055 else if (name
[1] == 'g' && name
[2] == 'd')
1056 p
= ".gdb_index", n
= 11; /* yes we really do mean 11. */
1057 else if (name
[1] == 'l')
1059 else if (name
[1] == 's')
1061 else if (name
[1] == 'z')
1062 p
= ".zdebug", n
= 7;
1065 if (p
!= NULL
&& strncmp (name
, p
, n
) == 0)
1066 flags
|= SEC_DEBUGGING
;
1070 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1071 only link a single copy of the section. This is used to support
1072 g++. g++ will emit each template expansion in its own section.
1073 The symbols will be defined as weak, so that multiple definitions
1074 are permitted. The GNU linker extension is to actually discard
1075 all but one of the sections. */
1076 if (CONST_STRNEQ (name
, ".gnu.linkonce")
1077 && elf_next_in_group (newsect
) == NULL
)
1078 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1080 bed
= get_elf_backend_data (abfd
);
1081 if (bed
->elf_backend_section_flags
)
1082 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
1085 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
1088 /* We do not parse the PT_NOTE segments as we are interested even in the
1089 separate debug info files which may have the segments offsets corrupted.
1090 PT_NOTEs from the core files are currently not parsed using BFD. */
1091 if (hdr
->sh_type
== SHT_NOTE
)
1095 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
1098 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
,
1099 hdr
->sh_offset
, hdr
->sh_addralign
);
1103 if ((flags
& SEC_ALLOC
) != 0)
1105 Elf_Internal_Phdr
*phdr
;
1106 unsigned int i
, nload
;
1108 /* Some ELF linkers produce binaries with all the program header
1109 p_paddr fields zero. If we have such a binary with more than
1110 one PT_LOAD header, then leave the section lma equal to vma
1111 so that we don't create sections with overlapping lma. */
1112 phdr
= elf_tdata (abfd
)->phdr
;
1113 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1114 if (phdr
->p_paddr
!= 0)
1116 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
1118 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
1121 phdr
= elf_tdata (abfd
)->phdr
;
1122 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
1124 if (((phdr
->p_type
== PT_LOAD
1125 && (hdr
->sh_flags
& SHF_TLS
) == 0)
1126 || phdr
->p_type
== PT_TLS
)
1127 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
1129 if ((flags
& SEC_LOAD
) == 0)
1130 newsect
->lma
= (phdr
->p_paddr
1131 + hdr
->sh_addr
- phdr
->p_vaddr
);
1133 /* We used to use the same adjustment for SEC_LOAD
1134 sections, but that doesn't work if the segment
1135 is packed with code from multiple VMAs.
1136 Instead we calculate the section LMA based on
1137 the segment LMA. It is assumed that the
1138 segment will contain sections with contiguous
1139 LMAs, even if the VMAs are not. */
1140 newsect
->lma
= (phdr
->p_paddr
1141 + hdr
->sh_offset
- phdr
->p_offset
);
1143 /* With contiguous segments, we can't tell from file
1144 offsets whether a section with zero size should
1145 be placed at the end of one segment or the
1146 beginning of the next. Decide based on vaddr. */
1147 if (hdr
->sh_addr
>= phdr
->p_vaddr
1148 && (hdr
->sh_addr
+ hdr
->sh_size
1149 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1155 /* Compress/decompress DWARF debug sections with names: .debug_* and
1156 .zdebug_*, after the section flags is set. */
1157 if ((flags
& SEC_DEBUGGING
)
1158 && ((name
[1] == 'd' && name
[6] == '_')
1159 || (name
[1] == 'z' && name
[7] == '_')))
1161 enum { nothing
, compress
, decompress
} action
= nothing
;
1162 int compression_header_size
;
1163 bfd_size_type uncompressed_size
;
1164 bfd_boolean compressed
1165 = bfd_is_section_compressed_with_header (abfd
, newsect
,
1166 &compression_header_size
,
1167 &uncompressed_size
);
1171 /* Compressed section. Check if we should decompress. */
1172 if ((abfd
->flags
& BFD_DECOMPRESS
))
1173 action
= decompress
;
1176 /* Compress the uncompressed section or convert from/to .zdebug*
1177 section. Check if we should compress. */
1178 if (action
== nothing
)
1180 if (newsect
->size
!= 0
1181 && (abfd
->flags
& BFD_COMPRESS
)
1182 && compression_header_size
>= 0
1183 && uncompressed_size
> 0
1185 || ((compression_header_size
> 0)
1186 != ((abfd
->flags
& BFD_COMPRESS_GABI
) != 0))))
1192 if (action
== compress
)
1194 if (!bfd_init_section_compress_status (abfd
, newsect
))
1197 /* xgettext:c-format */
1198 (_("%B: unable to initialize compress status for section %s"),
1205 if (!bfd_init_section_decompress_status (abfd
, newsect
))
1208 /* xgettext:c-format */
1209 (_("%B: unable to initialize decompress status for section %s"),
1215 if (abfd
->is_linker_input
)
1218 && (action
== decompress
1219 || (action
== compress
1220 && (abfd
->flags
& BFD_COMPRESS_GABI
) != 0)))
1222 /* Convert section name from .zdebug_* to .debug_* so
1223 that linker will consider this section as a debug
1225 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
1226 if (new_name
== NULL
)
1228 bfd_rename_section (abfd
, newsect
, new_name
);
1232 /* For objdump, don't rename the section. For objcopy, delay
1233 section rename to elf_fake_sections. */
1234 newsect
->flags
|= SEC_ELF_RENAME
;
1240 const char *const bfd_elf_section_type_names
[] =
1242 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1243 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1244 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1247 /* ELF relocs are against symbols. If we are producing relocatable
1248 output, and the reloc is against an external symbol, and nothing
1249 has given us any additional addend, the resulting reloc will also
1250 be against the same symbol. In such a case, we don't want to
1251 change anything about the way the reloc is handled, since it will
1252 all be done at final link time. Rather than put special case code
1253 into bfd_perform_relocation, all the reloc types use this howto
1254 function. It just short circuits the reloc if producing
1255 relocatable output against an external symbol. */
1257 bfd_reloc_status_type
1258 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1259 arelent
*reloc_entry
,
1261 void *data ATTRIBUTE_UNUSED
,
1262 asection
*input_section
,
1264 char **error_message ATTRIBUTE_UNUSED
)
1266 if (output_bfd
!= NULL
1267 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1268 && (! reloc_entry
->howto
->partial_inplace
1269 || reloc_entry
->addend
== 0))
1271 reloc_entry
->address
+= input_section
->output_offset
;
1272 return bfd_reloc_ok
;
1275 return bfd_reloc_continue
;
1278 /* Returns TRUE if section A matches section B.
1279 Names, addresses and links may be different, but everything else
1280 should be the same. */
1283 section_match (const Elf_Internal_Shdr
* a
,
1284 const Elf_Internal_Shdr
* b
)
1287 a
->sh_type
== b
->sh_type
1288 && (a
->sh_flags
& ~ SHF_INFO_LINK
)
1289 == (b
->sh_flags
& ~ SHF_INFO_LINK
)
1290 && a
->sh_addralign
== b
->sh_addralign
1291 && a
->sh_size
== b
->sh_size
1292 && a
->sh_entsize
== b
->sh_entsize
1293 /* FIXME: Check sh_addr ? */
1297 /* Find a section in OBFD that has the same characteristics
1298 as IHEADER. Return the index of this section or SHN_UNDEF if
1299 none can be found. Check's section HINT first, as this is likely
1300 to be the correct section. */
1303 find_link (const bfd
*obfd
, const Elf_Internal_Shdr
*iheader
,
1304 const unsigned int hint
)
1306 Elf_Internal_Shdr
** oheaders
= elf_elfsections (obfd
);
1309 BFD_ASSERT (iheader
!= NULL
);
1311 /* See PR 20922 for a reproducer of the NULL test. */
1312 if (hint
< elf_numsections (obfd
)
1313 && oheaders
[hint
] != NULL
1314 && section_match (oheaders
[hint
], iheader
))
1317 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1319 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1321 if (oheader
== NULL
)
1323 if (section_match (oheader
, iheader
))
1324 /* FIXME: Do we care if there is a potential for
1325 multiple matches ? */
1332 /* PR 19938: Attempt to set the ELF section header fields of an OS or
1333 Processor specific section, based upon a matching input section.
1334 Returns TRUE upon success, FALSE otherwise. */
1337 copy_special_section_fields (const bfd
*ibfd
,
1339 const Elf_Internal_Shdr
*iheader
,
1340 Elf_Internal_Shdr
*oheader
,
1341 const unsigned int secnum
)
1343 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
1344 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1345 bfd_boolean changed
= FALSE
;
1346 unsigned int sh_link
;
1348 if (oheader
->sh_type
== SHT_NOBITS
)
1350 /* This is a feature for objcopy --only-keep-debug:
1351 When a section's type is changed to NOBITS, we preserve
1352 the sh_link and sh_info fields so that they can be
1353 matched up with the original.
1355 Note: Strictly speaking these assignments are wrong.
1356 The sh_link and sh_info fields should point to the
1357 relevent sections in the output BFD, which may not be in
1358 the same location as they were in the input BFD. But
1359 the whole point of this action is to preserve the
1360 original values of the sh_link and sh_info fields, so
1361 that they can be matched up with the section headers in
1362 the original file. So strictly speaking we may be
1363 creating an invalid ELF file, but it is only for a file
1364 that just contains debug info and only for sections
1365 without any contents. */
1366 if (oheader
->sh_link
== 0)
1367 oheader
->sh_link
= iheader
->sh_link
;
1368 if (oheader
->sh_info
== 0)
1369 oheader
->sh_info
= iheader
->sh_info
;
1373 /* Allow the target a chance to decide how these fields should be set. */
1374 if (bed
->elf_backend_copy_special_section_fields
!= NULL
1375 && bed
->elf_backend_copy_special_section_fields
1376 (ibfd
, obfd
, iheader
, oheader
))
1379 /* We have an iheader which might match oheader, and which has non-zero
1380 sh_info and/or sh_link fields. Attempt to follow those links and find
1381 the section in the output bfd which corresponds to the linked section
1382 in the input bfd. */
1383 if (iheader
->sh_link
!= SHN_UNDEF
)
1385 /* See PR 20931 for a reproducer. */
1386 if (iheader
->sh_link
>= elf_numsections (ibfd
))
1389 /* xgettext:c-format */
1390 (_("%B: Invalid sh_link field (%d) in section number %d"),
1391 ibfd
, iheader
->sh_link
, secnum
);
1395 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_link
], iheader
->sh_link
);
1396 if (sh_link
!= SHN_UNDEF
)
1398 oheader
->sh_link
= sh_link
;
1402 /* FIXME: Should we install iheader->sh_link
1403 if we could not find a match ? */
1405 /* xgettext:c-format */
1406 (_("%B: Failed to find link section for section %d"), obfd
, secnum
);
1409 if (iheader
->sh_info
)
1411 /* The sh_info field can hold arbitrary information, but if the
1412 SHF_LINK_INFO flag is set then it should be interpreted as a
1414 if (iheader
->sh_flags
& SHF_INFO_LINK
)
1416 sh_link
= find_link (obfd
, iheaders
[iheader
->sh_info
],
1418 if (sh_link
!= SHN_UNDEF
)
1419 oheader
->sh_flags
|= SHF_INFO_LINK
;
1422 /* No idea what it means - just copy it. */
1423 sh_link
= iheader
->sh_info
;
1425 if (sh_link
!= SHN_UNDEF
)
1427 oheader
->sh_info
= sh_link
;
1432 /* xgettext:c-format */
1433 (_("%B: Failed to find info section for section %d"), obfd
, secnum
);
1439 /* Copy the program header and other data from one object module to
1443 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1445 const Elf_Internal_Shdr
**iheaders
= (const Elf_Internal_Shdr
**) elf_elfsections (ibfd
);
1446 Elf_Internal_Shdr
**oheaders
= elf_elfsections (obfd
);
1447 const struct elf_backend_data
*bed
;
1450 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1451 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1454 if (!elf_flags_init (obfd
))
1456 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1457 elf_flags_init (obfd
) = TRUE
;
1460 elf_gp (obfd
) = elf_gp (ibfd
);
1462 /* Also copy the EI_OSABI field. */
1463 elf_elfheader (obfd
)->e_ident
[EI_OSABI
] =
1464 elf_elfheader (ibfd
)->e_ident
[EI_OSABI
];
1466 /* If set, copy the EI_ABIVERSION field. */
1467 if (elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
])
1468 elf_elfheader (obfd
)->e_ident
[EI_ABIVERSION
]
1469 = elf_elfheader (ibfd
)->e_ident
[EI_ABIVERSION
];
1471 /* Copy object attributes. */
1472 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1474 if (iheaders
== NULL
|| oheaders
== NULL
)
1477 bed
= get_elf_backend_data (obfd
);
1479 /* Possibly copy other fields in the section header. */
1480 for (i
= 1; i
< elf_numsections (obfd
); i
++)
1483 Elf_Internal_Shdr
* oheader
= oheaders
[i
];
1485 /* Ignore ordinary sections. SHT_NOBITS sections are considered however
1486 because of a special case need for generating separate debug info
1487 files. See below for more details. */
1489 || (oheader
->sh_type
!= SHT_NOBITS
1490 && oheader
->sh_type
< SHT_LOOS
))
1493 /* Ignore empty sections, and sections whose
1494 fields have already been initialised. */
1495 if (oheader
->sh_size
== 0
1496 || (oheader
->sh_info
!= 0 && oheader
->sh_link
!= 0))
1499 /* Scan for the matching section in the input bfd.
1500 First we try for a direct mapping between the input and output sections. */
1501 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1503 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1505 if (iheader
== NULL
)
1508 if (oheader
->bfd_section
!= NULL
1509 && iheader
->bfd_section
!= NULL
1510 && iheader
->bfd_section
->output_section
!= NULL
1511 && iheader
->bfd_section
->output_section
== oheader
->bfd_section
)
1513 /* We have found a connection from the input section to the
1514 output section. Attempt to copy the header fields. If
1515 this fails then do not try any further sections - there
1516 should only be a one-to-one mapping between input and output. */
1517 if (! copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1518 j
= elf_numsections (ibfd
);
1523 if (j
< elf_numsections (ibfd
))
1526 /* That failed. So try to deduce the corresponding input section.
1527 Unfortunately we cannot compare names as the output string table
1528 is empty, so instead we check size, address and type. */
1529 for (j
= 1; j
< elf_numsections (ibfd
); j
++)
1531 const Elf_Internal_Shdr
* iheader
= iheaders
[j
];
1533 if (iheader
== NULL
)
1536 /* Try matching fields in the input section's header.
1537 Since --only-keep-debug turns all non-debug sections into
1538 SHT_NOBITS sections, the output SHT_NOBITS type matches any
1540 if ((oheader
->sh_type
== SHT_NOBITS
1541 || iheader
->sh_type
== oheader
->sh_type
)
1542 && (iheader
->sh_flags
& ~ SHF_INFO_LINK
)
1543 == (oheader
->sh_flags
& ~ SHF_INFO_LINK
)
1544 && iheader
->sh_addralign
== oheader
->sh_addralign
1545 && iheader
->sh_entsize
== oheader
->sh_entsize
1546 && iheader
->sh_size
== oheader
->sh_size
1547 && iheader
->sh_addr
== oheader
->sh_addr
1548 && (iheader
->sh_info
!= oheader
->sh_info
1549 || iheader
->sh_link
!= oheader
->sh_link
))
1551 if (copy_special_section_fields (ibfd
, obfd
, iheader
, oheader
, i
))
1556 if (j
== elf_numsections (ibfd
) && oheader
->sh_type
>= SHT_LOOS
)
1558 /* Final attempt. Call the backend copy function
1559 with a NULL input section. */
1560 if (bed
->elf_backend_copy_special_section_fields
!= NULL
)
1561 bed
->elf_backend_copy_special_section_fields (ibfd
, obfd
, NULL
, oheader
);
1569 get_segment_type (unsigned int p_type
)
1574 case PT_NULL
: pt
= "NULL"; break;
1575 case PT_LOAD
: pt
= "LOAD"; break;
1576 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1577 case PT_INTERP
: pt
= "INTERP"; break;
1578 case PT_NOTE
: pt
= "NOTE"; break;
1579 case PT_SHLIB
: pt
= "SHLIB"; break;
1580 case PT_PHDR
: pt
= "PHDR"; break;
1581 case PT_TLS
: pt
= "TLS"; break;
1582 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1583 case PT_GNU_STACK
: pt
= "STACK"; break;
1584 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1585 default: pt
= NULL
; break;
1590 /* Print out the program headers. */
1593 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1595 FILE *f
= (FILE *) farg
;
1596 Elf_Internal_Phdr
*p
;
1598 bfd_byte
*dynbuf
= NULL
;
1600 p
= elf_tdata (abfd
)->phdr
;
1605 fprintf (f
, _("\nProgram Header:\n"));
1606 c
= elf_elfheader (abfd
)->e_phnum
;
1607 for (i
= 0; i
< c
; i
++, p
++)
1609 const char *pt
= get_segment_type (p
->p_type
);
1614 sprintf (buf
, "0x%lx", p
->p_type
);
1617 fprintf (f
, "%8s off 0x", pt
);
1618 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1619 fprintf (f
, " vaddr 0x");
1620 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1621 fprintf (f
, " paddr 0x");
1622 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1623 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1624 fprintf (f
, " filesz 0x");
1625 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1626 fprintf (f
, " memsz 0x");
1627 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1628 fprintf (f
, " flags %c%c%c",
1629 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1630 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1631 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1632 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1633 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1638 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1641 unsigned int elfsec
;
1642 unsigned long shlink
;
1643 bfd_byte
*extdyn
, *extdynend
;
1645 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1647 fprintf (f
, _("\nDynamic Section:\n"));
1649 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1652 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1653 if (elfsec
== SHN_BAD
)
1655 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1657 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1658 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1661 /* PR 17512: file: 6f427532. */
1662 if (s
->size
< extdynsize
)
1664 extdynend
= extdyn
+ s
->size
;
1665 /* PR 17512: file: id:000006,sig:06,src:000000,op:flip4,pos:5664.
1667 for (; extdyn
<= (extdynend
- extdynsize
); extdyn
+= extdynsize
)
1669 Elf_Internal_Dyn dyn
;
1670 const char *name
= "";
1672 bfd_boolean stringp
;
1673 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1675 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1677 if (dyn
.d_tag
== DT_NULL
)
1684 if (bed
->elf_backend_get_target_dtag
)
1685 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1687 if (!strcmp (name
, ""))
1689 sprintf (ab
, "%#" BFD_VMA_FMT
"x", dyn
.d_tag
);
1694 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1695 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1696 case DT_PLTGOT
: name
= "PLTGOT"; break;
1697 case DT_HASH
: name
= "HASH"; break;
1698 case DT_STRTAB
: name
= "STRTAB"; break;
1699 case DT_SYMTAB
: name
= "SYMTAB"; break;
1700 case DT_RELA
: name
= "RELA"; break;
1701 case DT_RELASZ
: name
= "RELASZ"; break;
1702 case DT_RELAENT
: name
= "RELAENT"; break;
1703 case DT_STRSZ
: name
= "STRSZ"; break;
1704 case DT_SYMENT
: name
= "SYMENT"; break;
1705 case DT_INIT
: name
= "INIT"; break;
1706 case DT_FINI
: name
= "FINI"; break;
1707 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1708 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1709 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1710 case DT_REL
: name
= "REL"; break;
1711 case DT_RELSZ
: name
= "RELSZ"; break;
1712 case DT_RELENT
: name
= "RELENT"; break;
1713 case DT_PLTREL
: name
= "PLTREL"; break;
1714 case DT_DEBUG
: name
= "DEBUG"; break;
1715 case DT_TEXTREL
: name
= "TEXTREL"; break;
1716 case DT_JMPREL
: name
= "JMPREL"; break;
1717 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1718 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1719 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1720 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1721 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1722 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1723 case DT_FLAGS
: name
= "FLAGS"; break;
1724 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1725 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1726 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1727 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1728 case DT_MOVEENT
: name
= "MOVEENT"; break;
1729 case DT_MOVESZ
: name
= "MOVESZ"; break;
1730 case DT_FEATURE
: name
= "FEATURE"; break;
1731 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1732 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1733 case DT_SYMINENT
: name
= "SYMINENT"; break;
1734 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1735 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1736 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1737 case DT_PLTPAD
: name
= "PLTPAD"; break;
1738 case DT_MOVETAB
: name
= "MOVETAB"; break;
1739 case DT_SYMINFO
: name
= "SYMINFO"; break;
1740 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1741 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1742 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1743 case DT_VERSYM
: name
= "VERSYM"; break;
1744 case DT_VERDEF
: name
= "VERDEF"; break;
1745 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1746 case DT_VERNEED
: name
= "VERNEED"; break;
1747 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1748 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1749 case DT_USED
: name
= "USED"; break;
1750 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1751 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1754 fprintf (f
, " %-20s ", name
);
1758 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1763 unsigned int tagv
= dyn
.d_un
.d_val
;
1765 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1768 fprintf (f
, "%s", string
);
1777 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1778 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1780 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1784 if (elf_dynverdef (abfd
) != 0)
1786 Elf_Internal_Verdef
*t
;
1788 fprintf (f
, _("\nVersion definitions:\n"));
1789 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1791 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1792 t
->vd_flags
, t
->vd_hash
,
1793 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1794 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1796 Elf_Internal_Verdaux
*a
;
1799 for (a
= t
->vd_auxptr
->vda_nextptr
;
1803 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1809 if (elf_dynverref (abfd
) != 0)
1811 Elf_Internal_Verneed
*t
;
1813 fprintf (f
, _("\nVersion References:\n"));
1814 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1816 Elf_Internal_Vernaux
*a
;
1818 fprintf (f
, _(" required from %s:\n"),
1819 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1820 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1821 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1822 a
->vna_flags
, a
->vna_other
,
1823 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1835 /* Get version string. */
1838 _bfd_elf_get_symbol_version_string (bfd
*abfd
, asymbol
*symbol
,
1839 bfd_boolean
*hidden
)
1841 const char *version_string
= NULL
;
1842 if (elf_dynversym (abfd
) != 0
1843 && (elf_dynverdef (abfd
) != 0 || elf_dynverref (abfd
) != 0))
1845 unsigned int vernum
= ((elf_symbol_type
*) symbol
)->version
;
1847 *hidden
= (vernum
& VERSYM_HIDDEN
) != 0;
1848 vernum
&= VERSYM_VERSION
;
1851 version_string
= "";
1852 else if (vernum
== 1)
1853 version_string
= "Base";
1854 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1856 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1859 Elf_Internal_Verneed
*t
;
1861 version_string
= "";
1862 for (t
= elf_tdata (abfd
)->verref
;
1866 Elf_Internal_Vernaux
*a
;
1868 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1870 if (a
->vna_other
== vernum
)
1872 version_string
= a
->vna_nodename
;
1879 return version_string
;
1882 /* Display ELF-specific fields of a symbol. */
1885 bfd_elf_print_symbol (bfd
*abfd
,
1888 bfd_print_symbol_type how
)
1890 FILE *file
= (FILE *) filep
;
1893 case bfd_print_symbol_name
:
1894 fprintf (file
, "%s", symbol
->name
);
1896 case bfd_print_symbol_more
:
1897 fprintf (file
, "elf ");
1898 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1899 fprintf (file
, " %x", symbol
->flags
);
1901 case bfd_print_symbol_all
:
1903 const char *section_name
;
1904 const char *name
= NULL
;
1905 const struct elf_backend_data
*bed
;
1906 unsigned char st_other
;
1908 const char *version_string
;
1911 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1913 bed
= get_elf_backend_data (abfd
);
1914 if (bed
->elf_backend_print_symbol_all
)
1915 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1919 name
= symbol
->name
;
1920 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1923 fprintf (file
, " %s\t", section_name
);
1924 /* Print the "other" value for a symbol. For common symbols,
1925 we've already printed the size; now print the alignment.
1926 For other symbols, we have no specified alignment, and
1927 we've printed the address; now print the size. */
1928 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1929 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1931 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1932 bfd_fprintf_vma (abfd
, file
, val
);
1934 /* If we have version information, print it. */
1935 version_string
= _bfd_elf_get_symbol_version_string (abfd
,
1941 fprintf (file
, " %-11s", version_string
);
1946 fprintf (file
, " (%s)", version_string
);
1947 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1952 /* If the st_other field is not zero, print it. */
1953 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1958 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1959 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1960 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1962 /* Some other non-defined flags are also present, so print
1964 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1967 fprintf (file
, " %s", name
);
1973 /* ELF .o/exec file reading */
1975 /* Create a new bfd section from an ELF section header. */
1978 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1980 Elf_Internal_Shdr
*hdr
;
1981 Elf_Internal_Ehdr
*ehdr
;
1982 const struct elf_backend_data
*bed
;
1984 bfd_boolean ret
= TRUE
;
1985 static bfd_boolean
* sections_being_created
= NULL
;
1986 static bfd
* sections_being_created_abfd
= NULL
;
1987 static unsigned int nesting
= 0;
1989 if (shindex
>= elf_numsections (abfd
))
1994 /* PR17512: A corrupt ELF binary might contain a recursive group of
1995 sections, with each the string indicies pointing to the next in the
1996 loop. Detect this here, by refusing to load a section that we are
1997 already in the process of loading. We only trigger this test if
1998 we have nested at least three sections deep as normal ELF binaries
1999 can expect to recurse at least once.
2001 FIXME: It would be better if this array was attached to the bfd,
2002 rather than being held in a static pointer. */
2004 if (sections_being_created_abfd
!= abfd
)
2005 sections_being_created
= NULL
;
2006 if (sections_being_created
== NULL
)
2008 /* FIXME: It would be more efficient to attach this array to the bfd somehow. */
2009 sections_being_created
= (bfd_boolean
*)
2010 bfd_zalloc (abfd
, elf_numsections (abfd
) * sizeof (bfd_boolean
));
2011 sections_being_created_abfd
= abfd
;
2013 if (sections_being_created
[shindex
])
2016 (_("%B: warning: loop in section dependencies detected"), abfd
);
2019 sections_being_created
[shindex
] = TRUE
;
2022 hdr
= elf_elfsections (abfd
)[shindex
];
2023 ehdr
= elf_elfheader (abfd
);
2024 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
2029 bed
= get_elf_backend_data (abfd
);
2030 switch (hdr
->sh_type
)
2033 /* Inactive section. Throw it away. */
2036 case SHT_PROGBITS
: /* Normal section with contents. */
2037 case SHT_NOBITS
: /* .bss section. */
2038 case SHT_HASH
: /* .hash section. */
2039 case SHT_NOTE
: /* .note section. */
2040 case SHT_INIT_ARRAY
: /* .init_array section. */
2041 case SHT_FINI_ARRAY
: /* .fini_array section. */
2042 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
2043 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
2044 case SHT_GNU_HASH
: /* .gnu.hash section. */
2045 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2048 case SHT_DYNAMIC
: /* Dynamic linking information. */
2049 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2052 if (hdr
->sh_link
> elf_numsections (abfd
))
2054 /* PR 10478: Accept Solaris binaries with a sh_link
2055 field set to SHN_BEFORE or SHN_AFTER. */
2056 switch (bfd_get_arch (abfd
))
2059 case bfd_arch_sparc
:
2060 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
2061 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
2063 /* Otherwise fall through. */
2068 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
2070 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
2072 Elf_Internal_Shdr
*dynsymhdr
;
2074 /* The shared libraries distributed with hpux11 have a bogus
2075 sh_link field for the ".dynamic" section. Find the
2076 string table for the ".dynsym" section instead. */
2077 if (elf_dynsymtab (abfd
) != 0)
2079 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
2080 hdr
->sh_link
= dynsymhdr
->sh_link
;
2084 unsigned int i
, num_sec
;
2086 num_sec
= elf_numsections (abfd
);
2087 for (i
= 1; i
< num_sec
; i
++)
2089 dynsymhdr
= elf_elfsections (abfd
)[i
];
2090 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
2092 hdr
->sh_link
= dynsymhdr
->sh_link
;
2100 case SHT_SYMTAB
: /* A symbol table. */
2101 if (elf_onesymtab (abfd
) == shindex
)
2104 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2107 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2109 if (hdr
->sh_size
!= 0)
2111 /* Some assemblers erroneously set sh_info to one with a
2112 zero sh_size. ld sees this as a global symbol count
2113 of (unsigned) -1. Fix it here. */
2118 /* PR 18854: A binary might contain more than one symbol table.
2119 Unusual, but possible. Warn, but continue. */
2120 if (elf_onesymtab (abfd
) != 0)
2123 /* xgettext:c-format */
2124 (_("%B: warning: multiple symbol tables detected"
2125 " - ignoring the table in section %u"),
2129 elf_onesymtab (abfd
) = shindex
;
2130 elf_symtab_hdr (abfd
) = *hdr
;
2131 elf_elfsections (abfd
)[shindex
] = hdr
= & elf_symtab_hdr (abfd
);
2132 abfd
->flags
|= HAS_SYMS
;
2134 /* Sometimes a shared object will map in the symbol table. If
2135 SHF_ALLOC is set, and this is a shared object, then we also
2136 treat this section as a BFD section. We can not base the
2137 decision purely on SHF_ALLOC, because that flag is sometimes
2138 set in a relocatable object file, which would confuse the
2140 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
2141 && (abfd
->flags
& DYNAMIC
) != 0
2142 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2146 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
2147 can't read symbols without that section loaded as well. It
2148 is most likely specified by the next section header. */
2150 elf_section_list
* entry
;
2151 unsigned int i
, num_sec
;
2153 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2154 if (entry
->hdr
.sh_link
== shindex
)
2157 num_sec
= elf_numsections (abfd
);
2158 for (i
= shindex
+ 1; i
< num_sec
; i
++)
2160 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2162 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2163 && hdr2
->sh_link
== shindex
)
2168 for (i
= 1; i
< shindex
; i
++)
2170 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2172 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
2173 && hdr2
->sh_link
== shindex
)
2178 ret
= bfd_section_from_shdr (abfd
, i
);
2179 /* else FIXME: we have failed to find the symbol table - should we issue an error ? */
2183 case SHT_DYNSYM
: /* A dynamic symbol table. */
2184 if (elf_dynsymtab (abfd
) == shindex
)
2187 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
2190 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
2192 if (hdr
->sh_size
!= 0)
2195 /* Some linkers erroneously set sh_info to one with a
2196 zero sh_size. ld sees this as a global symbol count
2197 of (unsigned) -1. Fix it here. */
2202 /* PR 18854: A binary might contain more than one dynamic symbol table.
2203 Unusual, but possible. Warn, but continue. */
2204 if (elf_dynsymtab (abfd
) != 0)
2207 /* xgettext:c-format */
2208 (_("%B: warning: multiple dynamic symbol tables detected"
2209 " - ignoring the table in section %u"),
2213 elf_dynsymtab (abfd
) = shindex
;
2214 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
2215 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2216 abfd
->flags
|= HAS_SYMS
;
2218 /* Besides being a symbol table, we also treat this as a regular
2219 section, so that objcopy can handle it. */
2220 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2223 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections. */
2225 elf_section_list
* entry
;
2227 for (entry
= elf_symtab_shndx_list (abfd
); entry
!= NULL
; entry
= entry
->next
)
2228 if (entry
->ndx
== shindex
)
2231 entry
= bfd_alloc (abfd
, sizeof * entry
);
2234 entry
->ndx
= shindex
;
2236 entry
->next
= elf_symtab_shndx_list (abfd
);
2237 elf_symtab_shndx_list (abfd
) = entry
;
2238 elf_elfsections (abfd
)[shindex
] = & entry
->hdr
;
2242 case SHT_STRTAB
: /* A string table. */
2243 if (hdr
->bfd_section
!= NULL
)
2246 if (ehdr
->e_shstrndx
== shindex
)
2248 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
2249 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
2253 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
2256 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
2257 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2261 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2264 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2265 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2266 elf_elfsections (abfd
)[shindex
] = hdr
;
2267 /* We also treat this as a regular section, so that objcopy
2269 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2274 /* If the string table isn't one of the above, then treat it as a
2275 regular section. We need to scan all the headers to be sure,
2276 just in case this strtab section appeared before the above. */
2277 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2279 unsigned int i
, num_sec
;
2281 num_sec
= elf_numsections (abfd
);
2282 for (i
= 1; i
< num_sec
; i
++)
2284 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2285 if (hdr2
->sh_link
== shindex
)
2287 /* Prevent endless recursion on broken objects. */
2290 if (! bfd_section_from_shdr (abfd
, i
))
2292 if (elf_onesymtab (abfd
) == i
)
2294 if (elf_dynsymtab (abfd
) == i
)
2295 goto dynsymtab_strtab
;
2299 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2304 /* *These* do a lot of work -- but build no sections! */
2306 asection
*target_sect
;
2307 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
2308 unsigned int num_sec
= elf_numsections (abfd
);
2309 struct bfd_elf_section_data
*esdt
;
2312 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2313 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2316 /* Check for a bogus link to avoid crashing. */
2317 if (hdr
->sh_link
>= num_sec
)
2320 /* xgettext:c-format */
2321 (_("%B: invalid link %u for reloc section %s (index %u)"),
2322 abfd
, hdr
->sh_link
, name
, shindex
);
2323 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2328 /* For some incomprehensible reason Oracle distributes
2329 libraries for Solaris in which some of the objects have
2330 bogus sh_link fields. It would be nice if we could just
2331 reject them, but, unfortunately, some people need to use
2332 them. We scan through the section headers; if we find only
2333 one suitable symbol table, we clobber the sh_link to point
2334 to it. I hope this doesn't break anything.
2336 Don't do it on executable nor shared library. */
2337 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
2338 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2339 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2345 for (scan
= 1; scan
< num_sec
; scan
++)
2347 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2348 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2359 hdr
->sh_link
= found
;
2362 /* Get the symbol table. */
2363 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2364 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2365 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2368 /* If this reloc section does not use the main symbol table we
2369 don't treat it as a reloc section. BFD can't adequately
2370 represent such a section, so at least for now, we don't
2371 try. We just present it as a normal section. We also
2372 can't use it as a reloc section if it points to the null
2373 section, an invalid section, another reloc section, or its
2374 sh_link points to the null section. */
2375 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2376 || hdr
->sh_link
== SHN_UNDEF
2377 || hdr
->sh_info
== SHN_UNDEF
2378 || hdr
->sh_info
>= num_sec
2379 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2380 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2382 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2387 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2390 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2391 if (target_sect
== NULL
)
2394 esdt
= elf_section_data (target_sect
);
2395 if (hdr
->sh_type
== SHT_RELA
)
2396 p_hdr
= &esdt
->rela
.hdr
;
2398 p_hdr
= &esdt
->rel
.hdr
;
2400 /* PR 17512: file: 0b4f81b7. */
2403 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
2408 elf_elfsections (abfd
)[shindex
] = hdr2
;
2409 target_sect
->reloc_count
+= (NUM_SHDR_ENTRIES (hdr
)
2410 * bed
->s
->int_rels_per_ext_rel
);
2411 target_sect
->flags
|= SEC_RELOC
;
2412 target_sect
->relocation
= NULL
;
2413 target_sect
->rel_filepos
= hdr
->sh_offset
;
2414 /* In the section to which the relocations apply, mark whether
2415 its relocations are of the REL or RELA variety. */
2416 if (hdr
->sh_size
!= 0)
2418 if (hdr
->sh_type
== SHT_RELA
)
2419 target_sect
->use_rela_p
= 1;
2421 abfd
->flags
|= HAS_RELOC
;
2425 case SHT_GNU_verdef
:
2426 elf_dynverdef (abfd
) = shindex
;
2427 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2428 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2431 case SHT_GNU_versym
:
2432 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2435 elf_dynversym (abfd
) = shindex
;
2436 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2437 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2440 case SHT_GNU_verneed
:
2441 elf_dynverref (abfd
) = shindex
;
2442 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2443 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2450 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
, GRP_ENTRY_SIZE
))
2453 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2459 /* Possibly an attributes section. */
2460 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2461 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2463 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2465 _bfd_elf_parse_attributes (abfd
, hdr
);
2469 /* Check for any processor-specific section types. */
2470 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2473 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2475 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2476 /* FIXME: How to properly handle allocated section reserved
2477 for applications? */
2479 /* xgettext:c-format */
2480 (_("%B: unknown type [%#x] section `%s'"),
2481 abfd
, hdr
->sh_type
, name
);
2484 /* Allow sections reserved for applications. */
2485 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2490 else if (hdr
->sh_type
>= SHT_LOPROC
2491 && hdr
->sh_type
<= SHT_HIPROC
)
2492 /* FIXME: We should handle this section. */
2494 /* xgettext:c-format */
2495 (_("%B: unknown type [%#x] section `%s'"),
2496 abfd
, hdr
->sh_type
, name
);
2497 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2499 /* Unrecognised OS-specific sections. */
2500 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2501 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2502 required to correctly process the section and the file should
2503 be rejected with an error message. */
2505 /* xgettext:c-format */
2506 (_("%B: unknown type [%#x] section `%s'"),
2507 abfd
, hdr
->sh_type
, name
);
2510 /* Otherwise it should be processed. */
2511 ret
= _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2516 /* FIXME: We should handle this section. */
2518 /* xgettext:c-format */
2519 (_("%B: unknown type [%#x] section `%s'"),
2520 abfd
, hdr
->sh_type
, name
);
2528 if (sections_being_created
&& sections_being_created_abfd
== abfd
)
2529 sections_being_created
[shindex
] = FALSE
;
2530 if (-- nesting
== 0)
2532 sections_being_created
= NULL
;
2533 sections_being_created_abfd
= abfd
;
2538 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2541 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
2543 unsigned long r_symndx
)
2545 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2547 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
2549 Elf_Internal_Shdr
*symtab_hdr
;
2550 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2551 Elf_External_Sym_Shndx eshndx
;
2553 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2554 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2555 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
2558 if (cache
->abfd
!= abfd
)
2560 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2563 cache
->indx
[ent
] = r_symndx
;
2566 return &cache
->sym
[ent
];
2569 /* Given an ELF section number, retrieve the corresponding BFD
2573 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
2575 if (sec_index
>= elf_numsections (abfd
))
2577 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
2580 static const struct bfd_elf_special_section special_sections_b
[] =
2582 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2583 { NULL
, 0, 0, 0, 0 }
2586 static const struct bfd_elf_special_section special_sections_c
[] =
2588 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2589 { NULL
, 0, 0, 0, 0 }
2592 static const struct bfd_elf_special_section special_sections_d
[] =
2594 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2595 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2596 /* There are more DWARF sections than these, but they needn't be added here
2597 unless you have to cope with broken compilers that don't emit section
2598 attributes or you want to help the user writing assembler. */
2599 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2600 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2601 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2602 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2603 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2604 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2605 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2606 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2607 { NULL
, 0, 0, 0, 0 }
2610 static const struct bfd_elf_special_section special_sections_f
[] =
2612 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2613 { STRING_COMMA_LEN (".fini_array"), -2, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2614 { NULL
, 0 , 0, 0, 0 }
2617 static const struct bfd_elf_special_section special_sections_g
[] =
2619 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2620 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS
, SHF_EXCLUDE
},
2621 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2622 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2623 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2624 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2625 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2626 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2627 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2628 { NULL
, 0, 0, 0, 0 }
2631 static const struct bfd_elf_special_section special_sections_h
[] =
2633 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2634 { NULL
, 0, 0, 0, 0 }
2637 static const struct bfd_elf_special_section special_sections_i
[] =
2639 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2640 { STRING_COMMA_LEN (".init_array"), -2, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2641 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2642 { NULL
, 0, 0, 0, 0 }
2645 static const struct bfd_elf_special_section special_sections_l
[] =
2647 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2648 { NULL
, 0, 0, 0, 0 }
2651 static const struct bfd_elf_special_section special_sections_n
[] =
2653 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2654 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2655 { NULL
, 0, 0, 0, 0 }
2658 static const struct bfd_elf_special_section special_sections_p
[] =
2660 { STRING_COMMA_LEN (".preinit_array"), -2, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2661 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2662 { NULL
, 0, 0, 0, 0 }
2665 static const struct bfd_elf_special_section special_sections_r
[] =
2667 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2668 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2669 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2670 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2671 { NULL
, 0, 0, 0, 0 }
2674 static const struct bfd_elf_special_section special_sections_s
[] =
2676 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2677 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2678 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2679 /* See struct bfd_elf_special_section declaration for the semantics of
2680 this special case where .prefix_length != strlen (.prefix). */
2681 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2682 { NULL
, 0, 0, 0, 0 }
2685 static const struct bfd_elf_special_section special_sections_t
[] =
2687 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2688 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2689 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2690 { NULL
, 0, 0, 0, 0 }
2693 static const struct bfd_elf_special_section special_sections_z
[] =
2695 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2696 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2697 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2698 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2699 { NULL
, 0, 0, 0, 0 }
2702 static const struct bfd_elf_special_section
* const special_sections
[] =
2704 special_sections_b
, /* 'b' */
2705 special_sections_c
, /* 'c' */
2706 special_sections_d
, /* 'd' */
2708 special_sections_f
, /* 'f' */
2709 special_sections_g
, /* 'g' */
2710 special_sections_h
, /* 'h' */
2711 special_sections_i
, /* 'i' */
2714 special_sections_l
, /* 'l' */
2716 special_sections_n
, /* 'n' */
2718 special_sections_p
, /* 'p' */
2720 special_sections_r
, /* 'r' */
2721 special_sections_s
, /* 's' */
2722 special_sections_t
, /* 't' */
2728 special_sections_z
/* 'z' */
2731 const struct bfd_elf_special_section
*
2732 _bfd_elf_get_special_section (const char *name
,
2733 const struct bfd_elf_special_section
*spec
,
2739 len
= strlen (name
);
2741 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2744 int prefix_len
= spec
[i
].prefix_length
;
2746 if (len
< prefix_len
)
2748 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2751 suffix_len
= spec
[i
].suffix_length
;
2752 if (suffix_len
<= 0)
2754 if (name
[prefix_len
] != 0)
2756 if (suffix_len
== 0)
2758 if (name
[prefix_len
] != '.'
2759 && (suffix_len
== -2
2760 || (rela
&& spec
[i
].type
== SHT_REL
)))
2766 if (len
< prefix_len
+ suffix_len
)
2768 if (memcmp (name
+ len
- suffix_len
,
2769 spec
[i
].prefix
+ prefix_len
,
2779 const struct bfd_elf_special_section
*
2780 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2783 const struct bfd_elf_special_section
*spec
;
2784 const struct elf_backend_data
*bed
;
2786 /* See if this is one of the special sections. */
2787 if (sec
->name
== NULL
)
2790 bed
= get_elf_backend_data (abfd
);
2791 spec
= bed
->special_sections
;
2794 spec
= _bfd_elf_get_special_section (sec
->name
,
2795 bed
->special_sections
,
2801 if (sec
->name
[0] != '.')
2804 i
= sec
->name
[1] - 'b';
2805 if (i
< 0 || i
> 'z' - 'b')
2808 spec
= special_sections
[i
];
2813 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2817 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2819 struct bfd_elf_section_data
*sdata
;
2820 const struct elf_backend_data
*bed
;
2821 const struct bfd_elf_special_section
*ssect
;
2823 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2826 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2830 sec
->used_by_bfd
= sdata
;
2833 /* Indicate whether or not this section should use RELA relocations. */
2834 bed
= get_elf_backend_data (abfd
);
2835 sec
->use_rela_p
= bed
->default_use_rela_p
;
2837 /* When we read a file, we don't need to set ELF section type and
2838 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2839 anyway. We will set ELF section type and flags for all linker
2840 created sections. If user specifies BFD section flags, we will
2841 set ELF section type and flags based on BFD section flags in
2842 elf_fake_sections. Special handling for .init_array/.fini_array
2843 output sections since they may contain .ctors/.dtors input
2844 sections. We don't want _bfd_elf_init_private_section_data to
2845 copy ELF section type from .ctors/.dtors input sections. */
2846 if (abfd
->direction
!= read_direction
2847 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2849 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2852 || (sec
->flags
& SEC_LINKER_CREATED
) != 0
2853 || ssect
->type
== SHT_INIT_ARRAY
2854 || ssect
->type
== SHT_FINI_ARRAY
))
2856 elf_section_type (sec
) = ssect
->type
;
2857 elf_section_flags (sec
) = ssect
->attr
;
2861 return _bfd_generic_new_section_hook (abfd
, sec
);
2864 /* Create a new bfd section from an ELF program header.
2866 Since program segments have no names, we generate a synthetic name
2867 of the form segment<NUM>, where NUM is generally the index in the
2868 program header table. For segments that are split (see below) we
2869 generate the names segment<NUM>a and segment<NUM>b.
2871 Note that some program segments may have a file size that is different than
2872 (less than) the memory size. All this means is that at execution the
2873 system must allocate the amount of memory specified by the memory size,
2874 but only initialize it with the first "file size" bytes read from the
2875 file. This would occur for example, with program segments consisting
2876 of combined data+bss.
2878 To handle the above situation, this routine generates TWO bfd sections
2879 for the single program segment. The first has the length specified by
2880 the file size of the segment, and the second has the length specified
2881 by the difference between the two sizes. In effect, the segment is split
2882 into its initialized and uninitialized parts.
2887 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2888 Elf_Internal_Phdr
*hdr
,
2890 const char *type_name
)
2898 split
= ((hdr
->p_memsz
> 0)
2899 && (hdr
->p_filesz
> 0)
2900 && (hdr
->p_memsz
> hdr
->p_filesz
));
2902 if (hdr
->p_filesz
> 0)
2904 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2905 len
= strlen (namebuf
) + 1;
2906 name
= (char *) bfd_alloc (abfd
, len
);
2909 memcpy (name
, namebuf
, len
);
2910 newsect
= bfd_make_section (abfd
, name
);
2911 if (newsect
== NULL
)
2913 newsect
->vma
= hdr
->p_vaddr
;
2914 newsect
->lma
= hdr
->p_paddr
;
2915 newsect
->size
= hdr
->p_filesz
;
2916 newsect
->filepos
= hdr
->p_offset
;
2917 newsect
->flags
|= SEC_HAS_CONTENTS
;
2918 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2919 if (hdr
->p_type
== PT_LOAD
)
2921 newsect
->flags
|= SEC_ALLOC
;
2922 newsect
->flags
|= SEC_LOAD
;
2923 if (hdr
->p_flags
& PF_X
)
2925 /* FIXME: all we known is that it has execute PERMISSION,
2927 newsect
->flags
|= SEC_CODE
;
2930 if (!(hdr
->p_flags
& PF_W
))
2932 newsect
->flags
|= SEC_READONLY
;
2936 if (hdr
->p_memsz
> hdr
->p_filesz
)
2940 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2941 len
= strlen (namebuf
) + 1;
2942 name
= (char *) bfd_alloc (abfd
, len
);
2945 memcpy (name
, namebuf
, len
);
2946 newsect
= bfd_make_section (abfd
, name
);
2947 if (newsect
== NULL
)
2949 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2950 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2951 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2952 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2953 align
= newsect
->vma
& -newsect
->vma
;
2954 if (align
== 0 || align
> hdr
->p_align
)
2955 align
= hdr
->p_align
;
2956 newsect
->alignment_power
= bfd_log2 (align
);
2957 if (hdr
->p_type
== PT_LOAD
)
2959 /* Hack for gdb. Segments that have not been modified do
2960 not have their contents written to a core file, on the
2961 assumption that a debugger can find the contents in the
2962 executable. We flag this case by setting the fake
2963 section size to zero. Note that "real" bss sections will
2964 always have their contents dumped to the core file. */
2965 if (bfd_get_format (abfd
) == bfd_core
)
2967 newsect
->flags
|= SEC_ALLOC
;
2968 if (hdr
->p_flags
& PF_X
)
2969 newsect
->flags
|= SEC_CODE
;
2971 if (!(hdr
->p_flags
& PF_W
))
2972 newsect
->flags
|= SEC_READONLY
;
2979 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2981 const struct elf_backend_data
*bed
;
2983 switch (hdr
->p_type
)
2986 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2989 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2992 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2995 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2998 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
3000 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
,
3006 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
3009 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
3011 case PT_GNU_EH_FRAME
:
3012 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
3016 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
3019 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
3022 /* Check for any processor-specific program segment types. */
3023 bed
= get_elf_backend_data (abfd
);
3024 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
3028 /* Return the REL_HDR for SEC, assuming there is only a single one, either
3032 _bfd_elf_single_rel_hdr (asection
*sec
)
3034 if (elf_section_data (sec
)->rel
.hdr
)
3036 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
3037 return elf_section_data (sec
)->rel
.hdr
;
3040 return elf_section_data (sec
)->rela
.hdr
;
3044 _bfd_elf_set_reloc_sh_name (bfd
*abfd
,
3045 Elf_Internal_Shdr
*rel_hdr
,
3046 const char *sec_name
,
3047 bfd_boolean use_rela_p
)
3049 char *name
= (char *) bfd_alloc (abfd
,
3050 sizeof ".rela" + strlen (sec_name
));
3054 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", sec_name
);
3056 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
3058 if (rel_hdr
->sh_name
== (unsigned int) -1)
3064 /* Allocate and initialize a section-header for a new reloc section,
3065 containing relocations against ASECT. It is stored in RELDATA. If
3066 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
3070 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
3071 struct bfd_elf_section_reloc_data
*reldata
,
3072 const char *sec_name
,
3073 bfd_boolean use_rela_p
,
3074 bfd_boolean delay_st_name_p
)
3076 Elf_Internal_Shdr
*rel_hdr
;
3077 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3079 BFD_ASSERT (reldata
->hdr
== NULL
);
3080 rel_hdr
= bfd_zalloc (abfd
, sizeof (*rel_hdr
));
3081 reldata
->hdr
= rel_hdr
;
3083 if (delay_st_name_p
)
3084 rel_hdr
->sh_name
= (unsigned int) -1;
3085 else if (!_bfd_elf_set_reloc_sh_name (abfd
, rel_hdr
, sec_name
,
3088 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
3089 rel_hdr
->sh_entsize
= (use_rela_p
3090 ? bed
->s
->sizeof_rela
3091 : bed
->s
->sizeof_rel
);
3092 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
3093 rel_hdr
->sh_flags
= 0;
3094 rel_hdr
->sh_addr
= 0;
3095 rel_hdr
->sh_size
= 0;
3096 rel_hdr
->sh_offset
= 0;
3101 /* Return the default section type based on the passed in section flags. */
3104 bfd_elf_get_default_section_type (flagword flags
)
3106 if ((flags
& SEC_ALLOC
) != 0
3107 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3109 return SHT_PROGBITS
;
3112 struct fake_section_arg
3114 struct bfd_link_info
*link_info
;
3118 /* Set up an ELF internal section header for a section. */
3121 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
3123 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
3124 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3125 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
3126 Elf_Internal_Shdr
*this_hdr
;
3127 unsigned int sh_type
;
3128 const char *name
= asect
->name
;
3129 bfd_boolean delay_st_name_p
= FALSE
;
3133 /* We already failed; just get out of the bfd_map_over_sections
3138 this_hdr
= &esd
->this_hdr
;
3142 /* ld: compress DWARF debug sections with names: .debug_*. */
3143 if ((arg
->link_info
->compress_debug
& COMPRESS_DEBUG
)
3144 && (asect
->flags
& SEC_DEBUGGING
)
3148 /* Set SEC_ELF_COMPRESS to indicate this section should be
3150 asect
->flags
|= SEC_ELF_COMPRESS
;
3152 /* If this section will be compressed, delay adding section
3153 name to section name section after it is compressed in
3154 _bfd_elf_assign_file_positions_for_non_load. */
3155 delay_st_name_p
= TRUE
;
3158 else if ((asect
->flags
& SEC_ELF_RENAME
))
3160 /* objcopy: rename output DWARF debug section. */
3161 if ((abfd
->flags
& (BFD_DECOMPRESS
| BFD_COMPRESS_GABI
)))
3163 /* When we decompress or compress with SHF_COMPRESSED,
3164 convert section name from .zdebug_* to .debug_* if
3168 char *new_name
= convert_zdebug_to_debug (abfd
, name
);
3169 if (new_name
== NULL
)
3177 else if (asect
->compress_status
== COMPRESS_SECTION_DONE
)
3179 /* PR binutils/18087: Compression does not always make a
3180 section smaller. So only rename the section when
3181 compression has actually taken place. If input section
3182 name is .zdebug_*, we should never compress it again. */
3183 char *new_name
= convert_debug_to_zdebug (abfd
, name
);
3184 if (new_name
== NULL
)
3189 BFD_ASSERT (name
[1] != 'z');
3194 if (delay_st_name_p
)
3195 this_hdr
->sh_name
= (unsigned int) -1;
3199 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3201 if (this_hdr
->sh_name
== (unsigned int) -1)
3208 /* Don't clear sh_flags. Assembler may set additional bits. */
3210 if ((asect
->flags
& SEC_ALLOC
) != 0
3211 || asect
->user_set_vma
)
3212 this_hdr
->sh_addr
= asect
->vma
;
3214 this_hdr
->sh_addr
= 0;
3216 this_hdr
->sh_offset
= 0;
3217 this_hdr
->sh_size
= asect
->size
;
3218 this_hdr
->sh_link
= 0;
3219 /* PR 17512: file: 0eb809fe, 8b0535ee. */
3220 if (asect
->alignment_power
>= (sizeof (bfd_vma
) * 8) - 1)
3223 /* xgettext:c-format */
3224 (_("%B: error: Alignment power %d of section `%A' is too big"),
3225 abfd
, asect
->alignment_power
, asect
);
3229 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
3230 /* The sh_entsize and sh_info fields may have been set already by
3231 copy_private_section_data. */
3233 this_hdr
->bfd_section
= asect
;
3234 this_hdr
->contents
= NULL
;
3236 /* If the section type is unspecified, we set it based on
3238 if ((asect
->flags
& SEC_GROUP
) != 0)
3239 sh_type
= SHT_GROUP
;
3241 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
3243 if (this_hdr
->sh_type
== SHT_NULL
)
3244 this_hdr
->sh_type
= sh_type
;
3245 else if (this_hdr
->sh_type
== SHT_NOBITS
3246 && sh_type
== SHT_PROGBITS
3247 && (asect
->flags
& SEC_ALLOC
) != 0)
3249 /* Warn if we are changing a NOBITS section to PROGBITS, but
3250 allow the link to proceed. This can happen when users link
3251 non-bss input sections to bss output sections, or emit data
3252 to a bss output section via a linker script. */
3254 (_("warning: section `%A' type changed to PROGBITS"), asect
);
3255 this_hdr
->sh_type
= sh_type
;
3258 switch (this_hdr
->sh_type
)
3269 case SHT_INIT_ARRAY
:
3270 case SHT_FINI_ARRAY
:
3271 case SHT_PREINIT_ARRAY
:
3272 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
3276 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
3280 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3284 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
3288 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
3289 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
3293 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
3294 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
3297 case SHT_GNU_versym
:
3298 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
3301 case SHT_GNU_verdef
:
3302 this_hdr
->sh_entsize
= 0;
3303 /* objcopy or strip will copy over sh_info, but may not set
3304 cverdefs. The linker will set cverdefs, but sh_info will be
3306 if (this_hdr
->sh_info
== 0)
3307 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
3309 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
3310 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
3313 case SHT_GNU_verneed
:
3314 this_hdr
->sh_entsize
= 0;
3315 /* objcopy or strip will copy over sh_info, but may not set
3316 cverrefs. The linker will set cverrefs, but sh_info will be
3318 if (this_hdr
->sh_info
== 0)
3319 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
3321 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
3322 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
3326 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
3330 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
3334 if ((asect
->flags
& SEC_ALLOC
) != 0)
3335 this_hdr
->sh_flags
|= SHF_ALLOC
;
3336 if ((asect
->flags
& SEC_READONLY
) == 0)
3337 this_hdr
->sh_flags
|= SHF_WRITE
;
3338 if ((asect
->flags
& SEC_CODE
) != 0)
3339 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
3340 if ((asect
->flags
& SEC_MERGE
) != 0)
3342 this_hdr
->sh_flags
|= SHF_MERGE
;
3343 this_hdr
->sh_entsize
= asect
->entsize
;
3345 if ((asect
->flags
& SEC_STRINGS
) != 0)
3346 this_hdr
->sh_flags
|= SHF_STRINGS
;
3347 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
3348 this_hdr
->sh_flags
|= SHF_GROUP
;
3349 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
3351 this_hdr
->sh_flags
|= SHF_TLS
;
3352 if (asect
->size
== 0
3353 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
3355 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
3357 this_hdr
->sh_size
= 0;
3360 this_hdr
->sh_size
= o
->offset
+ o
->size
;
3361 if (this_hdr
->sh_size
!= 0)
3362 this_hdr
->sh_type
= SHT_NOBITS
;
3366 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
3367 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
3369 /* If the section has relocs, set up a section header for the
3370 SHT_REL[A] section. If two relocation sections are required for
3371 this section, it is up to the processor-specific back-end to
3372 create the other. */
3373 if ((asect
->flags
& SEC_RELOC
) != 0)
3375 /* When doing a relocatable link, create both REL and RELA sections if
3378 /* Do the normal setup if we wouldn't create any sections here. */
3379 && esd
->rel
.count
+ esd
->rela
.count
> 0
3380 && (bfd_link_relocatable (arg
->link_info
)
3381 || arg
->link_info
->emitrelocations
))
3383 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
3384 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, name
,
3385 FALSE
, delay_st_name_p
))
3390 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
3391 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, name
,
3392 TRUE
, delay_st_name_p
))
3398 else if (!_bfd_elf_init_reloc_shdr (abfd
,
3400 ? &esd
->rela
: &esd
->rel
),
3410 /* Check for processor-specific section types. */
3411 sh_type
= this_hdr
->sh_type
;
3412 if (bed
->elf_backend_fake_sections
3413 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
3419 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
3421 /* Don't change the header type from NOBITS if we are being
3422 called for objcopy --only-keep-debug. */
3423 this_hdr
->sh_type
= sh_type
;
3427 /* Fill in the contents of a SHT_GROUP section. Called from
3428 _bfd_elf_compute_section_file_positions for gas, objcopy, and
3429 when ELF targets use the generic linker, ld. Called for ld -r
3430 from bfd_elf_final_link. */
3433 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
3435 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
3436 asection
*elt
, *first
;
3440 /* Ignore linker created group section. See elfNN_ia64_object_p in
3442 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
3446 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
3448 unsigned long symindx
= 0;
3450 /* elf_group_id will have been set up by objcopy and the
3452 if (elf_group_id (sec
) != NULL
)
3453 symindx
= elf_group_id (sec
)->udata
.i
;
3457 /* If called from the assembler, swap_out_syms will have set up
3458 elf_section_syms. */
3459 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
3460 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
3462 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
3464 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
3466 /* The ELF backend linker sets sh_info to -2 when the group
3467 signature symbol is global, and thus the index can't be
3468 set until all local symbols are output. */
3470 struct bfd_elf_section_data
*sec_data
;
3471 unsigned long symndx
;
3472 unsigned long extsymoff
;
3473 struct elf_link_hash_entry
*h
;
3475 /* The point of this little dance to the first SHF_GROUP section
3476 then back to the SHT_GROUP section is that this gets us to
3477 the SHT_GROUP in the input object. */
3478 igroup
= elf_sec_group (elf_next_in_group (sec
));
3479 sec_data
= elf_section_data (igroup
);
3480 symndx
= sec_data
->this_hdr
.sh_info
;
3482 if (!elf_bad_symtab (igroup
->owner
))
3484 Elf_Internal_Shdr
*symtab_hdr
;
3486 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
3487 extsymoff
= symtab_hdr
->sh_info
;
3489 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
3490 while (h
->root
.type
== bfd_link_hash_indirect
3491 || h
->root
.type
== bfd_link_hash_warning
)
3492 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3494 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
3497 /* The contents won't be allocated for "ld -r" or objcopy. */
3499 if (sec
->contents
== NULL
)
3502 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
3504 /* Arrange for the section to be written out. */
3505 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
3506 if (sec
->contents
== NULL
)
3513 loc
= sec
->contents
+ sec
->size
;
3515 /* Get the pointer to the first section in the group that gas
3516 squirreled away here. objcopy arranges for this to be set to the
3517 start of the input section group. */
3518 first
= elt
= elf_next_in_group (sec
);
3520 /* First element is a flag word. Rest of section is elf section
3521 indices for all the sections of the group. Write them backwards
3522 just to keep the group in the same order as given in .section
3523 directives, not that it matters. */
3530 s
= s
->output_section
;
3532 && !bfd_is_abs_section (s
))
3534 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
3535 struct bfd_elf_section_data
*input_elf_sec
= elf_section_data (elt
);
3537 if (elf_sec
->rel
.hdr
!= NULL
3539 || (input_elf_sec
->rel
.hdr
!= NULL
3540 && input_elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3542 elf_sec
->rel
.hdr
->sh_flags
|= SHF_GROUP
;
3544 H_PUT_32 (abfd
, elf_sec
->rel
.idx
, loc
);
3546 if (elf_sec
->rela
.hdr
!= NULL
3548 || (input_elf_sec
->rela
.hdr
!= NULL
3549 && input_elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0))
3551 elf_sec
->rela
.hdr
->sh_flags
|= SHF_GROUP
;
3553 H_PUT_32 (abfd
, elf_sec
->rela
.idx
, loc
);
3556 H_PUT_32 (abfd
, elf_sec
->this_idx
, loc
);
3558 elt
= elf_next_in_group (elt
);
3564 BFD_ASSERT (loc
== sec
->contents
);
3566 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3569 /* Given NAME, the name of a relocation section stripped of its
3570 .rel/.rela prefix, return the section in ABFD to which the
3571 relocations apply. */
3574 _bfd_elf_plt_get_reloc_section (bfd
*abfd
, const char *name
)
3576 /* If a target needs .got.plt section, relocations in rela.plt/rel.plt
3577 section likely apply to .got.plt or .got section. */
3578 if (get_elf_backend_data (abfd
)->want_got_plt
3579 && strcmp (name
, ".plt") == 0)
3584 sec
= bfd_get_section_by_name (abfd
, name
);
3590 return bfd_get_section_by_name (abfd
, name
);
3593 /* Return the section to which RELOC_SEC applies. */
3596 elf_get_reloc_section (asection
*reloc_sec
)
3601 const struct elf_backend_data
*bed
;
3603 type
= elf_section_data (reloc_sec
)->this_hdr
.sh_type
;
3604 if (type
!= SHT_REL
&& type
!= SHT_RELA
)
3607 /* We look up the section the relocs apply to by name. */
3608 name
= reloc_sec
->name
;
3609 if (strncmp (name
, ".rel", 4) != 0)
3612 if (type
== SHT_RELA
&& *name
++ != 'a')
3615 abfd
= reloc_sec
->owner
;
3616 bed
= get_elf_backend_data (abfd
);
3617 return bed
->get_reloc_section (abfd
, name
);
3620 /* Assign all ELF section numbers. The dummy first section is handled here
3621 too. The link/info pointers for the standard section types are filled
3622 in here too, while we're at it. */
3625 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3627 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3629 unsigned int section_number
;
3630 Elf_Internal_Shdr
**i_shdrp
;
3631 struct bfd_elf_section_data
*d
;
3632 bfd_boolean need_symtab
;
3636 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3638 /* SHT_GROUP sections are in relocatable files only. */
3639 if (link_info
== NULL
|| !link_info
->resolve_section_groups
)
3641 size_t reloc_count
= 0;
3643 /* Put SHT_GROUP sections first. */
3644 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3646 d
= elf_section_data (sec
);
3648 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3650 if (sec
->flags
& SEC_LINKER_CREATED
)
3652 /* Remove the linker created SHT_GROUP sections. */
3653 bfd_section_list_remove (abfd
, sec
);
3654 abfd
->section_count
--;
3657 d
->this_idx
= section_number
++;
3660 /* Count relocations. */
3661 reloc_count
+= sec
->reloc_count
;
3664 /* Clear HAS_RELOC if there are no relocations. */
3665 if (reloc_count
== 0)
3666 abfd
->flags
&= ~HAS_RELOC
;
3669 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3671 d
= elf_section_data (sec
);
3673 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3674 d
->this_idx
= section_number
++;
3675 if (d
->this_hdr
.sh_name
!= (unsigned int) -1)
3676 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3679 d
->rel
.idx
= section_number
++;
3680 if (d
->rel
.hdr
->sh_name
!= (unsigned int) -1)
3681 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
3688 d
->rela
.idx
= section_number
++;
3689 if (d
->rela
.hdr
->sh_name
!= (unsigned int) -1)
3690 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
3696 need_symtab
= (bfd_get_symcount (abfd
) > 0
3697 || (link_info
== NULL
3698 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3702 elf_onesymtab (abfd
) = section_number
++;
3703 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3704 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
3706 elf_section_list
* entry
;
3708 BFD_ASSERT (elf_symtab_shndx_list (abfd
) == NULL
);
3710 entry
= bfd_zalloc (abfd
, sizeof * entry
);
3711 entry
->ndx
= section_number
++;
3712 elf_symtab_shndx_list (abfd
) = entry
;
3714 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3715 ".symtab_shndx", FALSE
);
3716 if (entry
->hdr
.sh_name
== (unsigned int) -1)
3719 elf_strtab_sec (abfd
) = section_number
++;
3720 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3723 elf_shstrtab_sec (abfd
) = section_number
++;
3724 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3725 elf_elfheader (abfd
)->e_shstrndx
= elf_shstrtab_sec (abfd
);
3727 if (section_number
>= SHN_LORESERVE
)
3729 /* xgettext:c-format */
3730 _bfd_error_handler (_("%B: too many sections: %u"),
3731 abfd
, section_number
);
3735 elf_numsections (abfd
) = section_number
;
3736 elf_elfheader (abfd
)->e_shnum
= section_number
;
3738 /* Set up the list of section header pointers, in agreement with the
3740 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
3741 sizeof (Elf_Internal_Shdr
*));
3742 if (i_shdrp
== NULL
)
3745 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
3746 sizeof (Elf_Internal_Shdr
));
3747 if (i_shdrp
[0] == NULL
)
3749 bfd_release (abfd
, i_shdrp
);
3753 elf_elfsections (abfd
) = i_shdrp
;
3755 i_shdrp
[elf_shstrtab_sec (abfd
)] = &t
->shstrtab_hdr
;
3758 i_shdrp
[elf_onesymtab (abfd
)] = &t
->symtab_hdr
;
3759 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
3761 elf_section_list
* entry
= elf_symtab_shndx_list (abfd
);
3762 BFD_ASSERT (entry
!= NULL
);
3763 i_shdrp
[entry
->ndx
] = & entry
->hdr
;
3764 entry
->hdr
.sh_link
= elf_onesymtab (abfd
);
3766 i_shdrp
[elf_strtab_sec (abfd
)] = &t
->strtab_hdr
;
3767 t
->symtab_hdr
.sh_link
= elf_strtab_sec (abfd
);
3770 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3774 d
= elf_section_data (sec
);
3776 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3777 if (d
->rel
.idx
!= 0)
3778 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
3779 if (d
->rela
.idx
!= 0)
3780 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
3782 /* Fill in the sh_link and sh_info fields while we're at it. */
3784 /* sh_link of a reloc section is the section index of the symbol
3785 table. sh_info is the section index of the section to which
3786 the relocation entries apply. */
3787 if (d
->rel
.idx
!= 0)
3789 d
->rel
.hdr
->sh_link
= elf_onesymtab (abfd
);
3790 d
->rel
.hdr
->sh_info
= d
->this_idx
;
3791 d
->rel
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3793 if (d
->rela
.idx
!= 0)
3795 d
->rela
.hdr
->sh_link
= elf_onesymtab (abfd
);
3796 d
->rela
.hdr
->sh_info
= d
->this_idx
;
3797 d
->rela
.hdr
->sh_flags
|= SHF_INFO_LINK
;
3800 /* We need to set up sh_link for SHF_LINK_ORDER. */
3801 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3803 s
= elf_linked_to_section (sec
);
3806 /* elf_linked_to_section points to the input section. */
3807 if (link_info
!= NULL
)
3809 /* Check discarded linkonce section. */
3810 if (discarded_section (s
))
3814 /* xgettext:c-format */
3815 (_("%B: sh_link of section `%A' points to"
3816 " discarded section `%A' of `%B'"),
3817 abfd
, d
->this_hdr
.bfd_section
,
3819 /* Point to the kept section if it has the same
3820 size as the discarded one. */
3821 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3824 bfd_set_error (bfd_error_bad_value
);
3830 s
= s
->output_section
;
3831 BFD_ASSERT (s
!= NULL
);
3835 /* Handle objcopy. */
3836 if (s
->output_section
== NULL
)
3839 /* xgettext:c-format */
3840 (_("%B: sh_link of section `%A' points to"
3841 " removed section `%A' of `%B'"),
3842 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3843 bfd_set_error (bfd_error_bad_value
);
3846 s
= s
->output_section
;
3848 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3853 The Intel C compiler generates SHT_IA_64_UNWIND with
3854 SHF_LINK_ORDER. But it doesn't set the sh_link or
3855 sh_info fields. Hence we could get the situation
3857 const struct elf_backend_data
*bed
3858 = get_elf_backend_data (abfd
);
3859 if (bed
->link_order_error_handler
)
3860 bed
->link_order_error_handler
3861 /* xgettext:c-format */
3862 (_("%B: warning: sh_link not set for section `%A'"),
3867 switch (d
->this_hdr
.sh_type
)
3871 /* A reloc section which we are treating as a normal BFD
3872 section. sh_link is the section index of the symbol
3873 table. sh_info is the section index of the section to
3874 which the relocation entries apply. We assume that an
3875 allocated reloc section uses the dynamic symbol table.
3876 FIXME: How can we be sure? */
3877 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3879 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3881 s
= elf_get_reloc_section (sec
);
3884 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3885 d
->this_hdr
.sh_flags
|= SHF_INFO_LINK
;
3890 /* We assume that a section named .stab*str is a stabs
3891 string section. We look for a section with the same name
3892 but without the trailing ``str'', and set its sh_link
3893 field to point to this section. */
3894 if (CONST_STRNEQ (sec
->name
, ".stab")
3895 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3900 len
= strlen (sec
->name
);
3901 alc
= (char *) bfd_malloc (len
- 2);
3904 memcpy (alc
, sec
->name
, len
- 3);
3905 alc
[len
- 3] = '\0';
3906 s
= bfd_get_section_by_name (abfd
, alc
);
3910 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3912 /* This is a .stab section. */
3913 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3914 elf_section_data (s
)->this_hdr
.sh_entsize
3915 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3922 case SHT_GNU_verneed
:
3923 case SHT_GNU_verdef
:
3924 /* sh_link is the section header index of the string table
3925 used for the dynamic entries, or the symbol table, or the
3927 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3929 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3932 case SHT_GNU_LIBLIST
:
3933 /* sh_link is the section header index of the prelink library
3934 list used for the dynamic entries, or the symbol table, or
3935 the version strings. */
3936 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3937 ? ".dynstr" : ".gnu.libstr");
3939 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3944 case SHT_GNU_versym
:
3945 /* sh_link is the section header index of the symbol table
3946 this hash table or version table is for. */
3947 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3949 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3953 d
->this_hdr
.sh_link
= elf_onesymtab (abfd
);
3957 /* Delay setting sh_name to _bfd_elf_write_object_contents so that
3958 _bfd_elf_assign_file_positions_for_non_load can convert DWARF
3959 debug section name from .debug_* to .zdebug_* if needed. */
3965 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3967 /* If the backend has a special mapping, use it. */
3968 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3969 if (bed
->elf_backend_sym_is_global
)
3970 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3972 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3973 || bfd_is_und_section (bfd_get_section (sym
))
3974 || bfd_is_com_section (bfd_get_section (sym
)));
3977 /* Filter global symbols of ABFD to include in the import library. All
3978 SYMCOUNT symbols of ABFD can be examined from their pointers in
3979 SYMS. Pointers of symbols to keep should be stored contiguously at
3980 the beginning of that array.
3982 Returns the number of symbols to keep. */
3985 _bfd_elf_filter_global_symbols (bfd
*abfd
, struct bfd_link_info
*info
,
3986 asymbol
**syms
, long symcount
)
3988 long src_count
, dst_count
= 0;
3990 for (src_count
= 0; src_count
< symcount
; src_count
++)
3992 asymbol
*sym
= syms
[src_count
];
3993 char *name
= (char *) bfd_asymbol_name (sym
);
3994 struct bfd_link_hash_entry
*h
;
3996 if (!sym_is_global (abfd
, sym
))
3999 h
= bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
4002 if (h
->type
!= bfd_link_hash_defined
&& h
->type
!= bfd_link_hash_defweak
)
4004 if (h
->linker_def
|| h
->ldscript_def
)
4007 syms
[dst_count
++] = sym
;
4010 syms
[dst_count
] = NULL
;
4015 /* Don't output section symbols for sections that are not going to be
4016 output, that are duplicates or there is no BFD section. */
4019 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
4021 elf_symbol_type
*type_ptr
;
4023 if ((sym
->flags
& BSF_SECTION_SYM
) == 0)
4026 type_ptr
= elf_symbol_from (abfd
, sym
);
4027 return ((type_ptr
!= NULL
4028 && type_ptr
->internal_elf_sym
.st_shndx
!= 0
4029 && bfd_is_abs_section (sym
->section
))
4030 || !(sym
->section
->owner
== abfd
4031 || (sym
->section
->output_section
->owner
== abfd
4032 && sym
->section
->output_offset
== 0)
4033 || bfd_is_abs_section (sym
->section
)));
4036 /* Map symbol from it's internal number to the external number, moving
4037 all local symbols to be at the head of the list. */
4040 elf_map_symbols (bfd
*abfd
, unsigned int *pnum_locals
)
4042 unsigned int symcount
= bfd_get_symcount (abfd
);
4043 asymbol
**syms
= bfd_get_outsymbols (abfd
);
4044 asymbol
**sect_syms
;
4045 unsigned int num_locals
= 0;
4046 unsigned int num_globals
= 0;
4047 unsigned int num_locals2
= 0;
4048 unsigned int num_globals2
= 0;
4049 unsigned int max_index
= 0;
4055 fprintf (stderr
, "elf_map_symbols\n");
4059 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4061 if (max_index
< asect
->index
)
4062 max_index
= asect
->index
;
4066 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
4067 if (sect_syms
== NULL
)
4069 elf_section_syms (abfd
) = sect_syms
;
4070 elf_num_section_syms (abfd
) = max_index
;
4072 /* Init sect_syms entries for any section symbols we have already
4073 decided to output. */
4074 for (idx
= 0; idx
< symcount
; idx
++)
4076 asymbol
*sym
= syms
[idx
];
4078 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
4080 && !ignore_section_sym (abfd
, sym
)
4081 && !bfd_is_abs_section (sym
->section
))
4083 asection
*sec
= sym
->section
;
4085 if (sec
->owner
!= abfd
)
4086 sec
= sec
->output_section
;
4088 sect_syms
[sec
->index
] = syms
[idx
];
4092 /* Classify all of the symbols. */
4093 for (idx
= 0; idx
< symcount
; idx
++)
4095 if (sym_is_global (abfd
, syms
[idx
]))
4097 else if (!ignore_section_sym (abfd
, syms
[idx
]))
4101 /* We will be adding a section symbol for each normal BFD section. Most
4102 sections will already have a section symbol in outsymbols, but
4103 eg. SHT_GROUP sections will not, and we need the section symbol mapped
4104 at least in that case. */
4105 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4107 if (sect_syms
[asect
->index
] == NULL
)
4109 if (!sym_is_global (abfd
, asect
->symbol
))
4116 /* Now sort the symbols so the local symbols are first. */
4117 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
4118 sizeof (asymbol
*));
4120 if (new_syms
== NULL
)
4123 for (idx
= 0; idx
< symcount
; idx
++)
4125 asymbol
*sym
= syms
[idx
];
4128 if (sym_is_global (abfd
, sym
))
4129 i
= num_locals
+ num_globals2
++;
4130 else if (!ignore_section_sym (abfd
, sym
))
4135 sym
->udata
.i
= i
+ 1;
4137 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
4139 if (sect_syms
[asect
->index
] == NULL
)
4141 asymbol
*sym
= asect
->symbol
;
4144 sect_syms
[asect
->index
] = sym
;
4145 if (!sym_is_global (abfd
, sym
))
4148 i
= num_locals
+ num_globals2
++;
4150 sym
->udata
.i
= i
+ 1;
4154 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
4156 *pnum_locals
= num_locals
;
4160 /* Align to the maximum file alignment that could be required for any
4161 ELF data structure. */
4163 static inline file_ptr
4164 align_file_position (file_ptr off
, int align
)
4166 return (off
+ align
- 1) & ~(align
- 1);
4169 /* Assign a file position to a section, optionally aligning to the
4170 required section alignment. */
4173 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
4177 if (align
&& i_shdrp
->sh_addralign
> 1)
4178 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
4179 i_shdrp
->sh_offset
= offset
;
4180 if (i_shdrp
->bfd_section
!= NULL
)
4181 i_shdrp
->bfd_section
->filepos
= offset
;
4182 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
4183 offset
+= i_shdrp
->sh_size
;
4187 /* Compute the file positions we are going to put the sections at, and
4188 otherwise prepare to begin writing out the ELF file. If LINK_INFO
4189 is not NULL, this is being called by the ELF backend linker. */
4192 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
4193 struct bfd_link_info
*link_info
)
4195 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4196 struct fake_section_arg fsargs
;
4198 struct elf_strtab_hash
*strtab
= NULL
;
4199 Elf_Internal_Shdr
*shstrtab_hdr
;
4200 bfd_boolean need_symtab
;
4202 if (abfd
->output_has_begun
)
4205 /* Do any elf backend specific processing first. */
4206 if (bed
->elf_backend_begin_write_processing
)
4207 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
4209 if (! prep_headers (abfd
))
4212 /* Post process the headers if necessary. */
4213 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
4215 fsargs
.failed
= FALSE
;
4216 fsargs
.link_info
= link_info
;
4217 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
4221 if (!assign_section_numbers (abfd
, link_info
))
4224 /* The backend linker builds symbol table information itself. */
4225 need_symtab
= (link_info
== NULL
4226 && (bfd_get_symcount (abfd
) > 0
4227 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
4231 /* Non-zero if doing a relocatable link. */
4232 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
4234 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
4239 if (link_info
== NULL
)
4241 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
4246 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
4247 /* sh_name was set in prep_headers. */
4248 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
4249 shstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
4250 shstrtab_hdr
->sh_addr
= 0;
4251 /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */
4252 shstrtab_hdr
->sh_entsize
= 0;
4253 shstrtab_hdr
->sh_link
= 0;
4254 shstrtab_hdr
->sh_info
= 0;
4255 /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */
4256 shstrtab_hdr
->sh_addralign
= 1;
4258 if (!assign_file_positions_except_relocs (abfd
, link_info
))
4264 Elf_Internal_Shdr
*hdr
;
4266 off
= elf_next_file_pos (abfd
);
4268 hdr
= & elf_symtab_hdr (abfd
);
4269 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4271 if (elf_symtab_shndx_list (abfd
) != NULL
)
4273 hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
4274 if (hdr
->sh_size
!= 0)
4275 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4276 /* FIXME: What about other symtab_shndx sections in the list ? */
4279 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
4280 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4282 elf_next_file_pos (abfd
) = off
;
4284 /* Now that we know where the .strtab section goes, write it
4286 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4287 || ! _bfd_elf_strtab_emit (abfd
, strtab
))
4289 _bfd_elf_strtab_free (strtab
);
4292 abfd
->output_has_begun
= TRUE
;
4297 /* Make an initial estimate of the size of the program header. If we
4298 get the number wrong here, we'll redo section placement. */
4300 static bfd_size_type
4301 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
4305 const struct elf_backend_data
*bed
;
4307 /* Assume we will need exactly two PT_LOAD segments: one for text
4308 and one for data. */
4311 s
= bfd_get_section_by_name (abfd
, ".interp");
4312 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4314 /* If we have a loadable interpreter section, we need a
4315 PT_INTERP segment. In this case, assume we also need a
4316 PT_PHDR segment, although that may not be true for all
4321 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
4323 /* We need a PT_DYNAMIC segment. */
4327 if (info
!= NULL
&& info
->relro
)
4329 /* We need a PT_GNU_RELRO segment. */
4333 if (elf_eh_frame_hdr (abfd
))
4335 /* We need a PT_GNU_EH_FRAME segment. */
4339 if (elf_stack_flags (abfd
))
4341 /* We need a PT_GNU_STACK segment. */
4345 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4347 if ((s
->flags
& SEC_LOAD
) != 0
4348 && CONST_STRNEQ (s
->name
, ".note"))
4350 /* We need a PT_NOTE segment. */
4352 /* Try to create just one PT_NOTE segment
4353 for all adjacent loadable .note* sections.
4354 gABI requires that within a PT_NOTE segment
4355 (and also inside of each SHT_NOTE section)
4356 each note is padded to a multiple of 4 size,
4357 so we check whether the sections are correctly
4359 if (s
->alignment_power
== 2)
4360 while (s
->next
!= NULL
4361 && s
->next
->alignment_power
== 2
4362 && (s
->next
->flags
& SEC_LOAD
) != 0
4363 && CONST_STRNEQ (s
->next
->name
, ".note"))
4368 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4370 if (s
->flags
& SEC_THREAD_LOCAL
)
4372 /* We need a PT_TLS segment. */
4378 bed
= get_elf_backend_data (abfd
);
4380 if ((abfd
->flags
& D_PAGED
) != 0)
4382 /* Add a PT_GNU_MBIND segment for each mbind section. */
4383 unsigned int page_align_power
= bfd_log2 (bed
->commonpagesize
);
4384 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4385 if (elf_section_flags (s
) & SHF_GNU_MBIND
)
4387 if (elf_section_data (s
)->this_hdr
.sh_info
4391 /* xgettext:c-format */
4392 (_("%B: GNU_MBIN section `%A' has invalid sh_info field: %d"),
4393 abfd
, s
, elf_section_data (s
)->this_hdr
.sh_info
);
4396 /* Align mbind section to page size. */
4397 if (s
->alignment_power
< page_align_power
)
4398 s
->alignment_power
= page_align_power
;
4403 /* Let the backend count up any program headers it might need. */
4404 if (bed
->elf_backend_additional_program_headers
)
4408 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
4414 return segs
* bed
->s
->sizeof_phdr
;
4417 /* Find the segment that contains the output_section of section. */
4420 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
4422 struct elf_segment_map
*m
;
4423 Elf_Internal_Phdr
*p
;
4425 for (m
= elf_seg_map (abfd
), p
= elf_tdata (abfd
)->phdr
;
4431 for (i
= m
->count
- 1; i
>= 0; i
--)
4432 if (m
->sections
[i
] == section
)
4439 /* Create a mapping from a set of sections to a program segment. */
4441 static struct elf_segment_map
*
4442 make_mapping (bfd
*abfd
,
4443 asection
**sections
,
4448 struct elf_segment_map
*m
;
4453 amt
= sizeof (struct elf_segment_map
);
4454 amt
+= (to
- from
- 1) * sizeof (asection
*);
4455 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4459 m
->p_type
= PT_LOAD
;
4460 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
4461 m
->sections
[i
- from
] = *hdrpp
;
4462 m
->count
= to
- from
;
4464 if (from
== 0 && phdr
)
4466 /* Include the headers in the first PT_LOAD segment. */
4467 m
->includes_filehdr
= 1;
4468 m
->includes_phdrs
= 1;
4474 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
4477 struct elf_segment_map
*
4478 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
4480 struct elf_segment_map
*m
;
4482 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
4483 sizeof (struct elf_segment_map
));
4487 m
->p_type
= PT_DYNAMIC
;
4489 m
->sections
[0] = dynsec
;
4494 /* Possibly add or remove segments from the segment map. */
4497 elf_modify_segment_map (bfd
*abfd
,
4498 struct bfd_link_info
*info
,
4499 bfd_boolean remove_empty_load
)
4501 struct elf_segment_map
**m
;
4502 const struct elf_backend_data
*bed
;
4504 /* The placement algorithm assumes that non allocated sections are
4505 not in PT_LOAD segments. We ensure this here by removing such
4506 sections from the segment map. We also remove excluded
4507 sections. Finally, any PT_LOAD segment without sections is
4509 m
= &elf_seg_map (abfd
);
4512 unsigned int i
, new_count
;
4514 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
4516 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
4517 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
4518 || (*m
)->p_type
!= PT_LOAD
))
4520 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
4524 (*m
)->count
= new_count
;
4526 if (remove_empty_load
4527 && (*m
)->p_type
== PT_LOAD
4529 && !(*m
)->includes_phdrs
)
4535 bed
= get_elf_backend_data (abfd
);
4536 if (bed
->elf_backend_modify_segment_map
!= NULL
)
4538 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
4545 /* Set up a mapping from BFD sections to program segments. */
4548 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
4551 struct elf_segment_map
*m
;
4552 asection
**sections
= NULL
;
4553 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4554 bfd_boolean no_user_phdrs
;
4556 no_user_phdrs
= elf_seg_map (abfd
) == NULL
;
4559 info
->user_phdrs
= !no_user_phdrs
;
4561 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
4565 struct elf_segment_map
*mfirst
;
4566 struct elf_segment_map
**pm
;
4569 unsigned int phdr_index
;
4570 bfd_vma maxpagesize
;
4572 bfd_boolean phdr_in_segment
= TRUE
;
4573 bfd_boolean writable
;
4574 bfd_boolean executable
;
4576 asection
*first_tls
= NULL
;
4577 asection
*first_mbind
= NULL
;
4578 asection
*dynsec
, *eh_frame_hdr
;
4580 bfd_vma addr_mask
, wrap_to
= 0;
4581 bfd_boolean linker_created_pt_phdr_segment
= FALSE
;
4583 /* Select the allocated sections, and sort them. */
4585 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
4586 sizeof (asection
*));
4587 if (sections
== NULL
)
4590 /* Calculate top address, avoiding undefined behaviour of shift
4591 left operator when shift count is equal to size of type
4593 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
4594 addr_mask
= (addr_mask
<< 1) + 1;
4597 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4599 if ((s
->flags
& SEC_ALLOC
) != 0)
4603 /* A wrapping section potentially clashes with header. */
4604 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
4605 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
4608 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
4611 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
4613 /* Build the mapping. */
4618 /* If we have a .interp section, then create a PT_PHDR segment for
4619 the program headers and a PT_INTERP segment for the .interp
4621 s
= bfd_get_section_by_name (abfd
, ".interp");
4622 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
4624 amt
= sizeof (struct elf_segment_map
);
4625 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4629 m
->p_type
= PT_PHDR
;
4631 m
->p_flags_valid
= 1;
4632 m
->includes_phdrs
= 1;
4633 linker_created_pt_phdr_segment
= TRUE
;
4637 amt
= sizeof (struct elf_segment_map
);
4638 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4642 m
->p_type
= PT_INTERP
;
4650 /* Look through the sections. We put sections in the same program
4651 segment when the start of the second section can be placed within
4652 a few bytes of the end of the first section. */
4656 maxpagesize
= bed
->maxpagesize
;
4657 /* PR 17512: file: c8455299.
4658 Avoid divide-by-zero errors later on.
4659 FIXME: Should we abort if the maxpagesize is zero ? */
4660 if (maxpagesize
== 0)
4664 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
4666 && (dynsec
->flags
& SEC_LOAD
) == 0)
4669 /* Deal with -Ttext or something similar such that the first section
4670 is not adjacent to the program headers. This is an
4671 approximation, since at this point we don't know exactly how many
4672 program headers we will need. */
4675 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
4677 if (phdr_size
== (bfd_size_type
) -1)
4678 phdr_size
= get_program_header_size (abfd
, info
);
4679 phdr_size
+= bed
->s
->sizeof_ehdr
;
4680 if ((abfd
->flags
& D_PAGED
) == 0
4681 || (sections
[0]->lma
& addr_mask
) < phdr_size
4682 || ((sections
[0]->lma
& addr_mask
) % maxpagesize
4683 < phdr_size
% maxpagesize
)
4684 || (sections
[0]->lma
& addr_mask
& -maxpagesize
) < wrap_to
)
4686 /* PR 20815: The ELF standard says that a PT_PHDR segment, if
4687 present, must be included as part of the memory image of the
4688 program. Ie it must be part of a PT_LOAD segment as well.
4689 If we have had to create our own PT_PHDR segment, but it is
4690 not going to be covered by the first PT_LOAD segment, then
4691 force the inclusion if we can... */
4692 if ((abfd
->flags
& D_PAGED
) != 0
4693 && linker_created_pt_phdr_segment
)
4694 phdr_in_segment
= TRUE
;
4696 phdr_in_segment
= FALSE
;
4700 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
4703 bfd_boolean new_segment
;
4707 /* See if this section and the last one will fit in the same
4710 if (last_hdr
== NULL
)
4712 /* If we don't have a segment yet, then we don't need a new
4713 one (we build the last one after this loop). */
4714 new_segment
= FALSE
;
4716 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
4718 /* If this section has a different relation between the
4719 virtual address and the load address, then we need a new
4723 else if (hdr
->lma
< last_hdr
->lma
+ last_size
4724 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
4726 /* If this section has a load address that makes it overlap
4727 the previous section, then we need a new segment. */
4730 else if ((abfd
->flags
& D_PAGED
) != 0
4731 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
4732 == (hdr
->lma
& -maxpagesize
)))
4734 /* If we are demand paged then we can't map two disk
4735 pages onto the same memory page. */
4736 new_segment
= FALSE
;
4738 /* In the next test we have to be careful when last_hdr->lma is close
4739 to the end of the address space. If the aligned address wraps
4740 around to the start of the address space, then there are no more
4741 pages left in memory and it is OK to assume that the current
4742 section can be included in the current segment. */
4743 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4744 + maxpagesize
> last_hdr
->lma
)
4745 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
4746 + maxpagesize
<= hdr
->lma
))
4748 /* If putting this section in this segment would force us to
4749 skip a page in the segment, then we need a new segment. */
4752 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
4753 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
4755 /* We don't want to put a loaded section after a
4756 nonloaded (ie. bss style) section in the same segment
4757 as that will force the non-loaded section to be loaded.
4758 Consider .tbss sections as loaded for this purpose. */
4761 else if ((abfd
->flags
& D_PAGED
) == 0)
4763 /* If the file is not demand paged, which means that we
4764 don't require the sections to be correctly aligned in the
4765 file, then there is no other reason for a new segment. */
4766 new_segment
= FALSE
;
4768 else if (info
!= NULL
4769 && info
->separate_code
4770 && executable
!= ((hdr
->flags
& SEC_CODE
) != 0))
4775 && (hdr
->flags
& SEC_READONLY
) == 0)
4777 /* We don't want to put a writable section in a read only
4783 /* Otherwise, we can use the same segment. */
4784 new_segment
= FALSE
;
4787 /* Allow interested parties a chance to override our decision. */
4788 if (last_hdr
!= NULL
4790 && info
->callbacks
->override_segment_assignment
!= NULL
)
4792 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
4798 if ((hdr
->flags
& SEC_READONLY
) == 0)
4800 if ((hdr
->flags
& SEC_CODE
) != 0)
4803 /* .tbss sections effectively have zero size. */
4804 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4805 != SEC_THREAD_LOCAL
)
4806 last_size
= hdr
->size
;
4812 /* We need a new program segment. We must create a new program
4813 header holding all the sections from phdr_index until hdr. */
4815 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4822 if ((hdr
->flags
& SEC_READONLY
) == 0)
4827 if ((hdr
->flags
& SEC_CODE
) == 0)
4833 /* .tbss sections effectively have zero size. */
4834 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
4835 last_size
= hdr
->size
;
4839 phdr_in_segment
= FALSE
;
4842 /* Create a final PT_LOAD program segment, but not if it's just
4844 if (last_hdr
!= NULL
4845 && (i
- phdr_index
!= 1
4846 || ((last_hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4847 != SEC_THREAD_LOCAL
)))
4849 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4857 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4860 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4867 /* For each batch of consecutive loadable .note sections,
4868 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4869 because if we link together nonloadable .note sections and
4870 loadable .note sections, we will generate two .note sections
4871 in the output file. FIXME: Using names for section types is
4873 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4875 if ((s
->flags
& SEC_LOAD
) != 0
4876 && CONST_STRNEQ (s
->name
, ".note"))
4881 amt
= sizeof (struct elf_segment_map
);
4882 if (s
->alignment_power
== 2)
4883 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
4885 if (s2
->next
->alignment_power
== 2
4886 && (s2
->next
->flags
& SEC_LOAD
) != 0
4887 && CONST_STRNEQ (s2
->next
->name
, ".note")
4888 && align_power (s2
->lma
+ s2
->size
, 2)
4894 amt
+= (count
- 1) * sizeof (asection
*);
4895 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4899 m
->p_type
= PT_NOTE
;
4903 m
->sections
[m
->count
- count
--] = s
;
4904 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4907 m
->sections
[m
->count
- 1] = s
;
4908 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
4912 if (s
->flags
& SEC_THREAD_LOCAL
)
4918 if (first_mbind
== NULL
4919 && (elf_section_flags (s
) & SHF_GNU_MBIND
) != 0)
4923 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4926 amt
= sizeof (struct elf_segment_map
);
4927 amt
+= (tls_count
- 1) * sizeof (asection
*);
4928 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4933 m
->count
= tls_count
;
4934 /* Mandated PF_R. */
4936 m
->p_flags_valid
= 1;
4938 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
4940 if ((s
->flags
& SEC_THREAD_LOCAL
) == 0)
4943 (_("%B: TLS sections are not adjacent:"), abfd
);
4946 while (i
< (unsigned int) tls_count
)
4948 if ((s
->flags
& SEC_THREAD_LOCAL
) != 0)
4950 _bfd_error_handler (_(" TLS: %A"), s
);
4954 _bfd_error_handler (_(" non-TLS: %A"), s
);
4957 bfd_set_error (bfd_error_bad_value
);
4968 if (first_mbind
&& (abfd
->flags
& D_PAGED
) != 0)
4969 for (s
= first_mbind
; s
!= NULL
; s
= s
->next
)
4970 if ((elf_section_flags (s
) & SHF_GNU_MBIND
) != 0
4971 && (elf_section_data (s
)->this_hdr
.sh_info
4972 <= PT_GNU_MBIND_NUM
))
4974 /* Mandated PF_R. */
4975 unsigned long p_flags
= PF_R
;
4976 if ((s
->flags
& SEC_READONLY
) == 0)
4978 if ((s
->flags
& SEC_CODE
) != 0)
4981 amt
= sizeof (struct elf_segment_map
) + sizeof (asection
*);
4982 m
= bfd_zalloc (abfd
, amt
);
4986 m
->p_type
= (PT_GNU_MBIND_LO
4987 + elf_section_data (s
)->this_hdr
.sh_info
);
4989 m
->p_flags_valid
= 1;
4991 m
->p_flags
= p_flags
;
4997 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4999 eh_frame_hdr
= elf_eh_frame_hdr (abfd
);
5000 if (eh_frame_hdr
!= NULL
5001 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
5003 amt
= sizeof (struct elf_segment_map
);
5004 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5008 m
->p_type
= PT_GNU_EH_FRAME
;
5010 m
->sections
[0] = eh_frame_hdr
->output_section
;
5016 if (elf_stack_flags (abfd
))
5018 amt
= sizeof (struct elf_segment_map
);
5019 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5023 m
->p_type
= PT_GNU_STACK
;
5024 m
->p_flags
= elf_stack_flags (abfd
);
5025 m
->p_align
= bed
->stack_align
;
5026 m
->p_flags_valid
= 1;
5027 m
->p_align_valid
= m
->p_align
!= 0;
5028 if (info
->stacksize
> 0)
5030 m
->p_size
= info
->stacksize
;
5031 m
->p_size_valid
= 1;
5038 if (info
!= NULL
&& info
->relro
)
5040 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
5042 if (m
->p_type
== PT_LOAD
5044 && m
->sections
[0]->vma
>= info
->relro_start
5045 && m
->sections
[0]->vma
< info
->relro_end
)
5048 while (--i
!= (unsigned) -1)
5049 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
))
5050 == (SEC_LOAD
| SEC_HAS_CONTENTS
))
5053 if (i
!= (unsigned) -1)
5058 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
5061 amt
= sizeof (struct elf_segment_map
);
5062 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
5066 m
->p_type
= PT_GNU_RELRO
;
5073 elf_seg_map (abfd
) = mfirst
;
5076 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
5079 for (count
= 0, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5081 elf_program_header_size (abfd
) = count
* bed
->s
->sizeof_phdr
;
5086 if (sections
!= NULL
)
5091 /* Sort sections by address. */
5094 elf_sort_sections (const void *arg1
, const void *arg2
)
5096 const asection
*sec1
= *(const asection
**) arg1
;
5097 const asection
*sec2
= *(const asection
**) arg2
;
5098 bfd_size_type size1
, size2
;
5100 /* Sort by LMA first, since this is the address used to
5101 place the section into a segment. */
5102 if (sec1
->lma
< sec2
->lma
)
5104 else if (sec1
->lma
> sec2
->lma
)
5107 /* Then sort by VMA. Normally the LMA and the VMA will be
5108 the same, and this will do nothing. */
5109 if (sec1
->vma
< sec2
->vma
)
5111 else if (sec1
->vma
> sec2
->vma
)
5114 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
5116 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
5122 /* If the indicies are the same, do not return 0
5123 here, but continue to try the next comparison. */
5124 if (sec1
->target_index
- sec2
->target_index
!= 0)
5125 return sec1
->target_index
- sec2
->target_index
;
5130 else if (TOEND (sec2
))
5135 /* Sort by size, to put zero sized sections
5136 before others at the same address. */
5138 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
5139 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
5146 return sec1
->target_index
- sec2
->target_index
;
5149 /* Ian Lance Taylor writes:
5151 We shouldn't be using % with a negative signed number. That's just
5152 not good. We have to make sure either that the number is not
5153 negative, or that the number has an unsigned type. When the types
5154 are all the same size they wind up as unsigned. When file_ptr is a
5155 larger signed type, the arithmetic winds up as signed long long,
5158 What we're trying to say here is something like ``increase OFF by
5159 the least amount that will cause it to be equal to the VMA modulo
5161 /* In other words, something like:
5163 vma_offset = m->sections[0]->vma % bed->maxpagesize;
5164 off_offset = off % bed->maxpagesize;
5165 if (vma_offset < off_offset)
5166 adjustment = vma_offset + bed->maxpagesize - off_offset;
5168 adjustment = vma_offset - off_offset;
5170 which can be collapsed into the expression below. */
5173 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
5175 /* PR binutils/16199: Handle an alignment of zero. */
5176 if (maxpagesize
== 0)
5178 return ((vma
- off
) % maxpagesize
);
5182 print_segment_map (const struct elf_segment_map
*m
)
5185 const char *pt
= get_segment_type (m
->p_type
);
5190 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
5191 sprintf (buf
, "LOPROC+%7.7x",
5192 (unsigned int) (m
->p_type
- PT_LOPROC
));
5193 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
5194 sprintf (buf
, "LOOS+%7.7x",
5195 (unsigned int) (m
->p_type
- PT_LOOS
));
5197 snprintf (buf
, sizeof (buf
), "%8.8x",
5198 (unsigned int) m
->p_type
);
5202 fprintf (stderr
, "%s:", pt
);
5203 for (j
= 0; j
< m
->count
; j
++)
5204 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
5210 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
5215 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
5217 buf
= bfd_zmalloc (len
);
5220 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
5225 /* Assign file positions to the sections based on the mapping from
5226 sections to segments. This function also sets up some fields in
5230 assign_file_positions_for_load_sections (bfd
*abfd
,
5231 struct bfd_link_info
*link_info
)
5233 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5234 struct elf_segment_map
*m
;
5235 Elf_Internal_Phdr
*phdrs
;
5236 Elf_Internal_Phdr
*p
;
5238 bfd_size_type maxpagesize
;
5239 unsigned int pt_load_count
= 0;
5242 bfd_vma header_pad
= 0;
5244 if (link_info
== NULL
5245 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
5249 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5253 header_pad
= m
->header_size
;
5258 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
5259 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
5263 /* PR binutils/12467. */
5264 elf_elfheader (abfd
)->e_phoff
= 0;
5265 elf_elfheader (abfd
)->e_phentsize
= 0;
5268 elf_elfheader (abfd
)->e_phnum
= alloc
;
5270 if (elf_program_header_size (abfd
) == (bfd_size_type
) -1)
5271 elf_program_header_size (abfd
) = alloc
* bed
->s
->sizeof_phdr
;
5273 BFD_ASSERT (elf_program_header_size (abfd
)
5274 >= alloc
* bed
->s
->sizeof_phdr
);
5278 elf_next_file_pos (abfd
) = bed
->s
->sizeof_ehdr
;
5282 /* We're writing the size in elf_program_header_size (abfd),
5283 see assign_file_positions_except_relocs, so make sure we have
5284 that amount allocated, with trailing space cleared.
5285 The variable alloc contains the computed need, while
5286 elf_program_header_size (abfd) contains the size used for the
5288 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
5289 where the layout is forced to according to a larger size in the
5290 last iterations for the testcase ld-elf/header. */
5291 BFD_ASSERT (elf_program_header_size (abfd
) % bed
->s
->sizeof_phdr
5293 phdrs
= (Elf_Internal_Phdr
*)
5295 (elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
),
5296 sizeof (Elf_Internal_Phdr
));
5297 elf_tdata (abfd
)->phdr
= phdrs
;
5302 if ((abfd
->flags
& D_PAGED
) != 0)
5303 maxpagesize
= bed
->maxpagesize
;
5305 off
= bed
->s
->sizeof_ehdr
;
5306 off
+= alloc
* bed
->s
->sizeof_phdr
;
5307 if (header_pad
< (bfd_vma
) off
)
5313 for (m
= elf_seg_map (abfd
), p
= phdrs
, j
= 0;
5315 m
= m
->next
, p
++, j
++)
5319 bfd_boolean no_contents
;
5321 /* If elf_segment_map is not from map_sections_to_segments, the
5322 sections may not be correctly ordered. NOTE: sorting should
5323 not be done to the PT_NOTE section of a corefile, which may
5324 contain several pseudo-sections artificially created by bfd.
5325 Sorting these pseudo-sections breaks things badly. */
5327 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
5328 && m
->p_type
== PT_NOTE
))
5329 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
5332 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
5333 number of sections with contents contributing to both p_filesz
5334 and p_memsz, followed by a number of sections with no contents
5335 that just contribute to p_memsz. In this loop, OFF tracks next
5336 available file offset for PT_LOAD and PT_NOTE segments. */
5337 p
->p_type
= m
->p_type
;
5338 p
->p_flags
= m
->p_flags
;
5343 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
5345 if (m
->p_paddr_valid
)
5346 p
->p_paddr
= m
->p_paddr
;
5347 else if (m
->count
== 0)
5350 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
5352 if (p
->p_type
== PT_LOAD
5353 && (abfd
->flags
& D_PAGED
) != 0)
5355 /* p_align in demand paged PT_LOAD segments effectively stores
5356 the maximum page size. When copying an executable with
5357 objcopy, we set m->p_align from the input file. Use this
5358 value for maxpagesize rather than bed->maxpagesize, which
5359 may be different. Note that we use maxpagesize for PT_TLS
5360 segment alignment later in this function, so we are relying
5361 on at least one PT_LOAD segment appearing before a PT_TLS
5363 if (m
->p_align_valid
)
5364 maxpagesize
= m
->p_align
;
5366 p
->p_align
= maxpagesize
;
5369 else if (m
->p_align_valid
)
5370 p
->p_align
= m
->p_align
;
5371 else if (m
->count
== 0)
5372 p
->p_align
= 1 << bed
->s
->log_file_align
;
5376 no_contents
= FALSE
;
5378 if (p
->p_type
== PT_LOAD
5381 bfd_size_type align
;
5382 unsigned int align_power
= 0;
5384 if (m
->p_align_valid
)
5388 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5390 unsigned int secalign
;
5392 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
5393 if (secalign
> align_power
)
5394 align_power
= secalign
;
5396 align
= (bfd_size_type
) 1 << align_power
;
5397 if (align
< maxpagesize
)
5398 align
= maxpagesize
;
5401 for (i
= 0; i
< m
->count
; i
++)
5402 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
5403 /* If we aren't making room for this section, then
5404 it must be SHT_NOBITS regardless of what we've
5405 set via struct bfd_elf_special_section. */
5406 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
5408 /* Find out whether this segment contains any loadable
5411 for (i
= 0; i
< m
->count
; i
++)
5412 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
5414 no_contents
= FALSE
;
5418 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
5420 /* Broken hardware and/or kernel require that files do not
5421 map the same page with different permissions on some hppa
5423 if (pt_load_count
> 1
5424 && bed
->no_page_alias
5425 && (off
& (maxpagesize
- 1)) != 0
5426 && (off
& -maxpagesize
) == ((off
+ off_adjust
) & -maxpagesize
))
5427 off_adjust
+= maxpagesize
;
5431 /* We shouldn't need to align the segment on disk since
5432 the segment doesn't need file space, but the gABI
5433 arguably requires the alignment and glibc ld.so
5434 checks it. So to comply with the alignment
5435 requirement but not waste file space, we adjust
5436 p_offset for just this segment. (OFF_ADJUST is
5437 subtracted from OFF later.) This may put p_offset
5438 past the end of file, but that shouldn't matter. */
5443 /* Make sure the .dynamic section is the first section in the
5444 PT_DYNAMIC segment. */
5445 else if (p
->p_type
== PT_DYNAMIC
5447 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
5450 (_("%B: The first section in the PT_DYNAMIC segment"
5451 " is not the .dynamic section"),
5453 bfd_set_error (bfd_error_bad_value
);
5456 /* Set the note section type to SHT_NOTE. */
5457 else if (p
->p_type
== PT_NOTE
)
5458 for (i
= 0; i
< m
->count
; i
++)
5459 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
5465 if (m
->includes_filehdr
)
5467 if (!m
->p_flags_valid
)
5469 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
5470 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
5473 if (p
->p_vaddr
< (bfd_vma
) off
5474 || (!m
->p_paddr_valid
5475 && p
->p_paddr
< (bfd_vma
) off
))
5478 (_("%B: Not enough room for program headers,"
5479 " try linking with -N"),
5481 bfd_set_error (bfd_error_bad_value
);
5486 if (!m
->p_paddr_valid
)
5491 if (m
->includes_phdrs
)
5493 if (!m
->p_flags_valid
)
5496 if (!m
->includes_filehdr
)
5498 p
->p_offset
= bed
->s
->sizeof_ehdr
;
5502 p
->p_vaddr
-= off
- p
->p_offset
;
5503 if (!m
->p_paddr_valid
)
5504 p
->p_paddr
-= off
- p
->p_offset
;
5508 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
5509 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
5512 p
->p_filesz
+= header_pad
;
5513 p
->p_memsz
+= header_pad
;
5517 if (p
->p_type
== PT_LOAD
5518 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
5520 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
5526 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
5528 p
->p_filesz
+= adjust
;
5529 p
->p_memsz
+= adjust
;
5533 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
5534 maps. Set filepos for sections in PT_LOAD segments, and in
5535 core files, for sections in PT_NOTE segments.
5536 assign_file_positions_for_non_load_sections will set filepos
5537 for other sections and update p_filesz for other segments. */
5538 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
5541 bfd_size_type align
;
5542 Elf_Internal_Shdr
*this_hdr
;
5545 this_hdr
= &elf_section_data (sec
)->this_hdr
;
5546 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
5548 if ((p
->p_type
== PT_LOAD
5549 || p
->p_type
== PT_TLS
)
5550 && (this_hdr
->sh_type
!= SHT_NOBITS
5551 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
5552 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
5553 || p
->p_type
== PT_TLS
))))
5555 bfd_vma p_start
= p
->p_paddr
;
5556 bfd_vma p_end
= p_start
+ p
->p_memsz
;
5557 bfd_vma s_start
= sec
->lma
;
5558 bfd_vma adjust
= s_start
- p_end
;
5562 || p_end
< p_start
))
5565 /* xgettext:c-format */
5566 (_("%B: section %A lma %#Lx adjusted to %#Lx"),
5567 abfd
, sec
, s_start
, p_end
);
5571 p
->p_memsz
+= adjust
;
5573 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5575 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
5577 /* We have a PROGBITS section following NOBITS ones.
5578 Allocate file space for the NOBITS section(s) and
5580 adjust
= p
->p_memsz
- p
->p_filesz
;
5581 if (!write_zeros (abfd
, off
, adjust
))
5585 p
->p_filesz
+= adjust
;
5589 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
5591 /* The section at i == 0 is the one that actually contains
5595 this_hdr
->sh_offset
= sec
->filepos
= off
;
5596 off
+= this_hdr
->sh_size
;
5597 p
->p_filesz
= this_hdr
->sh_size
;
5603 /* The rest are fake sections that shouldn't be written. */
5612 if (p
->p_type
== PT_LOAD
)
5614 this_hdr
->sh_offset
= sec
->filepos
= off
;
5615 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5616 off
+= this_hdr
->sh_size
;
5618 else if (this_hdr
->sh_type
== SHT_NOBITS
5619 && (this_hdr
->sh_flags
& SHF_TLS
) != 0
5620 && this_hdr
->sh_offset
== 0)
5622 /* This is a .tbss section that didn't get a PT_LOAD.
5623 (See _bfd_elf_map_sections_to_segments "Create a
5624 final PT_LOAD".) Set sh_offset to the value it
5625 would have if we had created a zero p_filesz and
5626 p_memsz PT_LOAD header for the section. This
5627 also makes the PT_TLS header have the same
5629 bfd_vma adjust
= vma_page_aligned_bias (this_hdr
->sh_addr
,
5631 this_hdr
->sh_offset
= sec
->filepos
= off
+ adjust
;
5634 if (this_hdr
->sh_type
!= SHT_NOBITS
)
5636 p
->p_filesz
+= this_hdr
->sh_size
;
5637 /* A load section without SHF_ALLOC is something like
5638 a note section in a PT_NOTE segment. These take
5639 file space but are not loaded into memory. */
5640 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5641 p
->p_memsz
+= this_hdr
->sh_size
;
5643 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
5645 if (p
->p_type
== PT_TLS
)
5646 p
->p_memsz
+= this_hdr
->sh_size
;
5648 /* .tbss is special. It doesn't contribute to p_memsz of
5650 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
5651 p
->p_memsz
+= this_hdr
->sh_size
;
5654 if (align
> p
->p_align
5655 && !m
->p_align_valid
5656 && (p
->p_type
!= PT_LOAD
5657 || (abfd
->flags
& D_PAGED
) == 0))
5661 if (!m
->p_flags_valid
)
5664 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
5666 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
5673 /* Check that all sections are in a PT_LOAD segment.
5674 Don't check funky gdb generated core files. */
5675 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
5677 bfd_boolean check_vma
= TRUE
;
5679 for (i
= 1; i
< m
->count
; i
++)
5680 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
5681 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
5682 ->this_hdr
), p
) != 0
5683 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
5684 ->this_hdr
), p
) != 0)
5686 /* Looks like we have overlays packed into the segment. */
5691 for (i
= 0; i
< m
->count
; i
++)
5693 Elf_Internal_Shdr
*this_hdr
;
5696 sec
= m
->sections
[i
];
5697 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
5698 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0)
5699 && !ELF_TBSS_SPECIAL (this_hdr
, p
))
5702 /* xgettext:c-format */
5703 (_("%B: section `%A' can't be allocated in segment %d"),
5705 print_segment_map (m
);
5711 elf_next_file_pos (abfd
) = off
;
5715 /* Assign file positions for the other sections. */
5718 assign_file_positions_for_non_load_sections (bfd
*abfd
,
5719 struct bfd_link_info
*link_info
)
5721 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5722 Elf_Internal_Shdr
**i_shdrpp
;
5723 Elf_Internal_Shdr
**hdrpp
, **end_hdrpp
;
5724 Elf_Internal_Phdr
*phdrs
;
5725 Elf_Internal_Phdr
*p
;
5726 struct elf_segment_map
*m
;
5727 struct elf_segment_map
*hdrs_segment
;
5728 bfd_vma filehdr_vaddr
, filehdr_paddr
;
5729 bfd_vma phdrs_vaddr
, phdrs_paddr
;
5733 i_shdrpp
= elf_elfsections (abfd
);
5734 end_hdrpp
= i_shdrpp
+ elf_numsections (abfd
);
5735 off
= elf_next_file_pos (abfd
);
5736 for (hdrpp
= i_shdrpp
+ 1; hdrpp
< end_hdrpp
; hdrpp
++)
5738 Elf_Internal_Shdr
*hdr
;
5741 if (hdr
->bfd_section
!= NULL
5742 && (hdr
->bfd_section
->filepos
!= 0
5743 || (hdr
->sh_type
== SHT_NOBITS
5744 && hdr
->contents
== NULL
)))
5745 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
5746 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
5748 if (hdr
->sh_size
!= 0)
5750 /* xgettext:c-format */
5751 (_("%B: warning: allocated section `%s' not in segment"),
5753 (hdr
->bfd_section
== NULL
5755 : hdr
->bfd_section
->name
));
5756 /* We don't need to page align empty sections. */
5757 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
5758 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5761 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
5763 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
5766 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
5767 && hdr
->bfd_section
== NULL
)
5768 || (hdr
->bfd_section
!= NULL
5769 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
5770 /* Compress DWARF debug sections. */
5771 || hdr
== i_shdrpp
[elf_onesymtab (abfd
)]
5772 || (elf_symtab_shndx_list (abfd
) != NULL
5773 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
5774 || hdr
== i_shdrpp
[elf_strtab_sec (abfd
)]
5775 || hdr
== i_shdrpp
[elf_shstrtab_sec (abfd
)])
5776 hdr
->sh_offset
= -1;
5778 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
5781 /* Now that we have set the section file positions, we can set up
5782 the file positions for the non PT_LOAD segments. */
5786 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
5788 hdrs_segment
= NULL
;
5789 phdrs
= elf_tdata (abfd
)->phdr
;
5790 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5793 if (p
->p_type
!= PT_LOAD
)
5796 if (m
->includes_filehdr
)
5798 filehdr_vaddr
= p
->p_vaddr
;
5799 filehdr_paddr
= p
->p_paddr
;
5801 if (m
->includes_phdrs
)
5803 phdrs_vaddr
= p
->p_vaddr
;
5804 phdrs_paddr
= p
->p_paddr
;
5805 if (m
->includes_filehdr
)
5808 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
5809 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
5814 if (hdrs_segment
!= NULL
&& link_info
!= NULL
)
5816 /* There is a segment that contains both the file headers and the
5817 program headers, so provide a symbol __ehdr_start pointing there.
5818 A program can use this to examine itself robustly. */
5820 struct elf_link_hash_entry
*hash
5821 = elf_link_hash_lookup (elf_hash_table (link_info
), "__ehdr_start",
5822 FALSE
, FALSE
, TRUE
);
5823 /* If the symbol was referenced and not defined, define it. */
5825 && (hash
->root
.type
== bfd_link_hash_new
5826 || hash
->root
.type
== bfd_link_hash_undefined
5827 || hash
->root
.type
== bfd_link_hash_undefweak
5828 || hash
->root
.type
== bfd_link_hash_common
))
5831 if (hdrs_segment
->count
!= 0)
5832 /* The segment contains sections, so use the first one. */
5833 s
= hdrs_segment
->sections
[0];
5835 /* Use the first (i.e. lowest-addressed) section in any segment. */
5836 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5845 hash
->root
.u
.def
.value
= filehdr_vaddr
- s
->vma
;
5846 hash
->root
.u
.def
.section
= s
;
5850 hash
->root
.u
.def
.value
= filehdr_vaddr
;
5851 hash
->root
.u
.def
.section
= bfd_abs_section_ptr
;
5854 hash
->root
.type
= bfd_link_hash_defined
;
5855 hash
->def_regular
= 1;
5860 for (m
= elf_seg_map (abfd
), p
= phdrs
; m
!= NULL
; m
= m
->next
, p
++)
5862 if (p
->p_type
== PT_GNU_RELRO
)
5866 if (link_info
!= NULL
)
5868 /* During linking the range of the RELRO segment is passed
5869 in link_info. Note that there may be padding between
5870 relro_start and the first RELRO section. */
5871 start
= link_info
->relro_start
;
5872 end
= link_info
->relro_end
;
5874 else if (m
->count
!= 0)
5876 if (!m
->p_size_valid
)
5878 start
= m
->sections
[0]->vma
;
5879 end
= start
+ m
->p_size
;
5889 struct elf_segment_map
*lm
;
5890 const Elf_Internal_Phdr
*lp
;
5893 /* Find a LOAD segment containing a section in the RELRO
5895 for (lm
= elf_seg_map (abfd
), lp
= phdrs
;
5897 lm
= lm
->next
, lp
++)
5899 if (lp
->p_type
== PT_LOAD
5902 && lm
->sections
[lm
->count
- 1]->vma
>= start
5903 && lm
->sections
[0]->vma
< end
)
5906 BFD_ASSERT (lm
!= NULL
);
5908 /* Find the section starting the RELRO segment. */
5909 for (i
= 0; i
< lm
->count
; i
++)
5911 asection
*s
= lm
->sections
[i
];
5917 BFD_ASSERT (i
< lm
->count
);
5919 p
->p_vaddr
= lm
->sections
[i
]->vma
;
5920 p
->p_paddr
= lm
->sections
[i
]->lma
;
5921 p
->p_offset
= lm
->sections
[i
]->filepos
;
5922 p
->p_memsz
= end
- p
->p_vaddr
;
5923 p
->p_filesz
= p
->p_memsz
;
5925 /* The RELRO segment typically ends a few bytes into
5926 .got.plt but other layouts are possible. In cases
5927 where the end does not match any loaded section (for
5928 instance is in file padding), trim p_filesz back to
5929 correspond to the end of loaded section contents. */
5930 if (p
->p_filesz
> lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
)
5931 p
->p_filesz
= lp
->p_vaddr
+ lp
->p_filesz
- p
->p_vaddr
;
5933 /* Preserve the alignment and flags if they are valid. The
5934 gold linker generates RW/4 for the PT_GNU_RELRO section.
5935 It is better for objcopy/strip to honor these attributes
5936 otherwise gdb will choke when using separate debug files.
5938 if (!m
->p_align_valid
)
5940 if (!m
->p_flags_valid
)
5945 memset (p
, 0, sizeof *p
);
5946 p
->p_type
= PT_NULL
;
5949 else if (p
->p_type
== PT_GNU_STACK
)
5951 if (m
->p_size_valid
)
5952 p
->p_memsz
= m
->p_size
;
5954 else if (m
->count
!= 0)
5958 if (p
->p_type
!= PT_LOAD
5959 && (p
->p_type
!= PT_NOTE
5960 || bfd_get_format (abfd
) != bfd_core
))
5962 /* A user specified segment layout may include a PHDR
5963 segment that overlaps with a LOAD segment... */
5964 if (p
->p_type
== PT_PHDR
)
5970 if (m
->includes_filehdr
|| m
->includes_phdrs
)
5972 /* PR 17512: file: 2195325e. */
5974 (_("%B: error: non-load segment %d includes file header "
5975 "and/or program header"),
5976 abfd
, (int) (p
- phdrs
));
5981 p
->p_offset
= m
->sections
[0]->filepos
;
5982 for (i
= m
->count
; i
-- != 0;)
5984 asection
*sect
= m
->sections
[i
];
5985 Elf_Internal_Shdr
*hdr
= &elf_section_data (sect
)->this_hdr
;
5986 if (hdr
->sh_type
!= SHT_NOBITS
)
5988 p
->p_filesz
= (sect
->filepos
- m
->sections
[0]->filepos
5995 else if (m
->includes_filehdr
)
5997 p
->p_vaddr
= filehdr_vaddr
;
5998 if (! m
->p_paddr_valid
)
5999 p
->p_paddr
= filehdr_paddr
;
6001 else if (m
->includes_phdrs
)
6003 p
->p_vaddr
= phdrs_vaddr
;
6004 if (! m
->p_paddr_valid
)
6005 p
->p_paddr
= phdrs_paddr
;
6009 elf_next_file_pos (abfd
) = off
;
6014 static elf_section_list
*
6015 find_section_in_list (unsigned int i
, elf_section_list
* list
)
6017 for (;list
!= NULL
; list
= list
->next
)
6023 /* Work out the file positions of all the sections. This is called by
6024 _bfd_elf_compute_section_file_positions. All the section sizes and
6025 VMAs must be known before this is called.
6027 Reloc sections come in two flavours: Those processed specially as
6028 "side-channel" data attached to a section to which they apply, and
6029 those that bfd doesn't process as relocations. The latter sort are
6030 stored in a normal bfd section by bfd_section_from_shdr. We don't
6031 consider the former sort here, unless they form part of the loadable
6032 image. Reloc sections not assigned here will be handled later by
6033 assign_file_positions_for_relocs.
6035 We also don't set the positions of the .symtab and .strtab here. */
6038 assign_file_positions_except_relocs (bfd
*abfd
,
6039 struct bfd_link_info
*link_info
)
6041 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
6042 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
6043 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6045 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
6046 && bfd_get_format (abfd
) != bfd_core
)
6048 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
6049 unsigned int num_sec
= elf_numsections (abfd
);
6050 Elf_Internal_Shdr
**hdrpp
;
6054 /* Start after the ELF header. */
6055 off
= i_ehdrp
->e_ehsize
;
6057 /* We are not creating an executable, which means that we are
6058 not creating a program header, and that the actual order of
6059 the sections in the file is unimportant. */
6060 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
6062 Elf_Internal_Shdr
*hdr
;
6065 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
6066 && hdr
->bfd_section
== NULL
)
6067 || (hdr
->bfd_section
!= NULL
6068 && (hdr
->bfd_section
->flags
& SEC_ELF_COMPRESS
))
6069 /* Compress DWARF debug sections. */
6070 || i
== elf_onesymtab (abfd
)
6071 || (elf_symtab_shndx_list (abfd
) != NULL
6072 && hdr
== i_shdrpp
[elf_symtab_shndx_list (abfd
)->ndx
])
6073 || i
== elf_strtab_sec (abfd
)
6074 || i
== elf_shstrtab_sec (abfd
))
6076 hdr
->sh_offset
= -1;
6079 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
6082 elf_next_file_pos (abfd
) = off
;
6088 /* Assign file positions for the loaded sections based on the
6089 assignment of sections to segments. */
6090 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
6093 /* And for non-load sections. */
6094 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
6097 if (bed
->elf_backend_modify_program_headers
!= NULL
)
6099 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
6103 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
6104 if (link_info
!= NULL
&& bfd_link_pie (link_info
))
6106 unsigned int num_segments
= elf_elfheader (abfd
)->e_phnum
;
6107 Elf_Internal_Phdr
*segment
= elf_tdata (abfd
)->phdr
;
6108 Elf_Internal_Phdr
*end_segment
= &segment
[num_segments
];
6110 /* Find the lowest p_vaddr in PT_LOAD segments. */
6111 bfd_vma p_vaddr
= (bfd_vma
) -1;
6112 for (; segment
< end_segment
; segment
++)
6113 if (segment
->p_type
== PT_LOAD
&& p_vaddr
> segment
->p_vaddr
)
6114 p_vaddr
= segment
->p_vaddr
;
6116 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
6117 segments is non-zero. */
6119 i_ehdrp
->e_type
= ET_EXEC
;
6122 /* Write out the program headers. */
6123 alloc
= elf_program_header_size (abfd
) / bed
->s
->sizeof_phdr
;
6125 /* Sort the program headers into the ordering required by the ELF standard. */
6129 /* PR ld/20815 - Check that the program header segment, if present, will
6130 be loaded into memory. FIXME: The check below is not sufficient as
6131 really all PT_LOAD segments should be checked before issuing an error
6132 message. Plus the PHDR segment does not have to be the first segment
6133 in the program header table. But this version of the check should
6134 catch all real world use cases.
6136 FIXME: We used to have code here to sort the PT_LOAD segments into
6137 ascending order, as per the ELF spec. But this breaks some programs,
6138 including the Linux kernel. But really either the spec should be
6139 changed or the programs updated. */
6141 && tdata
->phdr
[0].p_type
== PT_PHDR
6142 && (bed
->elf_backend_allow_non_load_phdr
== NULL
6143 || !bed
->elf_backend_allow_non_load_phdr (abfd
, tdata
->phdr
,
6145 && tdata
->phdr
[1].p_type
== PT_LOAD
6146 && (tdata
->phdr
[1].p_vaddr
> tdata
->phdr
[0].p_vaddr
6147 || (tdata
->phdr
[1].p_vaddr
+ tdata
->phdr
[1].p_memsz
)
6148 < (tdata
->phdr
[0].p_vaddr
+ tdata
->phdr
[0].p_memsz
)))
6150 /* The fix for this error is usually to edit the linker script being
6151 used and set up the program headers manually. Either that or
6152 leave room for the headers at the start of the SECTIONS. */
6153 _bfd_error_handler (_("\
6154 %B: error: PHDR segment not covered by LOAD segment"),
6159 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
6160 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
6168 prep_headers (bfd
*abfd
)
6170 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
6171 struct elf_strtab_hash
*shstrtab
;
6172 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6174 i_ehdrp
= elf_elfheader (abfd
);
6176 shstrtab
= _bfd_elf_strtab_init ();
6177 if (shstrtab
== NULL
)
6180 elf_shstrtab (abfd
) = shstrtab
;
6182 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
6183 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
6184 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
6185 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
6187 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
6188 i_ehdrp
->e_ident
[EI_DATA
] =
6189 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
6190 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
6192 if ((abfd
->flags
& DYNAMIC
) != 0)
6193 i_ehdrp
->e_type
= ET_DYN
;
6194 else if ((abfd
->flags
& EXEC_P
) != 0)
6195 i_ehdrp
->e_type
= ET_EXEC
;
6196 else if (bfd_get_format (abfd
) == bfd_core
)
6197 i_ehdrp
->e_type
= ET_CORE
;
6199 i_ehdrp
->e_type
= ET_REL
;
6201 switch (bfd_get_arch (abfd
))
6203 case bfd_arch_unknown
:
6204 i_ehdrp
->e_machine
= EM_NONE
;
6207 /* There used to be a long list of cases here, each one setting
6208 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
6209 in the corresponding bfd definition. To avoid duplication,
6210 the switch was removed. Machines that need special handling
6211 can generally do it in elf_backend_final_write_processing(),
6212 unless they need the information earlier than the final write.
6213 Such need can generally be supplied by replacing the tests for
6214 e_machine with the conditions used to determine it. */
6216 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
6219 i_ehdrp
->e_version
= bed
->s
->ev_current
;
6220 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
6222 /* No program header, for now. */
6223 i_ehdrp
->e_phoff
= 0;
6224 i_ehdrp
->e_phentsize
= 0;
6225 i_ehdrp
->e_phnum
= 0;
6227 /* Each bfd section is section header entry. */
6228 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
6229 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
6231 /* If we're building an executable, we'll need a program header table. */
6232 if (abfd
->flags
& EXEC_P
)
6233 /* It all happens later. */
6237 i_ehdrp
->e_phentsize
= 0;
6238 i_ehdrp
->e_phoff
= 0;
6241 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
6242 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
6243 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
6244 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
6245 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
6246 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
6247 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
6248 || elf_tdata (abfd
)->strtab_hdr
.sh_name
== (unsigned int) -1
6249 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
6255 /* Assign file positions for all the reloc sections which are not part
6256 of the loadable file image, and the file position of section headers. */
6259 _bfd_elf_assign_file_positions_for_non_load (bfd
*abfd
)
6262 Elf_Internal_Shdr
**shdrpp
, **end_shdrpp
;
6263 Elf_Internal_Shdr
*shdrp
;
6264 Elf_Internal_Ehdr
*i_ehdrp
;
6265 const struct elf_backend_data
*bed
;
6267 off
= elf_next_file_pos (abfd
);
6269 shdrpp
= elf_elfsections (abfd
);
6270 end_shdrpp
= shdrpp
+ elf_numsections (abfd
);
6271 for (shdrpp
++; shdrpp
< end_shdrpp
; shdrpp
++)
6274 if (shdrp
->sh_offset
== -1)
6276 asection
*sec
= shdrp
->bfd_section
;
6277 bfd_boolean is_rel
= (shdrp
->sh_type
== SHT_REL
6278 || shdrp
->sh_type
== SHT_RELA
);
6280 || (sec
!= NULL
&& (sec
->flags
& SEC_ELF_COMPRESS
)))
6284 const char *name
= sec
->name
;
6285 struct bfd_elf_section_data
*d
;
6287 /* Compress DWARF debug sections. */
6288 if (!bfd_compress_section (abfd
, sec
,
6292 if (sec
->compress_status
== COMPRESS_SECTION_DONE
6293 && (abfd
->flags
& BFD_COMPRESS_GABI
) == 0)
6295 /* If section is compressed with zlib-gnu, convert
6296 section name from .debug_* to .zdebug_*. */
6298 = convert_debug_to_zdebug (abfd
, name
);
6299 if (new_name
== NULL
)
6303 /* Add section name to section name section. */
6304 if (shdrp
->sh_name
!= (unsigned int) -1)
6307 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
6309 d
= elf_section_data (sec
);
6311 /* Add reloc section name to section name section. */
6313 && !_bfd_elf_set_reloc_sh_name (abfd
,
6318 && !_bfd_elf_set_reloc_sh_name (abfd
,
6323 /* Update section size and contents. */
6324 shdrp
->sh_size
= sec
->size
;
6325 shdrp
->contents
= sec
->contents
;
6326 shdrp
->bfd_section
->contents
= NULL
;
6328 off
= _bfd_elf_assign_file_position_for_section (shdrp
,
6335 /* Place section name section after DWARF debug sections have been
6337 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
6338 shdrp
= &elf_tdata (abfd
)->shstrtab_hdr
;
6339 shdrp
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
6340 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
6342 /* Place the section headers. */
6343 i_ehdrp
= elf_elfheader (abfd
);
6344 bed
= get_elf_backend_data (abfd
);
6345 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
6346 i_ehdrp
->e_shoff
= off
;
6347 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
6348 elf_next_file_pos (abfd
) = off
;
6354 _bfd_elf_write_object_contents (bfd
*abfd
)
6356 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6357 Elf_Internal_Shdr
**i_shdrp
;
6359 unsigned int count
, num_sec
;
6360 struct elf_obj_tdata
*t
;
6362 if (! abfd
->output_has_begun
6363 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
6366 i_shdrp
= elf_elfsections (abfd
);
6369 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
6373 if (!_bfd_elf_assign_file_positions_for_non_load (abfd
))
6376 /* After writing the headers, we need to write the sections too... */
6377 num_sec
= elf_numsections (abfd
);
6378 for (count
= 1; count
< num_sec
; count
++)
6380 i_shdrp
[count
]->sh_name
6381 = _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
6382 i_shdrp
[count
]->sh_name
);
6383 if (bed
->elf_backend_section_processing
)
6384 if (!(*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]))
6386 if (i_shdrp
[count
]->contents
)
6388 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
6390 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
6391 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
6396 /* Write out the section header names. */
6397 t
= elf_tdata (abfd
);
6398 if (elf_shstrtab (abfd
) != NULL
6399 && (bfd_seek (abfd
, t
->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
6400 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
6403 if (bed
->elf_backend_final_write_processing
)
6404 (*bed
->elf_backend_final_write_processing
) (abfd
, elf_linker (abfd
));
6406 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
6409 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
6410 if (t
->o
->build_id
.after_write_object_contents
!= NULL
)
6411 return (*t
->o
->build_id
.after_write_object_contents
) (abfd
);
6417 _bfd_elf_write_corefile_contents (bfd
*abfd
)
6419 /* Hopefully this can be done just like an object file. */
6420 return _bfd_elf_write_object_contents (abfd
);
6423 /* Given a section, search the header to find them. */
6426 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
6428 const struct elf_backend_data
*bed
;
6429 unsigned int sec_index
;
6431 if (elf_section_data (asect
) != NULL
6432 && elf_section_data (asect
)->this_idx
!= 0)
6433 return elf_section_data (asect
)->this_idx
;
6435 if (bfd_is_abs_section (asect
))
6436 sec_index
= SHN_ABS
;
6437 else if (bfd_is_com_section (asect
))
6438 sec_index
= SHN_COMMON
;
6439 else if (bfd_is_und_section (asect
))
6440 sec_index
= SHN_UNDEF
;
6442 sec_index
= SHN_BAD
;
6444 bed
= get_elf_backend_data (abfd
);
6445 if (bed
->elf_backend_section_from_bfd_section
)
6447 int retval
= sec_index
;
6449 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
6453 if (sec_index
== SHN_BAD
)
6454 bfd_set_error (bfd_error_nonrepresentable_section
);
6459 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
6463 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
6465 asymbol
*asym_ptr
= *asym_ptr_ptr
;
6467 flagword flags
= asym_ptr
->flags
;
6469 /* When gas creates relocations against local labels, it creates its
6470 own symbol for the section, but does put the symbol into the
6471 symbol chain, so udata is 0. When the linker is generating
6472 relocatable output, this section symbol may be for one of the
6473 input sections rather than the output section. */
6474 if (asym_ptr
->udata
.i
== 0
6475 && (flags
& BSF_SECTION_SYM
)
6476 && asym_ptr
->section
)
6481 sec
= asym_ptr
->section
;
6482 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
6483 sec
= sec
->output_section
;
6484 if (sec
->owner
== abfd
6485 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
6486 && elf_section_syms (abfd
)[indx
] != NULL
)
6487 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
6490 idx
= asym_ptr
->udata
.i
;
6494 /* This case can occur when using --strip-symbol on a symbol
6495 which is used in a relocation entry. */
6497 /* xgettext:c-format */
6498 (_("%B: symbol `%s' required but not present"),
6499 abfd
, bfd_asymbol_name (asym_ptr
));
6500 bfd_set_error (bfd_error_no_symbols
);
6507 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8x\n",
6508 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
);
6516 /* Rewrite program header information. */
6519 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
6521 Elf_Internal_Ehdr
*iehdr
;
6522 struct elf_segment_map
*map
;
6523 struct elf_segment_map
*map_first
;
6524 struct elf_segment_map
**pointer_to_map
;
6525 Elf_Internal_Phdr
*segment
;
6528 unsigned int num_segments
;
6529 bfd_boolean phdr_included
= FALSE
;
6530 bfd_boolean p_paddr_valid
;
6531 bfd_vma maxpagesize
;
6532 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
6533 unsigned int phdr_adjust_num
= 0;
6534 const struct elf_backend_data
*bed
;
6536 bed
= get_elf_backend_data (ibfd
);
6537 iehdr
= elf_elfheader (ibfd
);
6540 pointer_to_map
= &map_first
;
6542 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6543 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
6545 /* Returns the end address of the segment + 1. */
6546 #define SEGMENT_END(segment, start) \
6547 (start + (segment->p_memsz > segment->p_filesz \
6548 ? segment->p_memsz : segment->p_filesz))
6550 #define SECTION_SIZE(section, segment) \
6551 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
6552 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
6553 ? section->size : 0)
6555 /* Returns TRUE if the given section is contained within
6556 the given segment. VMA addresses are compared. */
6557 #define IS_CONTAINED_BY_VMA(section, segment) \
6558 (section->vma >= segment->p_vaddr \
6559 && (section->vma + SECTION_SIZE (section, segment) \
6560 <= (SEGMENT_END (segment, segment->p_vaddr))))
6562 /* Returns TRUE if the given section is contained within
6563 the given segment. LMA addresses are compared. */
6564 #define IS_CONTAINED_BY_LMA(section, segment, base) \
6565 (section->lma >= base \
6566 && (section->lma + SECTION_SIZE (section, segment) \
6567 <= SEGMENT_END (segment, base)))
6569 /* Handle PT_NOTE segment. */
6570 #define IS_NOTE(p, s) \
6571 (p->p_type == PT_NOTE \
6572 && elf_section_type (s) == SHT_NOTE \
6573 && (bfd_vma) s->filepos >= p->p_offset \
6574 && ((bfd_vma) s->filepos + s->size \
6575 <= p->p_offset + p->p_filesz))
6577 /* Special case: corefile "NOTE" section containing regs, prpsinfo
6579 #define IS_COREFILE_NOTE(p, s) \
6581 && bfd_get_format (ibfd) == bfd_core \
6585 /* The complicated case when p_vaddr is 0 is to handle the Solaris
6586 linker, which generates a PT_INTERP section with p_vaddr and
6587 p_memsz set to 0. */
6588 #define IS_SOLARIS_PT_INTERP(p, s) \
6590 && p->p_paddr == 0 \
6591 && p->p_memsz == 0 \
6592 && p->p_filesz > 0 \
6593 && (s->flags & SEC_HAS_CONTENTS) != 0 \
6595 && (bfd_vma) s->filepos >= p->p_offset \
6596 && ((bfd_vma) s->filepos + s->size \
6597 <= p->p_offset + p->p_filesz))
6599 /* Decide if the given section should be included in the given segment.
6600 A section will be included if:
6601 1. It is within the address space of the segment -- we use the LMA
6602 if that is set for the segment and the VMA otherwise,
6603 2. It is an allocated section or a NOTE section in a PT_NOTE
6605 3. There is an output section associated with it,
6606 4. The section has not already been allocated to a previous segment.
6607 5. PT_GNU_STACK segments do not include any sections.
6608 6. PT_TLS segment includes only SHF_TLS sections.
6609 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
6610 8. PT_DYNAMIC should not contain empty sections at the beginning
6611 (with the possible exception of .dynamic). */
6612 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
6613 ((((segment->p_paddr \
6614 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
6615 : IS_CONTAINED_BY_VMA (section, segment)) \
6616 && (section->flags & SEC_ALLOC) != 0) \
6617 || IS_NOTE (segment, section)) \
6618 && segment->p_type != PT_GNU_STACK \
6619 && (segment->p_type != PT_TLS \
6620 || (section->flags & SEC_THREAD_LOCAL)) \
6621 && (segment->p_type == PT_LOAD \
6622 || segment->p_type == PT_TLS \
6623 || (section->flags & SEC_THREAD_LOCAL) == 0) \
6624 && (segment->p_type != PT_DYNAMIC \
6625 || SECTION_SIZE (section, segment) > 0 \
6626 || (segment->p_paddr \
6627 ? segment->p_paddr != section->lma \
6628 : segment->p_vaddr != section->vma) \
6629 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
6631 && !section->segment_mark)
6633 /* If the output section of a section in the input segment is NULL,
6634 it is removed from the corresponding output segment. */
6635 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
6636 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
6637 && section->output_section != NULL)
6639 /* Returns TRUE iff seg1 starts after the end of seg2. */
6640 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
6641 (seg1->field >= SEGMENT_END (seg2, seg2->field))
6643 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
6644 their VMA address ranges and their LMA address ranges overlap.
6645 It is possible to have overlapping VMA ranges without overlapping LMA
6646 ranges. RedBoot images for example can have both .data and .bss mapped
6647 to the same VMA range, but with the .data section mapped to a different
6649 #define SEGMENT_OVERLAPS(seg1, seg2) \
6650 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
6651 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
6652 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
6653 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
6655 /* Initialise the segment mark field. */
6656 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
6657 section
->segment_mark
= FALSE
;
6659 /* The Solaris linker creates program headers in which all the
6660 p_paddr fields are zero. When we try to objcopy or strip such a
6661 file, we get confused. Check for this case, and if we find it
6662 don't set the p_paddr_valid fields. */
6663 p_paddr_valid
= FALSE
;
6664 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6667 if (segment
->p_paddr
!= 0)
6669 p_paddr_valid
= TRUE
;
6673 /* Scan through the segments specified in the program header
6674 of the input BFD. For this first scan we look for overlaps
6675 in the loadable segments. These can be created by weird
6676 parameters to objcopy. Also, fix some solaris weirdness. */
6677 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6682 Elf_Internal_Phdr
*segment2
;
6684 if (segment
->p_type
== PT_INTERP
)
6685 for (section
= ibfd
->sections
; section
; section
= section
->next
)
6686 if (IS_SOLARIS_PT_INTERP (segment
, section
))
6688 /* Mininal change so that the normal section to segment
6689 assignment code will work. */
6690 segment
->p_vaddr
= section
->vma
;
6694 if (segment
->p_type
!= PT_LOAD
)
6696 /* Remove PT_GNU_RELRO segment. */
6697 if (segment
->p_type
== PT_GNU_RELRO
)
6698 segment
->p_type
= PT_NULL
;
6702 /* Determine if this segment overlaps any previous segments. */
6703 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
6705 bfd_signed_vma extra_length
;
6707 if (segment2
->p_type
!= PT_LOAD
6708 || !SEGMENT_OVERLAPS (segment
, segment2
))
6711 /* Merge the two segments together. */
6712 if (segment2
->p_vaddr
< segment
->p_vaddr
)
6714 /* Extend SEGMENT2 to include SEGMENT and then delete
6716 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
6717 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
6719 if (extra_length
> 0)
6721 segment2
->p_memsz
+= extra_length
;
6722 segment2
->p_filesz
+= extra_length
;
6725 segment
->p_type
= PT_NULL
;
6727 /* Since we have deleted P we must restart the outer loop. */
6729 segment
= elf_tdata (ibfd
)->phdr
;
6734 /* Extend SEGMENT to include SEGMENT2 and then delete
6736 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
6737 - SEGMENT_END (segment
, segment
->p_vaddr
));
6739 if (extra_length
> 0)
6741 segment
->p_memsz
+= extra_length
;
6742 segment
->p_filesz
+= extra_length
;
6745 segment2
->p_type
= PT_NULL
;
6750 /* The second scan attempts to assign sections to segments. */
6751 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6755 unsigned int section_count
;
6756 asection
**sections
;
6757 asection
*output_section
;
6759 bfd_vma matching_lma
;
6760 bfd_vma suggested_lma
;
6763 asection
*first_section
;
6764 bfd_boolean first_matching_lma
;
6765 bfd_boolean first_suggested_lma
;
6767 if (segment
->p_type
== PT_NULL
)
6770 first_section
= NULL
;
6771 /* Compute how many sections might be placed into this segment. */
6772 for (section
= ibfd
->sections
, section_count
= 0;
6774 section
= section
->next
)
6776 /* Find the first section in the input segment, which may be
6777 removed from the corresponding output segment. */
6778 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
6780 if (first_section
== NULL
)
6781 first_section
= section
;
6782 if (section
->output_section
!= NULL
)
6787 /* Allocate a segment map big enough to contain
6788 all of the sections we have selected. */
6789 amt
= sizeof (struct elf_segment_map
);
6790 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
6791 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
6795 /* Initialise the fields of the segment map. Default to
6796 using the physical address of the segment in the input BFD. */
6798 map
->p_type
= segment
->p_type
;
6799 map
->p_flags
= segment
->p_flags
;
6800 map
->p_flags_valid
= 1;
6802 /* If the first section in the input segment is removed, there is
6803 no need to preserve segment physical address in the corresponding
6805 if (!first_section
|| first_section
->output_section
!= NULL
)
6807 map
->p_paddr
= segment
->p_paddr
;
6808 map
->p_paddr_valid
= p_paddr_valid
;
6811 /* Determine if this segment contains the ELF file header
6812 and if it contains the program headers themselves. */
6813 map
->includes_filehdr
= (segment
->p_offset
== 0
6814 && segment
->p_filesz
>= iehdr
->e_ehsize
);
6815 map
->includes_phdrs
= 0;
6817 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
6819 map
->includes_phdrs
=
6820 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
6821 && (segment
->p_offset
+ segment
->p_filesz
6822 >= ((bfd_vma
) iehdr
->e_phoff
6823 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
6825 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
6826 phdr_included
= TRUE
;
6829 if (section_count
== 0)
6831 /* Special segments, such as the PT_PHDR segment, may contain
6832 no sections, but ordinary, loadable segments should contain
6833 something. They are allowed by the ELF spec however, so only
6834 a warning is produced.
6835 There is however the valid use case of embedded systems which
6836 have segments with p_filesz of 0 and a p_memsz > 0 to initialize
6837 flash memory with zeros. No warning is shown for that case. */
6838 if (segment
->p_type
== PT_LOAD
6839 && (segment
->p_filesz
> 0 || segment
->p_memsz
== 0))
6840 /* xgettext:c-format */
6841 _bfd_error_handler (_("%B: warning: Empty loadable segment detected"
6842 " at vaddr=%#Lx, is this intentional?"),
6843 ibfd
, segment
->p_vaddr
);
6846 *pointer_to_map
= map
;
6847 pointer_to_map
= &map
->next
;
6852 /* Now scan the sections in the input BFD again and attempt
6853 to add their corresponding output sections to the segment map.
6854 The problem here is how to handle an output section which has
6855 been moved (ie had its LMA changed). There are four possibilities:
6857 1. None of the sections have been moved.
6858 In this case we can continue to use the segment LMA from the
6861 2. All of the sections have been moved by the same amount.
6862 In this case we can change the segment's LMA to match the LMA
6863 of the first section.
6865 3. Some of the sections have been moved, others have not.
6866 In this case those sections which have not been moved can be
6867 placed in the current segment which will have to have its size,
6868 and possibly its LMA changed, and a new segment or segments will
6869 have to be created to contain the other sections.
6871 4. The sections have been moved, but not by the same amount.
6872 In this case we can change the segment's LMA to match the LMA
6873 of the first section and we will have to create a new segment
6874 or segments to contain the other sections.
6876 In order to save time, we allocate an array to hold the section
6877 pointers that we are interested in. As these sections get assigned
6878 to a segment, they are removed from this array. */
6880 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
6881 if (sections
== NULL
)
6884 /* Step One: Scan for segment vs section LMA conflicts.
6885 Also add the sections to the section array allocated above.
6886 Also add the sections to the current segment. In the common
6887 case, where the sections have not been moved, this means that
6888 we have completely filled the segment, and there is nothing
6893 first_matching_lma
= TRUE
;
6894 first_suggested_lma
= TRUE
;
6896 for (section
= first_section
, j
= 0;
6898 section
= section
->next
)
6900 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
6902 output_section
= section
->output_section
;
6904 sections
[j
++] = section
;
6906 /* The Solaris native linker always sets p_paddr to 0.
6907 We try to catch that case here, and set it to the
6908 correct value. Note - some backends require that
6909 p_paddr be left as zero. */
6911 && segment
->p_vaddr
!= 0
6912 && !bed
->want_p_paddr_set_to_zero
6914 && output_section
->lma
!= 0
6915 && output_section
->vma
== (segment
->p_vaddr
6916 + (map
->includes_filehdr
6919 + (map
->includes_phdrs
6921 * iehdr
->e_phentsize
)
6923 map
->p_paddr
= segment
->p_vaddr
;
6925 /* Match up the physical address of the segment with the
6926 LMA address of the output section. */
6927 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
6928 || IS_COREFILE_NOTE (segment
, section
)
6929 || (bed
->want_p_paddr_set_to_zero
6930 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
6932 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
6934 matching_lma
= output_section
->lma
;
6935 first_matching_lma
= FALSE
;
6938 /* We assume that if the section fits within the segment
6939 then it does not overlap any other section within that
6941 map
->sections
[isec
++] = output_section
;
6943 else if (first_suggested_lma
)
6945 suggested_lma
= output_section
->lma
;
6946 first_suggested_lma
= FALSE
;
6949 if (j
== section_count
)
6954 BFD_ASSERT (j
== section_count
);
6956 /* Step Two: Adjust the physical address of the current segment,
6958 if (isec
== section_count
)
6960 /* All of the sections fitted within the segment as currently
6961 specified. This is the default case. Add the segment to
6962 the list of built segments and carry on to process the next
6963 program header in the input BFD. */
6964 map
->count
= section_count
;
6965 *pointer_to_map
= map
;
6966 pointer_to_map
= &map
->next
;
6969 && !bed
->want_p_paddr_set_to_zero
6970 && matching_lma
!= map
->p_paddr
6971 && !map
->includes_filehdr
6972 && !map
->includes_phdrs
)
6973 /* There is some padding before the first section in the
6974 segment. So, we must account for that in the output
6976 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
6983 if (!first_matching_lma
)
6985 /* At least one section fits inside the current segment.
6986 Keep it, but modify its physical address to match the
6987 LMA of the first section that fitted. */
6988 map
->p_paddr
= matching_lma
;
6992 /* None of the sections fitted inside the current segment.
6993 Change the current segment's physical address to match
6994 the LMA of the first section. */
6995 map
->p_paddr
= suggested_lma
;
6998 /* Offset the segment physical address from the lma
6999 to allow for space taken up by elf headers. */
7000 if (map
->includes_filehdr
)
7002 if (map
->p_paddr
>= iehdr
->e_ehsize
)
7003 map
->p_paddr
-= iehdr
->e_ehsize
;
7006 map
->includes_filehdr
= FALSE
;
7007 map
->includes_phdrs
= FALSE
;
7011 if (map
->includes_phdrs
)
7013 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
7015 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
7017 /* iehdr->e_phnum is just an estimate of the number
7018 of program headers that we will need. Make a note
7019 here of the number we used and the segment we chose
7020 to hold these headers, so that we can adjust the
7021 offset when we know the correct value. */
7022 phdr_adjust_num
= iehdr
->e_phnum
;
7023 phdr_adjust_seg
= map
;
7026 map
->includes_phdrs
= FALSE
;
7030 /* Step Three: Loop over the sections again, this time assigning
7031 those that fit to the current segment and removing them from the
7032 sections array; but making sure not to leave large gaps. Once all
7033 possible sections have been assigned to the current segment it is
7034 added to the list of built segments and if sections still remain
7035 to be assigned, a new segment is constructed before repeating
7042 first_suggested_lma
= TRUE
;
7044 /* Fill the current segment with sections that fit. */
7045 for (j
= 0; j
< section_count
; j
++)
7047 section
= sections
[j
];
7049 if (section
== NULL
)
7052 output_section
= section
->output_section
;
7054 BFD_ASSERT (output_section
!= NULL
);
7056 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
7057 || IS_COREFILE_NOTE (segment
, section
))
7059 if (map
->count
== 0)
7061 /* If the first section in a segment does not start at
7062 the beginning of the segment, then something is
7064 if (output_section
->lma
7066 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
7067 + (map
->includes_phdrs
7068 ? iehdr
->e_phnum
* iehdr
->e_phentsize
7076 prev_sec
= map
->sections
[map
->count
- 1];
7078 /* If the gap between the end of the previous section
7079 and the start of this section is more than
7080 maxpagesize then we need to start a new segment. */
7081 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
7083 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
7084 || (prev_sec
->lma
+ prev_sec
->size
7085 > output_section
->lma
))
7087 if (first_suggested_lma
)
7089 suggested_lma
= output_section
->lma
;
7090 first_suggested_lma
= FALSE
;
7097 map
->sections
[map
->count
++] = output_section
;
7100 section
->segment_mark
= TRUE
;
7102 else if (first_suggested_lma
)
7104 suggested_lma
= output_section
->lma
;
7105 first_suggested_lma
= FALSE
;
7109 BFD_ASSERT (map
->count
> 0);
7111 /* Add the current segment to the list of built segments. */
7112 *pointer_to_map
= map
;
7113 pointer_to_map
= &map
->next
;
7115 if (isec
< section_count
)
7117 /* We still have not allocated all of the sections to
7118 segments. Create a new segment here, initialise it
7119 and carry on looping. */
7120 amt
= sizeof (struct elf_segment_map
);
7121 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
7122 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7129 /* Initialise the fields of the segment map. Set the physical
7130 physical address to the LMA of the first section that has
7131 not yet been assigned. */
7133 map
->p_type
= segment
->p_type
;
7134 map
->p_flags
= segment
->p_flags
;
7135 map
->p_flags_valid
= 1;
7136 map
->p_paddr
= suggested_lma
;
7137 map
->p_paddr_valid
= p_paddr_valid
;
7138 map
->includes_filehdr
= 0;
7139 map
->includes_phdrs
= 0;
7142 while (isec
< section_count
);
7147 elf_seg_map (obfd
) = map_first
;
7149 /* If we had to estimate the number of program headers that were
7150 going to be needed, then check our estimate now and adjust
7151 the offset if necessary. */
7152 if (phdr_adjust_seg
!= NULL
)
7156 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
7159 if (count
> phdr_adjust_num
)
7160 phdr_adjust_seg
->p_paddr
7161 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
7166 #undef IS_CONTAINED_BY_VMA
7167 #undef IS_CONTAINED_BY_LMA
7169 #undef IS_COREFILE_NOTE
7170 #undef IS_SOLARIS_PT_INTERP
7171 #undef IS_SECTION_IN_INPUT_SEGMENT
7172 #undef INCLUDE_SECTION_IN_SEGMENT
7173 #undef SEGMENT_AFTER_SEGMENT
7174 #undef SEGMENT_OVERLAPS
7178 /* Copy ELF program header information. */
7181 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
7183 Elf_Internal_Ehdr
*iehdr
;
7184 struct elf_segment_map
*map
;
7185 struct elf_segment_map
*map_first
;
7186 struct elf_segment_map
**pointer_to_map
;
7187 Elf_Internal_Phdr
*segment
;
7189 unsigned int num_segments
;
7190 bfd_boolean phdr_included
= FALSE
;
7191 bfd_boolean p_paddr_valid
;
7193 iehdr
= elf_elfheader (ibfd
);
7196 pointer_to_map
= &map_first
;
7198 /* If all the segment p_paddr fields are zero, don't set
7199 map->p_paddr_valid. */
7200 p_paddr_valid
= FALSE
;
7201 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7202 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7205 if (segment
->p_paddr
!= 0)
7207 p_paddr_valid
= TRUE
;
7211 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7216 unsigned int section_count
;
7218 Elf_Internal_Shdr
*this_hdr
;
7219 asection
*first_section
= NULL
;
7220 asection
*lowest_section
;
7222 /* Compute how many sections are in this segment. */
7223 for (section
= ibfd
->sections
, section_count
= 0;
7225 section
= section
->next
)
7227 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7228 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7230 if (first_section
== NULL
)
7231 first_section
= section
;
7236 /* Allocate a segment map big enough to contain
7237 all of the sections we have selected. */
7238 amt
= sizeof (struct elf_segment_map
);
7239 if (section_count
!= 0)
7240 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
7241 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
7245 /* Initialize the fields of the output segment map with the
7248 map
->p_type
= segment
->p_type
;
7249 map
->p_flags
= segment
->p_flags
;
7250 map
->p_flags_valid
= 1;
7251 map
->p_paddr
= segment
->p_paddr
;
7252 map
->p_paddr_valid
= p_paddr_valid
;
7253 map
->p_align
= segment
->p_align
;
7254 map
->p_align_valid
= 1;
7255 map
->p_vaddr_offset
= 0;
7257 if (map
->p_type
== PT_GNU_RELRO
7258 || map
->p_type
== PT_GNU_STACK
)
7260 /* The PT_GNU_RELRO segment may contain the first a few
7261 bytes in the .got.plt section even if the whole .got.plt
7262 section isn't in the PT_GNU_RELRO segment. We won't
7263 change the size of the PT_GNU_RELRO segment.
7264 Similarly, PT_GNU_STACK size is significant on uclinux
7266 map
->p_size
= segment
->p_memsz
;
7267 map
->p_size_valid
= 1;
7270 /* Determine if this segment contains the ELF file header
7271 and if it contains the program headers themselves. */
7272 map
->includes_filehdr
= (segment
->p_offset
== 0
7273 && segment
->p_filesz
>= iehdr
->e_ehsize
);
7275 map
->includes_phdrs
= 0;
7276 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
7278 map
->includes_phdrs
=
7279 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
7280 && (segment
->p_offset
+ segment
->p_filesz
7281 >= ((bfd_vma
) iehdr
->e_phoff
7282 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
7284 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
7285 phdr_included
= TRUE
;
7288 lowest_section
= NULL
;
7289 if (section_count
!= 0)
7291 unsigned int isec
= 0;
7293 for (section
= first_section
;
7295 section
= section
->next
)
7297 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7298 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7300 map
->sections
[isec
++] = section
->output_section
;
7301 if ((section
->flags
& SEC_ALLOC
) != 0)
7305 if (lowest_section
== NULL
7306 || section
->lma
< lowest_section
->lma
)
7307 lowest_section
= section
;
7309 /* Section lmas are set up from PT_LOAD header
7310 p_paddr in _bfd_elf_make_section_from_shdr.
7311 If this header has a p_paddr that disagrees
7312 with the section lma, flag the p_paddr as
7314 if ((section
->flags
& SEC_LOAD
) != 0)
7315 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
7317 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
7318 if (section
->lma
- segment
->p_paddr
!= seg_off
)
7319 map
->p_paddr_valid
= FALSE
;
7321 if (isec
== section_count
)
7327 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
7328 /* We need to keep the space used by the headers fixed. */
7329 map
->header_size
= lowest_section
->vma
- segment
->p_vaddr
;
7331 if (!map
->includes_phdrs
7332 && !map
->includes_filehdr
7333 && map
->p_paddr_valid
)
7334 /* There is some other padding before the first section. */
7335 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
7336 - segment
->p_paddr
);
7338 map
->count
= section_count
;
7339 *pointer_to_map
= map
;
7340 pointer_to_map
= &map
->next
;
7343 elf_seg_map (obfd
) = map_first
;
7347 /* Copy private BFD data. This copies or rewrites ELF program header
7351 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
7353 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7354 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7357 if (elf_tdata (ibfd
)->phdr
== NULL
)
7360 if (ibfd
->xvec
== obfd
->xvec
)
7362 /* Check to see if any sections in the input BFD
7363 covered by ELF program header have changed. */
7364 Elf_Internal_Phdr
*segment
;
7365 asection
*section
, *osec
;
7366 unsigned int i
, num_segments
;
7367 Elf_Internal_Shdr
*this_hdr
;
7368 const struct elf_backend_data
*bed
;
7370 bed
= get_elf_backend_data (ibfd
);
7372 /* Regenerate the segment map if p_paddr is set to 0. */
7373 if (bed
->want_p_paddr_set_to_zero
)
7376 /* Initialize the segment mark field. */
7377 for (section
= obfd
->sections
; section
!= NULL
;
7378 section
= section
->next
)
7379 section
->segment_mark
= FALSE
;
7381 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7382 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7386 /* PR binutils/3535. The Solaris linker always sets the p_paddr
7387 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
7388 which severly confuses things, so always regenerate the segment
7389 map in this case. */
7390 if (segment
->p_paddr
== 0
7391 && segment
->p_memsz
== 0
7392 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
7395 for (section
= ibfd
->sections
;
7396 section
!= NULL
; section
= section
->next
)
7398 /* We mark the output section so that we know it comes
7399 from the input BFD. */
7400 osec
= section
->output_section
;
7402 osec
->segment_mark
= TRUE
;
7404 /* Check if this section is covered by the segment. */
7405 this_hdr
= &(elf_section_data(section
)->this_hdr
);
7406 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
7408 /* FIXME: Check if its output section is changed or
7409 removed. What else do we need to check? */
7411 || section
->flags
!= osec
->flags
7412 || section
->lma
!= osec
->lma
7413 || section
->vma
!= osec
->vma
7414 || section
->size
!= osec
->size
7415 || section
->rawsize
!= osec
->rawsize
7416 || section
->alignment_power
!= osec
->alignment_power
)
7422 /* Check to see if any output section do not come from the
7424 for (section
= obfd
->sections
; section
!= NULL
;
7425 section
= section
->next
)
7427 if (!section
->segment_mark
)
7430 section
->segment_mark
= FALSE
;
7433 return copy_elf_program_header (ibfd
, obfd
);
7437 if (ibfd
->xvec
== obfd
->xvec
)
7439 /* When rewriting program header, set the output maxpagesize to
7440 the maximum alignment of input PT_LOAD segments. */
7441 Elf_Internal_Phdr
*segment
;
7443 unsigned int num_segments
= elf_elfheader (ibfd
)->e_phnum
;
7444 bfd_vma maxpagesize
= 0;
7446 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
7449 if (segment
->p_type
== PT_LOAD
7450 && maxpagesize
< segment
->p_align
)
7452 /* PR 17512: file: f17299af. */
7453 if (segment
->p_align
> (bfd_vma
) 1 << ((sizeof (bfd_vma
) * 8) - 2))
7454 /* xgettext:c-format */
7455 _bfd_error_handler (_("%B: warning: segment alignment of %#Lx"
7457 ibfd
, segment
->p_align
);
7459 maxpagesize
= segment
->p_align
;
7462 if (maxpagesize
!= get_elf_backend_data (obfd
)->maxpagesize
)
7463 bfd_emul_set_maxpagesize (bfd_get_target (obfd
), maxpagesize
);
7466 return rewrite_elf_program_header (ibfd
, obfd
);
7469 /* Initialize private output section information from input section. */
7472 _bfd_elf_init_private_section_data (bfd
*ibfd
,
7476 struct bfd_link_info
*link_info
)
7479 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7480 bfd_boolean final_link
= (link_info
!= NULL
7481 && !bfd_link_relocatable (link_info
));
7483 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7484 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7487 BFD_ASSERT (elf_section_data (osec
) != NULL
);
7489 /* For objcopy and relocatable link, don't copy the output ELF
7490 section type from input if the output BFD section flags have been
7491 set to something different. For a final link allow some flags
7492 that the linker clears to differ. */
7493 if (elf_section_type (osec
) == SHT_NULL
7494 && (osec
->flags
== isec
->flags
7496 && ((osec
->flags
^ isec
->flags
)
7497 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
7498 elf_section_type (osec
) = elf_section_type (isec
);
7500 /* FIXME: Is this correct for all OS/PROC specific flags? */
7501 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7502 & (SHF_MASKOS
| SHF_MASKPROC
));
7504 /* Copy sh_info from input for mbind section. */
7505 if (elf_section_flags (isec
) & SHF_GNU_MBIND
)
7506 elf_section_data (osec
)->this_hdr
.sh_info
7507 = elf_section_data (isec
)->this_hdr
.sh_info
;
7509 /* Set things up for objcopy and relocatable link. The output
7510 SHT_GROUP section will have its elf_next_in_group pointing back
7511 to the input group members. Ignore linker created group section.
7512 See elfNN_ia64_object_p in elfxx-ia64.c. */
7513 if ((link_info
== NULL
7514 || !link_info
->resolve_section_groups
)
7515 && (elf_sec_group (isec
) == NULL
7516 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0))
7518 if (elf_section_flags (isec
) & SHF_GROUP
)
7519 elf_section_flags (osec
) |= SHF_GROUP
;
7520 elf_next_in_group (osec
) = elf_next_in_group (isec
);
7521 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
7524 /* If not decompress, preserve SHF_COMPRESSED. */
7525 if (!final_link
&& (ibfd
->flags
& BFD_DECOMPRESS
) == 0)
7526 elf_section_flags (osec
) |= (elf_section_flags (isec
)
7529 ihdr
= &elf_section_data (isec
)->this_hdr
;
7531 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
7532 don't use the output section of the linked-to section since it
7533 may be NULL at this point. */
7534 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
7536 ohdr
= &elf_section_data (osec
)->this_hdr
;
7537 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
7538 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
7541 osec
->use_rela_p
= isec
->use_rela_p
;
7546 /* Copy private section information. This copies over the entsize
7547 field, and sometimes the info field. */
7550 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
7555 Elf_Internal_Shdr
*ihdr
, *ohdr
;
7557 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
7558 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
7561 ihdr
= &elf_section_data (isec
)->this_hdr
;
7562 ohdr
= &elf_section_data (osec
)->this_hdr
;
7564 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
7566 if (ihdr
->sh_type
== SHT_SYMTAB
7567 || ihdr
->sh_type
== SHT_DYNSYM
7568 || ihdr
->sh_type
== SHT_GNU_verneed
7569 || ihdr
->sh_type
== SHT_GNU_verdef
)
7570 ohdr
->sh_info
= ihdr
->sh_info
;
7572 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
7576 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
7577 necessary if we are removing either the SHT_GROUP section or any of
7578 the group member sections. DISCARDED is the value that a section's
7579 output_section has if the section will be discarded, NULL when this
7580 function is called from objcopy, bfd_abs_section_ptr when called
7584 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
7588 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
7589 if (elf_section_type (isec
) == SHT_GROUP
)
7591 asection
*first
= elf_next_in_group (isec
);
7592 asection
*s
= first
;
7593 bfd_size_type removed
= 0;
7597 /* If this member section is being output but the
7598 SHT_GROUP section is not, then clear the group info
7599 set up by _bfd_elf_copy_private_section_data. */
7600 if (s
->output_section
!= discarded
7601 && isec
->output_section
== discarded
)
7603 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
7604 elf_group_name (s
->output_section
) = NULL
;
7606 /* Conversely, if the member section is not being output
7607 but the SHT_GROUP section is, then adjust its size. */
7608 else if (s
->output_section
== discarded
7609 && isec
->output_section
!= discarded
)
7611 struct bfd_elf_section_data
*elf_sec
= elf_section_data (s
);
7613 if (elf_sec
->rel
.hdr
!= NULL
7614 && (elf_sec
->rel
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7616 if (elf_sec
->rela
.hdr
!= NULL
7617 && (elf_sec
->rela
.hdr
->sh_flags
& SHF_GROUP
) != 0)
7620 s
= elf_next_in_group (s
);
7626 if (discarded
!= NULL
)
7628 /* If we've been called for ld -r, then we need to
7629 adjust the input section size. */
7630 if (isec
->rawsize
== 0)
7631 isec
->rawsize
= isec
->size
;
7632 isec
->size
= isec
->rawsize
- removed
;
7633 if (isec
->size
<= 4)
7636 isec
->flags
|= SEC_EXCLUDE
;
7641 /* Adjust the output section size when called from
7643 isec
->output_section
->size
-= removed
;
7644 if (isec
->output_section
->size
<= 4)
7646 isec
->output_section
->size
= 0;
7647 isec
->output_section
->flags
|= SEC_EXCLUDE
;
7656 /* Copy private header information. */
7659 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
7661 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7662 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7665 /* Copy over private BFD data if it has not already been copied.
7666 This must be done here, rather than in the copy_private_bfd_data
7667 entry point, because the latter is called after the section
7668 contents have been set, which means that the program headers have
7669 already been worked out. */
7670 if (elf_seg_map (obfd
) == NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
7672 if (! copy_private_bfd_data (ibfd
, obfd
))
7676 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
7679 /* Copy private symbol information. If this symbol is in a section
7680 which we did not map into a BFD section, try to map the section
7681 index correctly. We use special macro definitions for the mapped
7682 section indices; these definitions are interpreted by the
7683 swap_out_syms function. */
7685 #define MAP_ONESYMTAB (SHN_HIOS + 1)
7686 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
7687 #define MAP_STRTAB (SHN_HIOS + 3)
7688 #define MAP_SHSTRTAB (SHN_HIOS + 4)
7689 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
7692 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
7697 elf_symbol_type
*isym
, *osym
;
7699 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
7700 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
7703 isym
= elf_symbol_from (ibfd
, isymarg
);
7704 osym
= elf_symbol_from (obfd
, osymarg
);
7707 && isym
->internal_elf_sym
.st_shndx
!= 0
7709 && bfd_is_abs_section (isym
->symbol
.section
))
7713 shndx
= isym
->internal_elf_sym
.st_shndx
;
7714 if (shndx
== elf_onesymtab (ibfd
))
7715 shndx
= MAP_ONESYMTAB
;
7716 else if (shndx
== elf_dynsymtab (ibfd
))
7717 shndx
= MAP_DYNSYMTAB
;
7718 else if (shndx
== elf_strtab_sec (ibfd
))
7720 else if (shndx
== elf_shstrtab_sec (ibfd
))
7721 shndx
= MAP_SHSTRTAB
;
7722 else if (find_section_in_list (shndx
, elf_symtab_shndx_list (ibfd
)))
7723 shndx
= MAP_SYM_SHNDX
;
7724 osym
->internal_elf_sym
.st_shndx
= shndx
;
7730 /* Swap out the symbols. */
7733 swap_out_syms (bfd
*abfd
,
7734 struct elf_strtab_hash
**sttp
,
7737 const struct elf_backend_data
*bed
;
7740 struct elf_strtab_hash
*stt
;
7741 Elf_Internal_Shdr
*symtab_hdr
;
7742 Elf_Internal_Shdr
*symtab_shndx_hdr
;
7743 Elf_Internal_Shdr
*symstrtab_hdr
;
7744 struct elf_sym_strtab
*symstrtab
;
7745 bfd_byte
*outbound_syms
;
7746 bfd_byte
*outbound_shndx
;
7747 unsigned long outbound_syms_index
;
7748 unsigned long outbound_shndx_index
;
7750 unsigned int num_locals
;
7752 bfd_boolean name_local_sections
;
7754 if (!elf_map_symbols (abfd
, &num_locals
))
7757 /* Dump out the symtabs. */
7758 stt
= _bfd_elf_strtab_init ();
7762 bed
= get_elf_backend_data (abfd
);
7763 symcount
= bfd_get_symcount (abfd
);
7764 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
7765 symtab_hdr
->sh_type
= SHT_SYMTAB
;
7766 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
7767 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
7768 symtab_hdr
->sh_info
= num_locals
+ 1;
7769 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
7771 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
7772 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
7774 /* Allocate buffer to swap out the .strtab section. */
7775 symstrtab
= (struct elf_sym_strtab
*) bfd_malloc ((symcount
+ 1)
7776 * sizeof (*symstrtab
));
7777 if (symstrtab
== NULL
)
7779 _bfd_elf_strtab_free (stt
);
7783 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
7784 bed
->s
->sizeof_sym
);
7785 if (outbound_syms
== NULL
)
7788 _bfd_elf_strtab_free (stt
);
7792 symtab_hdr
->contents
= outbound_syms
;
7793 outbound_syms_index
= 0;
7795 outbound_shndx
= NULL
;
7796 outbound_shndx_index
= 0;
7798 if (elf_symtab_shndx_list (abfd
))
7800 symtab_shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
7801 if (symtab_shndx_hdr
->sh_name
!= 0)
7803 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
7804 outbound_shndx
= (bfd_byte
*)
7805 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
7806 if (outbound_shndx
== NULL
)
7809 symtab_shndx_hdr
->contents
= outbound_shndx
;
7810 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
7811 symtab_shndx_hdr
->sh_size
= amt
;
7812 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
7813 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
7815 /* FIXME: What about any other headers in the list ? */
7818 /* Now generate the data (for "contents"). */
7820 /* Fill in zeroth symbol and swap it out. */
7821 Elf_Internal_Sym sym
;
7827 sym
.st_shndx
= SHN_UNDEF
;
7828 sym
.st_target_internal
= 0;
7829 symstrtab
[0].sym
= sym
;
7830 symstrtab
[0].dest_index
= outbound_syms_index
;
7831 symstrtab
[0].destshndx_index
= outbound_shndx_index
;
7832 outbound_syms_index
++;
7833 if (outbound_shndx
!= NULL
)
7834 outbound_shndx_index
++;
7838 = (bed
->elf_backend_name_local_section_symbols
7839 && bed
->elf_backend_name_local_section_symbols (abfd
));
7841 syms
= bfd_get_outsymbols (abfd
);
7842 for (idx
= 0; idx
< symcount
;)
7844 Elf_Internal_Sym sym
;
7845 bfd_vma value
= syms
[idx
]->value
;
7846 elf_symbol_type
*type_ptr
;
7847 flagword flags
= syms
[idx
]->flags
;
7850 if (!name_local_sections
7851 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
7853 /* Local section symbols have no name. */
7854 sym
.st_name
= (unsigned long) -1;
7858 /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize
7859 to get the final offset for st_name. */
7861 = (unsigned long) _bfd_elf_strtab_add (stt
, syms
[idx
]->name
,
7863 if (sym
.st_name
== (unsigned long) -1)
7867 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
7869 if ((flags
& BSF_SECTION_SYM
) == 0
7870 && bfd_is_com_section (syms
[idx
]->section
))
7872 /* ELF common symbols put the alignment into the `value' field,
7873 and the size into the `size' field. This is backwards from
7874 how BFD handles it, so reverse it here. */
7875 sym
.st_size
= value
;
7876 if (type_ptr
== NULL
7877 || type_ptr
->internal_elf_sym
.st_value
== 0)
7878 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
7880 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
7881 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
7882 (abfd
, syms
[idx
]->section
);
7886 asection
*sec
= syms
[idx
]->section
;
7889 if (sec
->output_section
)
7891 value
+= sec
->output_offset
;
7892 sec
= sec
->output_section
;
7895 /* Don't add in the section vma for relocatable output. */
7896 if (! relocatable_p
)
7898 sym
.st_value
= value
;
7899 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
7901 if (bfd_is_abs_section (sec
)
7903 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
7905 /* This symbol is in a real ELF section which we did
7906 not create as a BFD section. Undo the mapping done
7907 by copy_private_symbol_data. */
7908 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
7912 shndx
= elf_onesymtab (abfd
);
7915 shndx
= elf_dynsymtab (abfd
);
7918 shndx
= elf_strtab_sec (abfd
);
7921 shndx
= elf_shstrtab_sec (abfd
);
7924 if (elf_symtab_shndx_list (abfd
))
7925 shndx
= elf_symtab_shndx_list (abfd
)->ndx
;
7934 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
7936 if (shndx
== SHN_BAD
)
7940 /* Writing this would be a hell of a lot easier if
7941 we had some decent documentation on bfd, and
7942 knew what to expect of the library, and what to
7943 demand of applications. For example, it
7944 appears that `objcopy' might not set the
7945 section of a symbol to be a section that is
7946 actually in the output file. */
7947 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
7949 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
7950 if (shndx
== SHN_BAD
)
7952 /* xgettext:c-format */
7953 _bfd_error_handler (_("\
7954 Unable to find equivalent output section for symbol '%s' from section '%s'"),
7955 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
7957 bfd_set_error (bfd_error_invalid_operation
);
7963 sym
.st_shndx
= shndx
;
7966 if ((flags
& BSF_THREAD_LOCAL
) != 0)
7968 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
7969 type
= STT_GNU_IFUNC
;
7970 else if ((flags
& BSF_FUNCTION
) != 0)
7972 else if ((flags
& BSF_OBJECT
) != 0)
7974 else if ((flags
& BSF_RELC
) != 0)
7976 else if ((flags
& BSF_SRELC
) != 0)
7981 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
7984 /* Processor-specific types. */
7985 if (type_ptr
!= NULL
7986 && bed
->elf_backend_get_symbol_type
)
7987 type
= ((*bed
->elf_backend_get_symbol_type
)
7988 (&type_ptr
->internal_elf_sym
, type
));
7990 if (flags
& BSF_SECTION_SYM
)
7992 if (flags
& BSF_GLOBAL
)
7993 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
7995 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
7997 else if (bfd_is_com_section (syms
[idx
]->section
))
7999 if (type
!= STT_TLS
)
8001 if ((abfd
->flags
& BFD_CONVERT_ELF_COMMON
))
8002 type
= ((abfd
->flags
& BFD_USE_ELF_STT_COMMON
)
8003 ? STT_COMMON
: STT_OBJECT
);
8005 type
= ((flags
& BSF_ELF_COMMON
) != 0
8006 ? STT_COMMON
: STT_OBJECT
);
8008 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
8010 else if (bfd_is_und_section (syms
[idx
]->section
))
8011 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
8015 else if (flags
& BSF_FILE
)
8016 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
8019 int bind
= STB_LOCAL
;
8021 if (flags
& BSF_LOCAL
)
8023 else if (flags
& BSF_GNU_UNIQUE
)
8024 bind
= STB_GNU_UNIQUE
;
8025 else if (flags
& BSF_WEAK
)
8027 else if (flags
& BSF_GLOBAL
)
8030 sym
.st_info
= ELF_ST_INFO (bind
, type
);
8033 if (type_ptr
!= NULL
)
8035 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
8036 sym
.st_target_internal
8037 = type_ptr
->internal_elf_sym
.st_target_internal
;
8042 sym
.st_target_internal
= 0;
8046 symstrtab
[idx
].sym
= sym
;
8047 symstrtab
[idx
].dest_index
= outbound_syms_index
;
8048 symstrtab
[idx
].destshndx_index
= outbound_shndx_index
;
8050 outbound_syms_index
++;
8051 if (outbound_shndx
!= NULL
)
8052 outbound_shndx_index
++;
8055 /* Finalize the .strtab section. */
8056 _bfd_elf_strtab_finalize (stt
);
8058 /* Swap out the .strtab section. */
8059 for (idx
= 0; idx
<= symcount
; idx
++)
8061 struct elf_sym_strtab
*elfsym
= &symstrtab
[idx
];
8062 if (elfsym
->sym
.st_name
== (unsigned long) -1)
8063 elfsym
->sym
.st_name
= 0;
8065 elfsym
->sym
.st_name
= _bfd_elf_strtab_offset (stt
,
8066 elfsym
->sym
.st_name
);
8067 bed
->s
->swap_symbol_out (abfd
, &elfsym
->sym
,
8069 + (elfsym
->dest_index
8070 * bed
->s
->sizeof_sym
)),
8072 + (elfsym
->destshndx_index
8073 * sizeof (Elf_External_Sym_Shndx
))));
8078 symstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (stt
);
8079 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
8080 symstrtab_hdr
->sh_flags
= bed
->elf_strtab_flags
;
8081 symstrtab_hdr
->sh_addr
= 0;
8082 symstrtab_hdr
->sh_entsize
= 0;
8083 symstrtab_hdr
->sh_link
= 0;
8084 symstrtab_hdr
->sh_info
= 0;
8085 symstrtab_hdr
->sh_addralign
= 1;
8090 /* Return the number of bytes required to hold the symtab vector.
8092 Note that we base it on the count plus 1, since we will null terminate
8093 the vector allocated based on this size. However, the ELF symbol table
8094 always has a dummy entry as symbol #0, so it ends up even. */
8097 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
8101 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
8103 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8104 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8106 symtab_size
-= sizeof (asymbol
*);
8112 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
8116 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
8118 if (elf_dynsymtab (abfd
) == 0)
8120 bfd_set_error (bfd_error_invalid_operation
);
8124 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
8125 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
8127 symtab_size
-= sizeof (asymbol
*);
8133 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
8136 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
8139 /* Canonicalize the relocs. */
8142 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
8149 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8151 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
8154 tblptr
= section
->relocation
;
8155 for (i
= 0; i
< section
->reloc_count
; i
++)
8156 *relptr
++ = tblptr
++;
8160 return section
->reloc_count
;
8164 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
8166 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8167 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
8170 bfd_get_symcount (abfd
) = symcount
;
8175 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
8176 asymbol
**allocation
)
8178 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8179 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
8182 bfd_get_dynamic_symcount (abfd
) = symcount
;
8186 /* Return the size required for the dynamic reloc entries. Any loadable
8187 section that was actually installed in the BFD, and has type SHT_REL
8188 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
8189 dynamic reloc section. */
8192 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
8197 if (elf_dynsymtab (abfd
) == 0)
8199 bfd_set_error (bfd_error_invalid_operation
);
8203 ret
= sizeof (arelent
*);
8204 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8205 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8206 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8207 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8208 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
8209 * sizeof (arelent
*));
8214 /* Canonicalize the dynamic relocation entries. Note that we return the
8215 dynamic relocations as a single block, although they are actually
8216 associated with particular sections; the interface, which was
8217 designed for SunOS style shared libraries, expects that there is only
8218 one set of dynamic relocs. Any loadable section that was actually
8219 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
8220 dynamic symbol table, is considered to be a dynamic reloc section. */
8223 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
8227 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8231 if (elf_dynsymtab (abfd
) == 0)
8233 bfd_set_error (bfd_error_invalid_operation
);
8237 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8239 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
8241 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
8242 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
8243 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
8248 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
8250 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
8252 for (i
= 0; i
< count
; i
++)
8263 /* Read in the version information. */
8266 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
8268 bfd_byte
*contents
= NULL
;
8269 unsigned int freeidx
= 0;
8271 if (elf_dynverref (abfd
) != 0)
8273 Elf_Internal_Shdr
*hdr
;
8274 Elf_External_Verneed
*everneed
;
8275 Elf_Internal_Verneed
*iverneed
;
8277 bfd_byte
*contents_end
;
8279 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
8281 if (hdr
->sh_info
== 0
8282 || hdr
->sh_info
> hdr
->sh_size
/ sizeof (Elf_External_Verneed
))
8284 error_return_bad_verref
:
8286 (_("%B: .gnu.version_r invalid entry"), abfd
);
8287 bfd_set_error (bfd_error_bad_value
);
8288 error_return_verref
:
8289 elf_tdata (abfd
)->verref
= NULL
;
8290 elf_tdata (abfd
)->cverrefs
= 0;
8294 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8295 if (contents
== NULL
)
8296 goto error_return_verref
;
8298 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8299 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8300 goto error_return_verref
;
8302 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
8303 bfd_alloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
8305 if (elf_tdata (abfd
)->verref
== NULL
)
8306 goto error_return_verref
;
8308 BFD_ASSERT (sizeof (Elf_External_Verneed
)
8309 == sizeof (Elf_External_Vernaux
));
8310 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
8311 everneed
= (Elf_External_Verneed
*) contents
;
8312 iverneed
= elf_tdata (abfd
)->verref
;
8313 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
8315 Elf_External_Vernaux
*evernaux
;
8316 Elf_Internal_Vernaux
*ivernaux
;
8319 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
8321 iverneed
->vn_bfd
= abfd
;
8323 iverneed
->vn_filename
=
8324 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8326 if (iverneed
->vn_filename
== NULL
)
8327 goto error_return_bad_verref
;
8329 if (iverneed
->vn_cnt
== 0)
8330 iverneed
->vn_auxptr
= NULL
;
8333 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
8334 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
8335 sizeof (Elf_Internal_Vernaux
));
8336 if (iverneed
->vn_auxptr
== NULL
)
8337 goto error_return_verref
;
8340 if (iverneed
->vn_aux
8341 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8342 goto error_return_bad_verref
;
8344 evernaux
= ((Elf_External_Vernaux
*)
8345 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
8346 ivernaux
= iverneed
->vn_auxptr
;
8347 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
8349 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
8351 ivernaux
->vna_nodename
=
8352 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8353 ivernaux
->vna_name
);
8354 if (ivernaux
->vna_nodename
== NULL
)
8355 goto error_return_bad_verref
;
8357 if (ivernaux
->vna_other
> freeidx
)
8358 freeidx
= ivernaux
->vna_other
;
8360 ivernaux
->vna_nextptr
= NULL
;
8361 if (ivernaux
->vna_next
== 0)
8363 iverneed
->vn_cnt
= j
+ 1;
8366 if (j
+ 1 < iverneed
->vn_cnt
)
8367 ivernaux
->vna_nextptr
= ivernaux
+ 1;
8369 if (ivernaux
->vna_next
8370 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
8371 goto error_return_bad_verref
;
8373 evernaux
= ((Elf_External_Vernaux
*)
8374 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
8377 iverneed
->vn_nextref
= NULL
;
8378 if (iverneed
->vn_next
== 0)
8380 if (i
+ 1 < hdr
->sh_info
)
8381 iverneed
->vn_nextref
= iverneed
+ 1;
8383 if (iverneed
->vn_next
8384 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
8385 goto error_return_bad_verref
;
8387 everneed
= ((Elf_External_Verneed
*)
8388 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
8390 elf_tdata (abfd
)->cverrefs
= i
;
8396 if (elf_dynverdef (abfd
) != 0)
8398 Elf_Internal_Shdr
*hdr
;
8399 Elf_External_Verdef
*everdef
;
8400 Elf_Internal_Verdef
*iverdef
;
8401 Elf_Internal_Verdef
*iverdefarr
;
8402 Elf_Internal_Verdef iverdefmem
;
8404 unsigned int maxidx
;
8405 bfd_byte
*contents_end_def
, *contents_end_aux
;
8407 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
8409 if (hdr
->sh_info
== 0 || hdr
->sh_size
< sizeof (Elf_External_Verdef
))
8411 error_return_bad_verdef
:
8413 (_("%B: .gnu.version_d invalid entry"), abfd
);
8414 bfd_set_error (bfd_error_bad_value
);
8415 error_return_verdef
:
8416 elf_tdata (abfd
)->verdef
= NULL
;
8417 elf_tdata (abfd
)->cverdefs
= 0;
8421 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
8422 if (contents
== NULL
)
8423 goto error_return_verdef
;
8424 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
8425 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
8426 goto error_return_verdef
;
8428 BFD_ASSERT (sizeof (Elf_External_Verdef
)
8429 >= sizeof (Elf_External_Verdaux
));
8430 contents_end_def
= contents
+ hdr
->sh_size
8431 - sizeof (Elf_External_Verdef
);
8432 contents_end_aux
= contents
+ hdr
->sh_size
8433 - sizeof (Elf_External_Verdaux
);
8435 /* We know the number of entries in the section but not the maximum
8436 index. Therefore we have to run through all entries and find
8438 everdef
= (Elf_External_Verdef
*) contents
;
8440 for (i
= 0; i
< hdr
->sh_info
; ++i
)
8442 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8444 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) == 0)
8445 goto error_return_bad_verdef
;
8446 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
8447 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
8449 if (iverdefmem
.vd_next
== 0)
8452 if (iverdefmem
.vd_next
8453 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
8454 goto error_return_bad_verdef
;
8456 everdef
= ((Elf_External_Verdef
*)
8457 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
8460 if (default_imported_symver
)
8462 if (freeidx
> maxidx
)
8468 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8469 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
8470 if (elf_tdata (abfd
)->verdef
== NULL
)
8471 goto error_return_verdef
;
8473 elf_tdata (abfd
)->cverdefs
= maxidx
;
8475 everdef
= (Elf_External_Verdef
*) contents
;
8476 iverdefarr
= elf_tdata (abfd
)->verdef
;
8477 for (i
= 0; i
< hdr
->sh_info
; i
++)
8479 Elf_External_Verdaux
*everdaux
;
8480 Elf_Internal_Verdaux
*iverdaux
;
8483 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
8485 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
8486 goto error_return_bad_verdef
;
8488 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
8489 memcpy (iverdef
, &iverdefmem
, offsetof (Elf_Internal_Verdef
, vd_bfd
));
8491 iverdef
->vd_bfd
= abfd
;
8493 if (iverdef
->vd_cnt
== 0)
8494 iverdef
->vd_auxptr
= NULL
;
8497 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
8498 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
8499 sizeof (Elf_Internal_Verdaux
));
8500 if (iverdef
->vd_auxptr
== NULL
)
8501 goto error_return_verdef
;
8505 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
8506 goto error_return_bad_verdef
;
8508 everdaux
= ((Elf_External_Verdaux
*)
8509 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
8510 iverdaux
= iverdef
->vd_auxptr
;
8511 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
8513 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
8515 iverdaux
->vda_nodename
=
8516 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
8517 iverdaux
->vda_name
);
8518 if (iverdaux
->vda_nodename
== NULL
)
8519 goto error_return_bad_verdef
;
8521 iverdaux
->vda_nextptr
= NULL
;
8522 if (iverdaux
->vda_next
== 0)
8524 iverdef
->vd_cnt
= j
+ 1;
8527 if (j
+ 1 < iverdef
->vd_cnt
)
8528 iverdaux
->vda_nextptr
= iverdaux
+ 1;
8530 if (iverdaux
->vda_next
8531 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
8532 goto error_return_bad_verdef
;
8534 everdaux
= ((Elf_External_Verdaux
*)
8535 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
8538 iverdef
->vd_nodename
= NULL
;
8539 if (iverdef
->vd_cnt
)
8540 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
8542 iverdef
->vd_nextdef
= NULL
;
8543 if (iverdef
->vd_next
== 0)
8545 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
8546 iverdef
->vd_nextdef
= iverdef
+ 1;
8548 everdef
= ((Elf_External_Verdef
*)
8549 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
8555 else if (default_imported_symver
)
8562 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
8563 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
8564 if (elf_tdata (abfd
)->verdef
== NULL
)
8567 elf_tdata (abfd
)->cverdefs
= freeidx
;
8570 /* Create a default version based on the soname. */
8571 if (default_imported_symver
)
8573 Elf_Internal_Verdef
*iverdef
;
8574 Elf_Internal_Verdaux
*iverdaux
;
8576 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];
8578 iverdef
->vd_version
= VER_DEF_CURRENT
;
8579 iverdef
->vd_flags
= 0;
8580 iverdef
->vd_ndx
= freeidx
;
8581 iverdef
->vd_cnt
= 1;
8583 iverdef
->vd_bfd
= abfd
;
8585 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
8586 if (iverdef
->vd_nodename
== NULL
)
8587 goto error_return_verdef
;
8588 iverdef
->vd_nextdef
= NULL
;
8589 iverdef
->vd_auxptr
= ((struct elf_internal_verdaux
*)
8590 bfd_zalloc (abfd
, sizeof (Elf_Internal_Verdaux
)));
8591 if (iverdef
->vd_auxptr
== NULL
)
8592 goto error_return_verdef
;
8594 iverdaux
= iverdef
->vd_auxptr
;
8595 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
8601 if (contents
!= NULL
)
8607 _bfd_elf_make_empty_symbol (bfd
*abfd
)
8609 elf_symbol_type
*newsym
;
8611 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof * newsym
);
8614 newsym
->symbol
.the_bfd
= abfd
;
8615 return &newsym
->symbol
;
8619 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
8623 bfd_symbol_info (symbol
, ret
);
8626 /* Return whether a symbol name implies a local symbol. Most targets
8627 use this function for the is_local_label_name entry point, but some
8631 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
8634 /* Normal local symbols start with ``.L''. */
8635 if (name
[0] == '.' && name
[1] == 'L')
8638 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
8639 DWARF debugging symbols starting with ``..''. */
8640 if (name
[0] == '.' && name
[1] == '.')
8643 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
8644 emitting DWARF debugging output. I suspect this is actually a
8645 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
8646 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
8647 underscore to be emitted on some ELF targets). For ease of use,
8648 we treat such symbols as local. */
8649 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
8652 /* Treat assembler generated fake symbols, dollar local labels and
8653 forward-backward labels (aka local labels) as locals.
8654 These labels have the form:
8656 L0^A.* (fake symbols)
8658 [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels)
8660 Versions which start with .L will have already been matched above,
8661 so we only need to match the rest. */
8662 if (name
[0] == 'L' && ISDIGIT (name
[1]))
8664 bfd_boolean ret
= FALSE
;
8668 for (p
= name
+ 2; (c
= *p
); p
++)
8670 if (c
== 1 || c
== 2)
8672 if (c
== 1 && p
== name
+ 2)
8673 /* A fake symbol. */
8676 /* FIXME: We are being paranoid here and treating symbols like
8677 L0^Bfoo as if there were non-local, on the grounds that the
8678 assembler will never generate them. But can any symbol
8679 containing an ASCII value in the range 1-31 ever be anything
8680 other than some kind of local ? */
8697 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
8698 asymbol
*symbol ATTRIBUTE_UNUSED
)
8705 _bfd_elf_set_arch_mach (bfd
*abfd
,
8706 enum bfd_architecture arch
,
8707 unsigned long machine
)
8709 /* If this isn't the right architecture for this backend, and this
8710 isn't the generic backend, fail. */
8711 if (arch
!= get_elf_backend_data (abfd
)->arch
8712 && arch
!= bfd_arch_unknown
8713 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
8716 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
8719 /* Find the nearest line to a particular section and offset,
8720 for error reporting. */
8723 _bfd_elf_find_nearest_line (bfd
*abfd
,
8727 const char **filename_ptr
,
8728 const char **functionname_ptr
,
8729 unsigned int *line_ptr
,
8730 unsigned int *discriminator_ptr
)
8734 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
8735 filename_ptr
, functionname_ptr
,
8736 line_ptr
, discriminator_ptr
,
8737 dwarf_debug_sections
, 0,
8738 &elf_tdata (abfd
)->dwarf2_find_line_info
)
8739 || _bfd_dwarf1_find_nearest_line (abfd
, symbols
, section
, offset
,
8740 filename_ptr
, functionname_ptr
,
8743 if (!*functionname_ptr
)
8744 _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8745 *filename_ptr
? NULL
: filename_ptr
,
8750 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
8751 &found
, filename_ptr
,
8752 functionname_ptr
, line_ptr
,
8753 &elf_tdata (abfd
)->line_info
))
8755 if (found
&& (*functionname_ptr
|| *line_ptr
))
8758 if (symbols
== NULL
)
8761 if (! _bfd_elf_find_function (abfd
, symbols
, section
, offset
,
8762 filename_ptr
, functionname_ptr
))
8769 /* Find the line for a symbol. */
8772 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
8773 const char **filename_ptr
, unsigned int *line_ptr
)
8775 return _bfd_dwarf2_find_nearest_line (abfd
, symbols
, symbol
, NULL
, 0,
8776 filename_ptr
, NULL
, line_ptr
, NULL
,
8777 dwarf_debug_sections
, 0,
8778 &elf_tdata (abfd
)->dwarf2_find_line_info
);
8781 /* After a call to bfd_find_nearest_line, successive calls to
8782 bfd_find_inliner_info can be used to get source information about
8783 each level of function inlining that terminated at the address
8784 passed to bfd_find_nearest_line. Currently this is only supported
8785 for DWARF2 with appropriate DWARF3 extensions. */
8788 _bfd_elf_find_inliner_info (bfd
*abfd
,
8789 const char **filename_ptr
,
8790 const char **functionname_ptr
,
8791 unsigned int *line_ptr
)
8794 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
8795 functionname_ptr
, line_ptr
,
8796 & elf_tdata (abfd
)->dwarf2_find_line_info
);
8801 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
8803 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8804 int ret
= bed
->s
->sizeof_ehdr
;
8806 if (!bfd_link_relocatable (info
))
8808 bfd_size_type phdr_size
= elf_program_header_size (abfd
);
8810 if (phdr_size
== (bfd_size_type
) -1)
8812 struct elf_segment_map
*m
;
8815 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
8816 phdr_size
+= bed
->s
->sizeof_phdr
;
8819 phdr_size
= get_program_header_size (abfd
, info
);
8822 elf_program_header_size (abfd
) = phdr_size
;
8830 _bfd_elf_set_section_contents (bfd
*abfd
,
8832 const void *location
,
8834 bfd_size_type count
)
8836 Elf_Internal_Shdr
*hdr
;
8839 if (! abfd
->output_has_begun
8840 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
8846 hdr
= &elf_section_data (section
)->this_hdr
;
8847 if (hdr
->sh_offset
== (file_ptr
) -1)
8849 /* We must compress this section. Write output to the buffer. */
8850 unsigned char *contents
= hdr
->contents
;
8851 if ((offset
+ count
) > hdr
->sh_size
8852 || (section
->flags
& SEC_ELF_COMPRESS
) == 0
8853 || contents
== NULL
)
8855 memcpy (contents
+ offset
, location
, count
);
8858 pos
= hdr
->sh_offset
+ offset
;
8859 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
8860 || bfd_bwrite (location
, count
, abfd
) != count
)
8867 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
8868 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
8869 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
8874 /* Try to convert a non-ELF reloc into an ELF one. */
8877 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
8879 /* Check whether we really have an ELF howto. */
8881 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
8883 bfd_reloc_code_real_type code
;
8884 reloc_howto_type
*howto
;
8886 /* Alien reloc: Try to determine its type to replace it with an
8887 equivalent ELF reloc. */
8889 if (areloc
->howto
->pc_relative
)
8891 switch (areloc
->howto
->bitsize
)
8894 code
= BFD_RELOC_8_PCREL
;
8897 code
= BFD_RELOC_12_PCREL
;
8900 code
= BFD_RELOC_16_PCREL
;
8903 code
= BFD_RELOC_24_PCREL
;
8906 code
= BFD_RELOC_32_PCREL
;
8909 code
= BFD_RELOC_64_PCREL
;
8915 howto
= bfd_reloc_type_lookup (abfd
, code
);
8917 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
8919 if (howto
->pcrel_offset
)
8920 areloc
->addend
+= areloc
->address
;
8922 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
8927 switch (areloc
->howto
->bitsize
)
8933 code
= BFD_RELOC_14
;
8936 code
= BFD_RELOC_16
;
8939 code
= BFD_RELOC_26
;
8942 code
= BFD_RELOC_32
;
8945 code
= BFD_RELOC_64
;
8951 howto
= bfd_reloc_type_lookup (abfd
, code
);
8955 areloc
->howto
= howto
;
8964 /* xgettext:c-format */
8965 (_("%B: unsupported relocation type %s"),
8966 abfd
, areloc
->howto
->name
);
8967 bfd_set_error (bfd_error_bad_value
);
8972 _bfd_elf_close_and_cleanup (bfd
*abfd
)
8974 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
8975 if (bfd_get_format (abfd
) == bfd_object
&& tdata
!= NULL
)
8977 if (elf_tdata (abfd
)->o
!= NULL
&& elf_shstrtab (abfd
) != NULL
)
8978 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
8979 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
8982 return _bfd_generic_close_and_cleanup (abfd
);
8985 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
8986 in the relocation's offset. Thus we cannot allow any sort of sanity
8987 range-checking to interfere. There is nothing else to do in processing
8990 bfd_reloc_status_type
8991 _bfd_elf_rel_vtable_reloc_fn
8992 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
8993 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
8994 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
8995 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
8997 return bfd_reloc_ok
;
9000 /* Elf core file support. Much of this only works on native
9001 toolchains, since we rely on knowing the
9002 machine-dependent procfs structure in order to pick
9003 out details about the corefile. */
9005 #ifdef HAVE_SYS_PROCFS_H
9006 /* Needed for new procfs interface on sparc-solaris. */
9007 # define _STRUCTURED_PROC 1
9008 # include <sys/procfs.h>
9011 /* Return a PID that identifies a "thread" for threaded cores, or the
9012 PID of the main process for non-threaded cores. */
9015 elfcore_make_pid (bfd
*abfd
)
9019 pid
= elf_tdata (abfd
)->core
->lwpid
;
9021 pid
= elf_tdata (abfd
)->core
->pid
;
9026 /* If there isn't a section called NAME, make one, using
9027 data from SECT. Note, this function will generate a
9028 reference to NAME, so you shouldn't deallocate or
9032 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
9036 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
9039 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
9043 sect2
->size
= sect
->size
;
9044 sect2
->filepos
= sect
->filepos
;
9045 sect2
->alignment_power
= sect
->alignment_power
;
9049 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
9050 actually creates up to two pseudosections:
9051 - For the single-threaded case, a section named NAME, unless
9052 such a section already exists.
9053 - For the multi-threaded case, a section named "NAME/PID", where
9054 PID is elfcore_make_pid (abfd).
9055 Both pseudosections have identical contents. */
9057 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
9063 char *threaded_name
;
9067 /* Build the section name. */
9069 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
9070 len
= strlen (buf
) + 1;
9071 threaded_name
= (char *) bfd_alloc (abfd
, len
);
9072 if (threaded_name
== NULL
)
9074 memcpy (threaded_name
, buf
, len
);
9076 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
9081 sect
->filepos
= filepos
;
9082 sect
->alignment_power
= 2;
9084 return elfcore_maybe_make_sect (abfd
, name
, sect
);
9087 /* prstatus_t exists on:
9089 linux 2.[01] + glibc
9093 #if defined (HAVE_PRSTATUS_T)
9096 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9101 if (note
->descsz
== sizeof (prstatus_t
))
9105 size
= sizeof (prstat
.pr_reg
);
9106 offset
= offsetof (prstatus_t
, pr_reg
);
9107 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9109 /* Do not overwrite the core signal if it
9110 has already been set by another thread. */
9111 if (elf_tdata (abfd
)->core
->signal
== 0)
9112 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9113 if (elf_tdata (abfd
)->core
->pid
== 0)
9114 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9116 /* pr_who exists on:
9119 pr_who doesn't exist on:
9122 #if defined (HAVE_PRSTATUS_T_PR_WHO)
9123 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9125 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9128 #if defined (HAVE_PRSTATUS32_T)
9129 else if (note
->descsz
== sizeof (prstatus32_t
))
9131 /* 64-bit host, 32-bit corefile */
9132 prstatus32_t prstat
;
9134 size
= sizeof (prstat
.pr_reg
);
9135 offset
= offsetof (prstatus32_t
, pr_reg
);
9136 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
9138 /* Do not overwrite the core signal if it
9139 has already been set by another thread. */
9140 if (elf_tdata (abfd
)->core
->signal
== 0)
9141 elf_tdata (abfd
)->core
->signal
= prstat
.pr_cursig
;
9142 if (elf_tdata (abfd
)->core
->pid
== 0)
9143 elf_tdata (abfd
)->core
->pid
= prstat
.pr_pid
;
9145 /* pr_who exists on:
9148 pr_who doesn't exist on:
9151 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
9152 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_who
;
9154 elf_tdata (abfd
)->core
->lwpid
= prstat
.pr_pid
;
9157 #endif /* HAVE_PRSTATUS32_T */
9160 /* Fail - we don't know how to handle any other
9161 note size (ie. data object type). */
9165 /* Make a ".reg/999" section and a ".reg" section. */
9166 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
9167 size
, note
->descpos
+ offset
);
9169 #endif /* defined (HAVE_PRSTATUS_T) */
9171 /* Create a pseudosection containing the exact contents of NOTE. */
9173 elfcore_make_note_pseudosection (bfd
*abfd
,
9175 Elf_Internal_Note
*note
)
9177 return _bfd_elfcore_make_pseudosection (abfd
, name
,
9178 note
->descsz
, note
->descpos
);
9181 /* There isn't a consistent prfpregset_t across platforms,
9182 but it doesn't matter, because we don't have to pick this
9183 data structure apart. */
9186 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9188 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
9191 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
9192 type of NT_PRXFPREG. Just include the whole note's contents
9196 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9198 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
9201 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
9202 with a note type of NT_X86_XSTATE. Just include the whole note's
9203 contents literally. */
9206 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
9208 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
9212 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
9214 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
9218 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
9220 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
9224 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
9226 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
9230 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
9232 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
9236 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
9238 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
9242 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
9244 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
9248 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
9250 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
9254 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
9256 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
9260 elfcore_grok_s390_last_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9262 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-last-break", note
);
9266 elfcore_grok_s390_system_call (bfd
*abfd
, Elf_Internal_Note
*note
)
9268 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-system-call", note
);
9272 elfcore_grok_s390_tdb (bfd
*abfd
, Elf_Internal_Note
*note
)
9274 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-tdb", note
);
9278 elfcore_grok_s390_vxrs_low (bfd
*abfd
, Elf_Internal_Note
*note
)
9280 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-low", note
);
9284 elfcore_grok_s390_vxrs_high (bfd
*abfd
, Elf_Internal_Note
*note
)
9286 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-vxrs-high", note
);
9290 elfcore_grok_s390_gs_cb (bfd
*abfd
, Elf_Internal_Note
*note
)
9292 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-cb", note
);
9296 elfcore_grok_s390_gs_bc (bfd
*abfd
, Elf_Internal_Note
*note
)
9298 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-gs-bc", note
);
9302 elfcore_grok_arm_vfp (bfd
*abfd
, Elf_Internal_Note
*note
)
9304 return elfcore_make_note_pseudosection (abfd
, ".reg-arm-vfp", note
);
9308 elfcore_grok_aarch_tls (bfd
*abfd
, Elf_Internal_Note
*note
)
9310 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-tls", note
);
9314 elfcore_grok_aarch_hw_break (bfd
*abfd
, Elf_Internal_Note
*note
)
9316 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-break", note
);
9320 elfcore_grok_aarch_hw_watch (bfd
*abfd
, Elf_Internal_Note
*note
)
9322 return elfcore_make_note_pseudosection (abfd
, ".reg-aarch-hw-watch", note
);
9325 #if defined (HAVE_PRPSINFO_T)
9326 typedef prpsinfo_t elfcore_psinfo_t
;
9327 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
9328 typedef prpsinfo32_t elfcore_psinfo32_t
;
9332 #if defined (HAVE_PSINFO_T)
9333 typedef psinfo_t elfcore_psinfo_t
;
9334 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
9335 typedef psinfo32_t elfcore_psinfo32_t
;
9339 /* return a malloc'ed copy of a string at START which is at
9340 most MAX bytes long, possibly without a terminating '\0'.
9341 the copy will always have a terminating '\0'. */
9344 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
9347 char *end
= (char *) memchr (start
, '\0', max
);
9355 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
9359 memcpy (dups
, start
, len
);
9365 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9367 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9369 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
9371 elfcore_psinfo_t psinfo
;
9373 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9375 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
9376 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9378 elf_tdata (abfd
)->core
->program
9379 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9380 sizeof (psinfo
.pr_fname
));
9382 elf_tdata (abfd
)->core
->command
9383 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9384 sizeof (psinfo
.pr_psargs
));
9386 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9387 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
9389 /* 64-bit host, 32-bit corefile */
9390 elfcore_psinfo32_t psinfo
;
9392 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
9394 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
9395 elf_tdata (abfd
)->core
->pid
= psinfo
.pr_pid
;
9397 elf_tdata (abfd
)->core
->program
9398 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
9399 sizeof (psinfo
.pr_fname
));
9401 elf_tdata (abfd
)->core
->command
9402 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
9403 sizeof (psinfo
.pr_psargs
));
9409 /* Fail - we don't know how to handle any other
9410 note size (ie. data object type). */
9414 /* Note that for some reason, a spurious space is tacked
9415 onto the end of the args in some (at least one anyway)
9416 implementations, so strip it off if it exists. */
9419 char *command
= elf_tdata (abfd
)->core
->command
;
9420 int n
= strlen (command
);
9422 if (0 < n
&& command
[n
- 1] == ' ')
9423 command
[n
- 1] = '\0';
9428 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
9430 #if defined (HAVE_PSTATUS_T)
9432 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9434 if (note
->descsz
== sizeof (pstatus_t
)
9435 #if defined (HAVE_PXSTATUS_T)
9436 || note
->descsz
== sizeof (pxstatus_t
)
9442 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9444 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9446 #if defined (HAVE_PSTATUS32_T)
9447 else if (note
->descsz
== sizeof (pstatus32_t
))
9449 /* 64-bit host, 32-bit corefile */
9452 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
9454 elf_tdata (abfd
)->core
->pid
= pstat
.pr_pid
;
9457 /* Could grab some more details from the "representative"
9458 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
9459 NT_LWPSTATUS note, presumably. */
9463 #endif /* defined (HAVE_PSTATUS_T) */
9465 #if defined (HAVE_LWPSTATUS_T)
9467 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9469 lwpstatus_t lwpstat
;
9475 if (note
->descsz
!= sizeof (lwpstat
)
9476 #if defined (HAVE_LWPXSTATUS_T)
9477 && note
->descsz
!= sizeof (lwpxstatus_t
)
9482 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
9484 elf_tdata (abfd
)->core
->lwpid
= lwpstat
.pr_lwpid
;
9485 /* Do not overwrite the core signal if it has already been set by
9487 if (elf_tdata (abfd
)->core
->signal
== 0)
9488 elf_tdata (abfd
)->core
->signal
= lwpstat
.pr_cursig
;
9490 /* Make a ".reg/999" section. */
9492 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
9493 len
= strlen (buf
) + 1;
9494 name
= bfd_alloc (abfd
, len
);
9497 memcpy (name
, buf
, len
);
9499 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9503 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9504 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
9505 sect
->filepos
= note
->descpos
9506 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
9509 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9510 sect
->size
= sizeof (lwpstat
.pr_reg
);
9511 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
9514 sect
->alignment_power
= 2;
9516 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9519 /* Make a ".reg2/999" section */
9521 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
9522 len
= strlen (buf
) + 1;
9523 name
= bfd_alloc (abfd
, len
);
9526 memcpy (name
, buf
, len
);
9528 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9532 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9533 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
9534 sect
->filepos
= note
->descpos
9535 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
9538 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
9539 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
9540 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
9543 sect
->alignment_power
= 2;
9545 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
9547 #endif /* defined (HAVE_LWPSTATUS_T) */
9550 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9557 int is_active_thread
;
9560 if (note
->descsz
< 728)
9563 if (! CONST_STRNEQ (note
->namedata
, "win32"))
9566 type
= bfd_get_32 (abfd
, note
->descdata
);
9570 case 1 /* NOTE_INFO_PROCESS */:
9571 /* FIXME: need to add ->core->command. */
9572 /* process_info.pid */
9573 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9574 /* process_info.signal */
9575 elf_tdata (abfd
)->core
->signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
9578 case 2 /* NOTE_INFO_THREAD */:
9579 /* Make a ".reg/999" section. */
9580 /* thread_info.tid */
9581 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
9583 len
= strlen (buf
) + 1;
9584 name
= (char *) bfd_alloc (abfd
, len
);
9588 memcpy (name
, buf
, len
);
9590 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9594 /* sizeof (thread_info.thread_context) */
9596 /* offsetof (thread_info.thread_context) */
9597 sect
->filepos
= note
->descpos
+ 12;
9598 sect
->alignment_power
= 2;
9600 /* thread_info.is_active_thread */
9601 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
9603 if (is_active_thread
)
9604 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
9608 case 3 /* NOTE_INFO_MODULE */:
9609 /* Make a ".module/xxxxxxxx" section. */
9610 /* module_info.base_address */
9611 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
9612 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
9614 len
= strlen (buf
) + 1;
9615 name
= (char *) bfd_alloc (abfd
, len
);
9619 memcpy (name
, buf
, len
);
9621 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
9626 sect
->size
= note
->descsz
;
9627 sect
->filepos
= note
->descpos
;
9628 sect
->alignment_power
= 2;
9639 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9641 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9649 if (bed
->elf_backend_grok_prstatus
)
9650 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
9652 #if defined (HAVE_PRSTATUS_T)
9653 return elfcore_grok_prstatus (abfd
, note
);
9658 #if defined (HAVE_PSTATUS_T)
9660 return elfcore_grok_pstatus (abfd
, note
);
9663 #if defined (HAVE_LWPSTATUS_T)
9665 return elfcore_grok_lwpstatus (abfd
, note
);
9668 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
9669 return elfcore_grok_prfpreg (abfd
, note
);
9671 case NT_WIN32PSTATUS
:
9672 return elfcore_grok_win32pstatus (abfd
, note
);
9674 case NT_PRXFPREG
: /* Linux SSE extension */
9675 if (note
->namesz
== 6
9676 && strcmp (note
->namedata
, "LINUX") == 0)
9677 return elfcore_grok_prxfpreg (abfd
, note
);
9681 case NT_X86_XSTATE
: /* Linux XSAVE extension */
9682 if (note
->namesz
== 6
9683 && strcmp (note
->namedata
, "LINUX") == 0)
9684 return elfcore_grok_xstatereg (abfd
, note
);
9689 if (note
->namesz
== 6
9690 && strcmp (note
->namedata
, "LINUX") == 0)
9691 return elfcore_grok_ppc_vmx (abfd
, note
);
9696 if (note
->namesz
== 6
9697 && strcmp (note
->namedata
, "LINUX") == 0)
9698 return elfcore_grok_ppc_vsx (abfd
, note
);
9702 case NT_S390_HIGH_GPRS
:
9703 if (note
->namesz
== 6
9704 && strcmp (note
->namedata
, "LINUX") == 0)
9705 return elfcore_grok_s390_high_gprs (abfd
, note
);
9710 if (note
->namesz
== 6
9711 && strcmp (note
->namedata
, "LINUX") == 0)
9712 return elfcore_grok_s390_timer (abfd
, note
);
9716 case NT_S390_TODCMP
:
9717 if (note
->namesz
== 6
9718 && strcmp (note
->namedata
, "LINUX") == 0)
9719 return elfcore_grok_s390_todcmp (abfd
, note
);
9723 case NT_S390_TODPREG
:
9724 if (note
->namesz
== 6
9725 && strcmp (note
->namedata
, "LINUX") == 0)
9726 return elfcore_grok_s390_todpreg (abfd
, note
);
9731 if (note
->namesz
== 6
9732 && strcmp (note
->namedata
, "LINUX") == 0)
9733 return elfcore_grok_s390_ctrs (abfd
, note
);
9737 case NT_S390_PREFIX
:
9738 if (note
->namesz
== 6
9739 && strcmp (note
->namedata
, "LINUX") == 0)
9740 return elfcore_grok_s390_prefix (abfd
, note
);
9744 case NT_S390_LAST_BREAK
:
9745 if (note
->namesz
== 6
9746 && strcmp (note
->namedata
, "LINUX") == 0)
9747 return elfcore_grok_s390_last_break (abfd
, note
);
9751 case NT_S390_SYSTEM_CALL
:
9752 if (note
->namesz
== 6
9753 && strcmp (note
->namedata
, "LINUX") == 0)
9754 return elfcore_grok_s390_system_call (abfd
, note
);
9759 if (note
->namesz
== 6
9760 && strcmp (note
->namedata
, "LINUX") == 0)
9761 return elfcore_grok_s390_tdb (abfd
, note
);
9765 case NT_S390_VXRS_LOW
:
9766 if (note
->namesz
== 6
9767 && strcmp (note
->namedata
, "LINUX") == 0)
9768 return elfcore_grok_s390_vxrs_low (abfd
, note
);
9772 case NT_S390_VXRS_HIGH
:
9773 if (note
->namesz
== 6
9774 && strcmp (note
->namedata
, "LINUX") == 0)
9775 return elfcore_grok_s390_vxrs_high (abfd
, note
);
9780 if (note
->namesz
== 6
9781 && strcmp (note
->namedata
, "LINUX") == 0)
9782 return elfcore_grok_s390_gs_cb (abfd
, note
);
9787 if (note
->namesz
== 6
9788 && strcmp (note
->namedata
, "LINUX") == 0)
9789 return elfcore_grok_s390_gs_bc (abfd
, note
);
9794 if (note
->namesz
== 6
9795 && strcmp (note
->namedata
, "LINUX") == 0)
9796 return elfcore_grok_arm_vfp (abfd
, note
);
9801 if (note
->namesz
== 6
9802 && strcmp (note
->namedata
, "LINUX") == 0)
9803 return elfcore_grok_aarch_tls (abfd
, note
);
9807 case NT_ARM_HW_BREAK
:
9808 if (note
->namesz
== 6
9809 && strcmp (note
->namedata
, "LINUX") == 0)
9810 return elfcore_grok_aarch_hw_break (abfd
, note
);
9814 case NT_ARM_HW_WATCH
:
9815 if (note
->namesz
== 6
9816 && strcmp (note
->namedata
, "LINUX") == 0)
9817 return elfcore_grok_aarch_hw_watch (abfd
, note
);
9823 if (bed
->elf_backend_grok_psinfo
)
9824 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
9826 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
9827 return elfcore_grok_psinfo (abfd
, note
);
9834 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
9839 sect
->size
= note
->descsz
;
9840 sect
->filepos
= note
->descpos
;
9841 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
9847 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.file",
9851 return elfcore_make_note_pseudosection (abfd
, ".note.linuxcore.siginfo",
9858 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
9860 struct bfd_build_id
* build_id
;
9862 if (note
->descsz
== 0)
9865 build_id
= bfd_alloc (abfd
, sizeof (struct bfd_build_id
) - 1 + note
->descsz
);
9866 if (build_id
== NULL
)
9869 build_id
->size
= note
->descsz
;
9870 memcpy (build_id
->data
, note
->descdata
, note
->descsz
);
9871 abfd
->build_id
= build_id
;
9877 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9884 case NT_GNU_PROPERTY_TYPE_0
:
9885 return _bfd_elf_parse_gnu_properties (abfd
, note
);
9887 case NT_GNU_BUILD_ID
:
9888 return elfobj_grok_gnu_build_id (abfd
, note
);
9893 elfobj_grok_stapsdt_note_1 (bfd
*abfd
, Elf_Internal_Note
*note
)
9895 struct sdt_note
*cur
=
9896 (struct sdt_note
*) bfd_alloc (abfd
, sizeof (struct sdt_note
)
9899 cur
->next
= (struct sdt_note
*) (elf_tdata (abfd
))->sdt_note_head
;
9900 cur
->size
= (bfd_size_type
) note
->descsz
;
9901 memcpy (cur
->data
, note
->descdata
, note
->descsz
);
9903 elf_tdata (abfd
)->sdt_note_head
= cur
;
9909 elfobj_grok_stapsdt_note (bfd
*abfd
, Elf_Internal_Note
*note
)
9914 return elfobj_grok_stapsdt_note_1 (abfd
, note
);
9922 elfcore_grok_freebsd_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
9926 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
9929 if (note
->descsz
< 108)
9934 if (note
->descsz
< 120)
9942 /* Check for version 1 in pr_version. */
9943 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
9948 /* Skip over pr_psinfosz. */
9949 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
9953 offset
+= 4; /* Padding before pr_psinfosz. */
9957 /* pr_fname is PRFNAMESZ (16) + 1 bytes in size. */
9958 elf_tdata (abfd
)->core
->program
9959 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 17);
9962 /* pr_psargs is PRARGSZ (80) + 1 bytes in size. */
9963 elf_tdata (abfd
)->core
->command
9964 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ offset
, 81);
9967 /* Padding before pr_pid. */
9970 /* The pr_pid field was added in version "1a". */
9971 if (note
->descsz
< offset
+ 4)
9974 elf_tdata (abfd
)->core
->pid
9975 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
9981 elfcore_grok_freebsd_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
9987 /* Compute offset of pr_getregsz, skipping over pr_statussz.
9988 Also compute minimum size of this note. */
9989 switch (elf_elfheader (abfd
)->e_ident
[EI_CLASS
])
9993 min_size
= offset
+ (4 * 2) + 4 + 4 + 4;
9997 offset
= 4 + 4 + 8; /* Includes padding before pr_statussz. */
9998 min_size
= offset
+ (8 * 2) + 4 + 4 + 4 + 4;
10005 if (note
->descsz
< min_size
)
10008 /* Check for version 1 in pr_version. */
10009 if (bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
) != 1)
10012 /* Extract size of pr_reg from pr_gregsetsz. */
10013 /* Skip over pr_gregsetsz and pr_fpregsetsz. */
10014 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS32
)
10016 size
= bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10021 size
= bfd_h_get_64 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10025 /* Skip over pr_osreldate. */
10028 /* Read signal from pr_cursig. */
10029 if (elf_tdata (abfd
)->core
->signal
== 0)
10030 elf_tdata (abfd
)->core
->signal
10031 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10034 /* Read TID from pr_pid. */
10035 elf_tdata (abfd
)->core
->lwpid
10036 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ offset
);
10039 /* Padding before pr_reg. */
10040 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
10043 /* Make sure that there is enough data remaining in the note. */
10044 if ((note
->descsz
- offset
) < size
)
10047 /* Make a ".reg/999" section and a ".reg" section. */
10048 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
10049 size
, note
->descpos
+ offset
);
10053 elfcore_grok_freebsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10055 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10057 switch (note
->type
)
10060 if (bed
->elf_backend_grok_freebsd_prstatus
)
10061 if ((*bed
->elf_backend_grok_freebsd_prstatus
) (abfd
, note
))
10063 return elfcore_grok_freebsd_prstatus (abfd
, note
);
10066 return elfcore_grok_prfpreg (abfd
, note
);
10069 return elfcore_grok_freebsd_psinfo (abfd
, note
);
10071 case NT_FREEBSD_THRMISC
:
10072 if (note
->namesz
== 8)
10073 return elfcore_make_note_pseudosection (abfd
, ".thrmisc", note
);
10077 case NT_FREEBSD_PROCSTAT_PROC
:
10078 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.proc",
10081 case NT_FREEBSD_PROCSTAT_FILES
:
10082 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.files",
10085 case NT_FREEBSD_PROCSTAT_VMMAP
:
10086 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.vmmap",
10089 case NT_FREEBSD_PROCSTAT_AUXV
:
10091 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
10096 sect
->size
= note
->descsz
- 4;
10097 sect
->filepos
= note
->descpos
+ 4;
10098 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10103 case NT_X86_XSTATE
:
10104 if (note
->namesz
== 8)
10105 return elfcore_grok_xstatereg (abfd
, note
);
10109 case NT_FREEBSD_PTLWPINFO
:
10110 return elfcore_make_note_pseudosection (abfd
, ".note.freebsdcore.lwpinfo",
10114 return elfcore_grok_arm_vfp (abfd
, note
);
10122 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
10126 cp
= strchr (note
->namedata
, '@');
10129 *lwpidp
= atoi(cp
+ 1);
10136 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10138 if (note
->descsz
<= 0x7c + 31)
10141 /* Signal number at offset 0x08. */
10142 elf_tdata (abfd
)->core
->signal
10143 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10145 /* Process ID at offset 0x50. */
10146 elf_tdata (abfd
)->core
->pid
10147 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
10149 /* Command name at 0x7c (max 32 bytes, including nul). */
10150 elf_tdata (abfd
)->core
->command
10151 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
10153 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
10158 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10162 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
10163 elf_tdata (abfd
)->core
->lwpid
= lwp
;
10165 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
10167 /* NetBSD-specific core "procinfo". Note that we expect to
10168 find this note before any of the others, which is fine,
10169 since the kernel writes this note out first when it
10170 creates a core file. */
10172 return elfcore_grok_netbsd_procinfo (abfd
, note
);
10175 /* As of Jan 2002 there are no other machine-independent notes
10176 defined for NetBSD core files. If the note type is less
10177 than the start of the machine-dependent note types, we don't
10180 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
10184 switch (bfd_get_arch (abfd
))
10186 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
10187 PT_GETFPREGS == mach+2. */
10189 case bfd_arch_alpha
:
10190 case bfd_arch_sparc
:
10191 switch (note
->type
)
10193 case NT_NETBSDCORE_FIRSTMACH
+0:
10194 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10196 case NT_NETBSDCORE_FIRSTMACH
+2:
10197 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10203 /* On all other arch's, PT_GETREGS == mach+1 and
10204 PT_GETFPREGS == mach+3. */
10207 switch (note
->type
)
10209 case NT_NETBSDCORE_FIRSTMACH
+1:
10210 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10212 case NT_NETBSDCORE_FIRSTMACH
+3:
10213 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10223 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
10225 if (note
->descsz
<= 0x48 + 31)
10228 /* Signal number at offset 0x08. */
10229 elf_tdata (abfd
)->core
->signal
10230 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
10232 /* Process ID at offset 0x20. */
10233 elf_tdata (abfd
)->core
->pid
10234 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
10236 /* Command name at 0x48 (max 32 bytes, including nul). */
10237 elf_tdata (abfd
)->core
->command
10238 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
10244 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10246 if (note
->type
== NT_OPENBSD_PROCINFO
)
10247 return elfcore_grok_openbsd_procinfo (abfd
, note
);
10249 if (note
->type
== NT_OPENBSD_REGS
)
10250 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
10252 if (note
->type
== NT_OPENBSD_FPREGS
)
10253 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
10255 if (note
->type
== NT_OPENBSD_XFPREGS
)
10256 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
10258 if (note
->type
== NT_OPENBSD_AUXV
)
10260 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
10265 sect
->size
= note
->descsz
;
10266 sect
->filepos
= note
->descpos
;
10267 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10272 if (note
->type
== NT_OPENBSD_WCOOKIE
)
10274 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
10279 sect
->size
= note
->descsz
;
10280 sect
->filepos
= note
->descpos
;
10281 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
10290 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
10292 void *ddata
= note
->descdata
;
10299 if (note
->descsz
< 16)
10302 /* nto_procfs_status 'pid' field is at offset 0. */
10303 elf_tdata (abfd
)->core
->pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
10305 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
10306 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
10308 /* nto_procfs_status 'flags' field is at offset 8. */
10309 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
10311 /* nto_procfs_status 'what' field is at offset 14. */
10312 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
10314 elf_tdata (abfd
)->core
->signal
= sig
;
10315 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10318 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
10319 do not come from signals so we make sure we set the current
10320 thread just in case. */
10321 if (flags
& 0x00000080)
10322 elf_tdata (abfd
)->core
->lwpid
= *tid
;
10324 /* Make a ".qnx_core_status/%d" section. */
10325 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
10327 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10330 strcpy (name
, buf
);
10332 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10336 sect
->size
= note
->descsz
;
10337 sect
->filepos
= note
->descpos
;
10338 sect
->alignment_power
= 2;
10340 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
10344 elfcore_grok_nto_regs (bfd
*abfd
,
10345 Elf_Internal_Note
*note
,
10353 /* Make a "(base)/%d" section. */
10354 sprintf (buf
, "%s/%ld", base
, tid
);
10356 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
10359 strcpy (name
, buf
);
10361 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10365 sect
->size
= note
->descsz
;
10366 sect
->filepos
= note
->descpos
;
10367 sect
->alignment_power
= 2;
10369 /* This is the current thread. */
10370 if (elf_tdata (abfd
)->core
->lwpid
== tid
)
10371 return elfcore_maybe_make_sect (abfd
, base
, sect
);
10376 #define BFD_QNT_CORE_INFO 7
10377 #define BFD_QNT_CORE_STATUS 8
10378 #define BFD_QNT_CORE_GREG 9
10379 #define BFD_QNT_CORE_FPREG 10
10382 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10384 /* Every GREG section has a STATUS section before it. Store the
10385 tid from the previous call to pass down to the next gregs
10387 static long tid
= 1;
10389 switch (note
->type
)
10391 case BFD_QNT_CORE_INFO
:
10392 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
10393 case BFD_QNT_CORE_STATUS
:
10394 return elfcore_grok_nto_status (abfd
, note
, &tid
);
10395 case BFD_QNT_CORE_GREG
:
10396 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
10397 case BFD_QNT_CORE_FPREG
:
10398 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
10405 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
10411 /* Use note name as section name. */
10412 len
= note
->namesz
;
10413 name
= (char *) bfd_alloc (abfd
, len
);
10416 memcpy (name
, note
->namedata
, len
);
10417 name
[len
- 1] = '\0';
10419 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
10423 sect
->size
= note
->descsz
;
10424 sect
->filepos
= note
->descpos
;
10425 sect
->alignment_power
= 1;
10430 /* Function: elfcore_write_note
10433 buffer to hold note, and current size of buffer
10437 size of data for note
10439 Writes note to end of buffer. ELF64 notes are written exactly as
10440 for ELF32, despite the current (as of 2006) ELF gabi specifying
10441 that they ought to have 8-byte namesz and descsz field, and have
10442 8-byte alignment. Other writers, eg. Linux kernel, do the same.
10445 Pointer to realloc'd buffer, *BUFSIZ updated. */
10448 elfcore_write_note (bfd
*abfd
,
10456 Elf_External_Note
*xnp
;
10463 namesz
= strlen (name
) + 1;
10465 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
10467 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
10470 dest
= buf
+ *bufsiz
;
10471 *bufsiz
+= newspace
;
10472 xnp
= (Elf_External_Note
*) dest
;
10473 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
10474 H_PUT_32 (abfd
, size
, xnp
->descsz
);
10475 H_PUT_32 (abfd
, type
, xnp
->type
);
10479 memcpy (dest
, name
, namesz
);
10487 memcpy (dest
, input
, size
);
10498 elfcore_write_prpsinfo (bfd
*abfd
,
10502 const char *psargs
)
10504 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10506 if (bed
->elf_backend_write_core_note
!= NULL
)
10509 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
10510 NT_PRPSINFO
, fname
, psargs
);
10515 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
10516 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
10517 if (bed
->s
->elfclass
== ELFCLASS32
)
10519 #if defined (HAVE_PSINFO32_T)
10521 int note_type
= NT_PSINFO
;
10524 int note_type
= NT_PRPSINFO
;
10527 memset (&data
, 0, sizeof (data
));
10528 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
10529 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
10530 return elfcore_write_note (abfd
, buf
, bufsiz
,
10531 "CORE", note_type
, &data
, sizeof (data
));
10536 #if defined (HAVE_PSINFO_T)
10538 int note_type
= NT_PSINFO
;
10541 int note_type
= NT_PRPSINFO
;
10544 memset (&data
, 0, sizeof (data
));
10545 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
10546 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
10547 return elfcore_write_note (abfd
, buf
, bufsiz
,
10548 "CORE", note_type
, &data
, sizeof (data
));
10550 #endif /* PSINFO_T or PRPSINFO_T */
10557 elfcore_write_linux_prpsinfo32
10558 (bfd
*abfd
, char *buf
, int *bufsiz
,
10559 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
10561 if (get_elf_backend_data (abfd
)->linux_prpsinfo32_ugid16
)
10563 struct elf_external_linux_prpsinfo32_ugid16 data
;
10565 swap_linux_prpsinfo32_ugid16_out (abfd
, prpsinfo
, &data
);
10566 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
10567 &data
, sizeof (data
));
10571 struct elf_external_linux_prpsinfo32_ugid32 data
;
10573 swap_linux_prpsinfo32_ugid32_out (abfd
, prpsinfo
, &data
);
10574 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE", NT_PRPSINFO
,
10575 &data
, sizeof (data
));
10580 elfcore_write_linux_prpsinfo64
10581 (bfd
*abfd
, char *buf
, int *bufsiz
,
10582 const struct elf_internal_linux_prpsinfo
*prpsinfo
)
10584 if (get_elf_backend_data (abfd
)->linux_prpsinfo64_ugid16
)
10586 struct elf_external_linux_prpsinfo64_ugid16 data
;
10588 swap_linux_prpsinfo64_ugid16_out (abfd
, prpsinfo
, &data
);
10589 return elfcore_write_note (abfd
, buf
, bufsiz
,
10590 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
10594 struct elf_external_linux_prpsinfo64_ugid32 data
;
10596 swap_linux_prpsinfo64_ugid32_out (abfd
, prpsinfo
, &data
);
10597 return elfcore_write_note (abfd
, buf
, bufsiz
,
10598 "CORE", NT_PRPSINFO
, &data
, sizeof (data
));
10603 elfcore_write_prstatus (bfd
*abfd
,
10610 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10612 if (bed
->elf_backend_write_core_note
!= NULL
)
10615 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
10617 pid
, cursig
, gregs
);
10622 #if defined (HAVE_PRSTATUS_T)
10623 #if defined (HAVE_PRSTATUS32_T)
10624 if (bed
->s
->elfclass
== ELFCLASS32
)
10626 prstatus32_t prstat
;
10628 memset (&prstat
, 0, sizeof (prstat
));
10629 prstat
.pr_pid
= pid
;
10630 prstat
.pr_cursig
= cursig
;
10631 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
10632 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
10633 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
10640 memset (&prstat
, 0, sizeof (prstat
));
10641 prstat
.pr_pid
= pid
;
10642 prstat
.pr_cursig
= cursig
;
10643 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
10644 return elfcore_write_note (abfd
, buf
, bufsiz
, "CORE",
10645 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
10647 #endif /* HAVE_PRSTATUS_T */
10653 #if defined (HAVE_LWPSTATUS_T)
10655 elfcore_write_lwpstatus (bfd
*abfd
,
10662 lwpstatus_t lwpstat
;
10663 const char *note_name
= "CORE";
10665 memset (&lwpstat
, 0, sizeof (lwpstat
));
10666 lwpstat
.pr_lwpid
= pid
>> 16;
10667 lwpstat
.pr_cursig
= cursig
;
10668 #if defined (HAVE_LWPSTATUS_T_PR_REG)
10669 memcpy (&lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
10670 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
10671 #if !defined(gregs)
10672 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
10673 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
10675 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
10676 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
10679 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
10680 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
10682 #endif /* HAVE_LWPSTATUS_T */
10684 #if defined (HAVE_PSTATUS_T)
10686 elfcore_write_pstatus (bfd
*abfd
,
10690 int cursig ATTRIBUTE_UNUSED
,
10691 const void *gregs ATTRIBUTE_UNUSED
)
10693 const char *note_name
= "CORE";
10694 #if defined (HAVE_PSTATUS32_T)
10695 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
10697 if (bed
->s
->elfclass
== ELFCLASS32
)
10701 memset (&pstat
, 0, sizeof (pstat
));
10702 pstat
.pr_pid
= pid
& 0xffff;
10703 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
10704 NT_PSTATUS
, &pstat
, sizeof (pstat
));
10712 memset (&pstat
, 0, sizeof (pstat
));
10713 pstat
.pr_pid
= pid
& 0xffff;
10714 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
10715 NT_PSTATUS
, &pstat
, sizeof (pstat
));
10719 #endif /* HAVE_PSTATUS_T */
10722 elfcore_write_prfpreg (bfd
*abfd
,
10725 const void *fpregs
,
10728 const char *note_name
= "CORE";
10729 return elfcore_write_note (abfd
, buf
, bufsiz
,
10730 note_name
, NT_FPREGSET
, fpregs
, size
);
10734 elfcore_write_prxfpreg (bfd
*abfd
,
10737 const void *xfpregs
,
10740 char *note_name
= "LINUX";
10741 return elfcore_write_note (abfd
, buf
, bufsiz
,
10742 note_name
, NT_PRXFPREG
, xfpregs
, size
);
10746 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
10747 const void *xfpregs
, int size
)
10750 if (get_elf_backend_data (abfd
)->elf_osabi
== ELFOSABI_FREEBSD
)
10751 note_name
= "FreeBSD";
10753 note_name
= "LINUX";
10754 return elfcore_write_note (abfd
, buf
, bufsiz
,
10755 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
10759 elfcore_write_ppc_vmx (bfd
*abfd
,
10762 const void *ppc_vmx
,
10765 char *note_name
= "LINUX";
10766 return elfcore_write_note (abfd
, buf
, bufsiz
,
10767 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
10771 elfcore_write_ppc_vsx (bfd
*abfd
,
10774 const void *ppc_vsx
,
10777 char *note_name
= "LINUX";
10778 return elfcore_write_note (abfd
, buf
, bufsiz
,
10779 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
10783 elfcore_write_s390_high_gprs (bfd
*abfd
,
10786 const void *s390_high_gprs
,
10789 char *note_name
= "LINUX";
10790 return elfcore_write_note (abfd
, buf
, bufsiz
,
10791 note_name
, NT_S390_HIGH_GPRS
,
10792 s390_high_gprs
, size
);
10796 elfcore_write_s390_timer (bfd
*abfd
,
10799 const void *s390_timer
,
10802 char *note_name
= "LINUX";
10803 return elfcore_write_note (abfd
, buf
, bufsiz
,
10804 note_name
, NT_S390_TIMER
, s390_timer
, size
);
10808 elfcore_write_s390_todcmp (bfd
*abfd
,
10811 const void *s390_todcmp
,
10814 char *note_name
= "LINUX";
10815 return elfcore_write_note (abfd
, buf
, bufsiz
,
10816 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
10820 elfcore_write_s390_todpreg (bfd
*abfd
,
10823 const void *s390_todpreg
,
10826 char *note_name
= "LINUX";
10827 return elfcore_write_note (abfd
, buf
, bufsiz
,
10828 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
10832 elfcore_write_s390_ctrs (bfd
*abfd
,
10835 const void *s390_ctrs
,
10838 char *note_name
= "LINUX";
10839 return elfcore_write_note (abfd
, buf
, bufsiz
,
10840 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
10844 elfcore_write_s390_prefix (bfd
*abfd
,
10847 const void *s390_prefix
,
10850 char *note_name
= "LINUX";
10851 return elfcore_write_note (abfd
, buf
, bufsiz
,
10852 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
10856 elfcore_write_s390_last_break (bfd
*abfd
,
10859 const void *s390_last_break
,
10862 char *note_name
= "LINUX";
10863 return elfcore_write_note (abfd
, buf
, bufsiz
,
10864 note_name
, NT_S390_LAST_BREAK
,
10865 s390_last_break
, size
);
10869 elfcore_write_s390_system_call (bfd
*abfd
,
10872 const void *s390_system_call
,
10875 char *note_name
= "LINUX";
10876 return elfcore_write_note (abfd
, buf
, bufsiz
,
10877 note_name
, NT_S390_SYSTEM_CALL
,
10878 s390_system_call
, size
);
10882 elfcore_write_s390_tdb (bfd
*abfd
,
10885 const void *s390_tdb
,
10888 char *note_name
= "LINUX";
10889 return elfcore_write_note (abfd
, buf
, bufsiz
,
10890 note_name
, NT_S390_TDB
, s390_tdb
, size
);
10894 elfcore_write_s390_vxrs_low (bfd
*abfd
,
10897 const void *s390_vxrs_low
,
10900 char *note_name
= "LINUX";
10901 return elfcore_write_note (abfd
, buf
, bufsiz
,
10902 note_name
, NT_S390_VXRS_LOW
, s390_vxrs_low
, size
);
10906 elfcore_write_s390_vxrs_high (bfd
*abfd
,
10909 const void *s390_vxrs_high
,
10912 char *note_name
= "LINUX";
10913 return elfcore_write_note (abfd
, buf
, bufsiz
,
10914 note_name
, NT_S390_VXRS_HIGH
,
10915 s390_vxrs_high
, size
);
10919 elfcore_write_s390_gs_cb (bfd
*abfd
,
10922 const void *s390_gs_cb
,
10925 char *note_name
= "LINUX";
10926 return elfcore_write_note (abfd
, buf
, bufsiz
,
10927 note_name
, NT_S390_GS_CB
,
10932 elfcore_write_s390_gs_bc (bfd
*abfd
,
10935 const void *s390_gs_bc
,
10938 char *note_name
= "LINUX";
10939 return elfcore_write_note (abfd
, buf
, bufsiz
,
10940 note_name
, NT_S390_GS_BC
,
10945 elfcore_write_arm_vfp (bfd
*abfd
,
10948 const void *arm_vfp
,
10951 char *note_name
= "LINUX";
10952 return elfcore_write_note (abfd
, buf
, bufsiz
,
10953 note_name
, NT_ARM_VFP
, arm_vfp
, size
);
10957 elfcore_write_aarch_tls (bfd
*abfd
,
10960 const void *aarch_tls
,
10963 char *note_name
= "LINUX";
10964 return elfcore_write_note (abfd
, buf
, bufsiz
,
10965 note_name
, NT_ARM_TLS
, aarch_tls
, size
);
10969 elfcore_write_aarch_hw_break (bfd
*abfd
,
10972 const void *aarch_hw_break
,
10975 char *note_name
= "LINUX";
10976 return elfcore_write_note (abfd
, buf
, bufsiz
,
10977 note_name
, NT_ARM_HW_BREAK
, aarch_hw_break
, size
);
10981 elfcore_write_aarch_hw_watch (bfd
*abfd
,
10984 const void *aarch_hw_watch
,
10987 char *note_name
= "LINUX";
10988 return elfcore_write_note (abfd
, buf
, bufsiz
,
10989 note_name
, NT_ARM_HW_WATCH
, aarch_hw_watch
, size
);
10993 elfcore_write_register_note (bfd
*abfd
,
10996 const char *section
,
11000 if (strcmp (section
, ".reg2") == 0)
11001 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
11002 if (strcmp (section
, ".reg-xfp") == 0)
11003 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
11004 if (strcmp (section
, ".reg-xstate") == 0)
11005 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
11006 if (strcmp (section
, ".reg-ppc-vmx") == 0)
11007 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
11008 if (strcmp (section
, ".reg-ppc-vsx") == 0)
11009 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
11010 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
11011 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
11012 if (strcmp (section
, ".reg-s390-timer") == 0)
11013 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
11014 if (strcmp (section
, ".reg-s390-todcmp") == 0)
11015 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
11016 if (strcmp (section
, ".reg-s390-todpreg") == 0)
11017 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
11018 if (strcmp (section
, ".reg-s390-ctrs") == 0)
11019 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
11020 if (strcmp (section
, ".reg-s390-prefix") == 0)
11021 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
11022 if (strcmp (section
, ".reg-s390-last-break") == 0)
11023 return elfcore_write_s390_last_break (abfd
, buf
, bufsiz
, data
, size
);
11024 if (strcmp (section
, ".reg-s390-system-call") == 0)
11025 return elfcore_write_s390_system_call (abfd
, buf
, bufsiz
, data
, size
);
11026 if (strcmp (section
, ".reg-s390-tdb") == 0)
11027 return elfcore_write_s390_tdb (abfd
, buf
, bufsiz
, data
, size
);
11028 if (strcmp (section
, ".reg-s390-vxrs-low") == 0)
11029 return elfcore_write_s390_vxrs_low (abfd
, buf
, bufsiz
, data
, size
);
11030 if (strcmp (section
, ".reg-s390-vxrs-high") == 0)
11031 return elfcore_write_s390_vxrs_high (abfd
, buf
, bufsiz
, data
, size
);
11032 if (strcmp (section
, ".reg-s390-gs-cb") == 0)
11033 return elfcore_write_s390_gs_cb (abfd
, buf
, bufsiz
, data
, size
);
11034 if (strcmp (section
, ".reg-s390-gs-bc") == 0)
11035 return elfcore_write_s390_gs_bc (abfd
, buf
, bufsiz
, data
, size
);
11036 if (strcmp (section
, ".reg-arm-vfp") == 0)
11037 return elfcore_write_arm_vfp (abfd
, buf
, bufsiz
, data
, size
);
11038 if (strcmp (section
, ".reg-aarch-tls") == 0)
11039 return elfcore_write_aarch_tls (abfd
, buf
, bufsiz
, data
, size
);
11040 if (strcmp (section
, ".reg-aarch-hw-break") == 0)
11041 return elfcore_write_aarch_hw_break (abfd
, buf
, bufsiz
, data
, size
);
11042 if (strcmp (section
, ".reg-aarch-hw-watch") == 0)
11043 return elfcore_write_aarch_hw_watch (abfd
, buf
, bufsiz
, data
, size
);
11048 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
,
11053 /* NB: CORE PT_NOTE segments may have p_align values of 0 or 1.
11054 gABI specifies that PT_NOTE alignment should be aligned to 4
11055 bytes for 32-bit objects and to 8 bytes for 64-bit objects. If
11056 align is less than 4, we use 4 byte alignment. */
11059 if (align
!= 4 && align
!= 8)
11063 while (p
< buf
+ size
)
11065 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
11066 Elf_Internal_Note in
;
11068 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
11071 in
.type
= H_GET_32 (abfd
, xnp
->type
);
11073 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
11074 in
.namedata
= xnp
->name
;
11075 if (in
.namesz
> buf
- in
.namedata
+ size
)
11078 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
11079 in
.descdata
= p
+ ELF_NOTE_DESC_OFFSET (in
.namesz
, align
);
11080 in
.descpos
= offset
+ (in
.descdata
- buf
);
11082 && (in
.descdata
>= buf
+ size
11083 || in
.descsz
> buf
- in
.descdata
+ size
))
11086 switch (bfd_get_format (abfd
))
11093 #define GROKER_ELEMENT(S,F) {S, sizeof (S) - 1, F}
11096 const char * string
;
11098 bfd_boolean (* func
)(bfd
*, Elf_Internal_Note
*);
11102 GROKER_ELEMENT ("", elfcore_grok_note
),
11103 GROKER_ELEMENT ("FreeBSD", elfcore_grok_freebsd_note
),
11104 GROKER_ELEMENT ("NetBSD-CORE", elfcore_grok_netbsd_note
),
11105 GROKER_ELEMENT ( "OpenBSD", elfcore_grok_openbsd_note
),
11106 GROKER_ELEMENT ("QNX", elfcore_grok_nto_note
),
11107 GROKER_ELEMENT ("SPU/", elfcore_grok_spu_note
)
11109 #undef GROKER_ELEMENT
11112 for (i
= ARRAY_SIZE (grokers
); i
--;)
11114 if (in
.namesz
>= grokers
[i
].len
11115 && strncmp (in
.namedata
, grokers
[i
].string
,
11116 grokers
[i
].len
) == 0)
11118 if (! grokers
[i
].func (abfd
, & in
))
11127 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
11129 if (! elfobj_grok_gnu_note (abfd
, &in
))
11132 else if (in
.namesz
== sizeof "stapsdt"
11133 && strcmp (in
.namedata
, "stapsdt") == 0)
11135 if (! elfobj_grok_stapsdt_note (abfd
, &in
))
11141 p
+= ELF_NOTE_NEXT_OFFSET (in
.namesz
, in
.descsz
, align
);
11148 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
,
11153 if (size
== 0 || (size
+ 1) == 0)
11156 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
11159 buf
= (char *) bfd_malloc (size
+ 1);
11163 /* PR 17512: file: ec08f814
11164 0-termintate the buffer so that string searches will not overflow. */
11167 if (bfd_bread (buf
, size
, abfd
) != size
11168 || !elf_parse_notes (abfd
, buf
, size
, offset
, align
))
11178 /* Providing external access to the ELF program header table. */
11180 /* Return an upper bound on the number of bytes required to store a
11181 copy of ABFD's program header table entries. Return -1 if an error
11182 occurs; bfd_get_error will return an appropriate code. */
11185 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
11187 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11189 bfd_set_error (bfd_error_wrong_format
);
11193 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
11196 /* Copy ABFD's program header table entries to *PHDRS. The entries
11197 will be stored as an array of Elf_Internal_Phdr structures, as
11198 defined in include/elf/internal.h. To find out how large the
11199 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
11201 Return the number of program header table entries read, or -1 if an
11202 error occurs; bfd_get_error will return an appropriate code. */
11205 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
11209 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
11211 bfd_set_error (bfd_error_wrong_format
);
11215 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
11216 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
11217 num_phdrs
* sizeof (Elf_Internal_Phdr
));
11222 enum elf_reloc_type_class
11223 _bfd_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
11224 const asection
*rel_sec ATTRIBUTE_UNUSED
,
11225 const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
11227 return reloc_class_normal
;
11230 /* For RELA architectures, return the relocation value for a
11231 relocation against a local symbol. */
11234 _bfd_elf_rela_local_sym (bfd
*abfd
,
11235 Elf_Internal_Sym
*sym
,
11237 Elf_Internal_Rela
*rel
)
11239 asection
*sec
= *psec
;
11240 bfd_vma relocation
;
11242 relocation
= (sec
->output_section
->vma
11243 + sec
->output_offset
11245 if ((sec
->flags
& SEC_MERGE
)
11246 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
11247 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
11250 _bfd_merged_section_offset (abfd
, psec
,
11251 elf_section_data (sec
)->sec_info
,
11252 sym
->st_value
+ rel
->r_addend
);
11255 /* If we have changed the section, and our original section is
11256 marked with SEC_EXCLUDE, it means that the original
11257 SEC_MERGE section has been completely subsumed in some
11258 other SEC_MERGE section. In this case, we need to leave
11259 some info around for --emit-relocs. */
11260 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
11261 sec
->kept_section
= *psec
;
11264 rel
->r_addend
-= relocation
;
11265 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
11271 _bfd_elf_rel_local_sym (bfd
*abfd
,
11272 Elf_Internal_Sym
*sym
,
11276 asection
*sec
= *psec
;
11278 if (sec
->sec_info_type
!= SEC_INFO_TYPE_MERGE
)
11279 return sym
->st_value
+ addend
;
11281 return _bfd_merged_section_offset (abfd
, psec
,
11282 elf_section_data (sec
)->sec_info
,
11283 sym
->st_value
+ addend
);
11286 /* Adjust an address within a section. Given OFFSET within SEC, return
11287 the new offset within the section, based upon changes made to the
11288 section. Returns -1 if the offset is now invalid.
11289 The offset (in abnd out) is in target sized bytes, however big a
11293 _bfd_elf_section_offset (bfd
*abfd
,
11294 struct bfd_link_info
*info
,
11298 switch (sec
->sec_info_type
)
11300 case SEC_INFO_TYPE_STABS
:
11301 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
11303 case SEC_INFO_TYPE_EH_FRAME
:
11304 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
11307 if ((sec
->flags
& SEC_ELF_REVERSE_COPY
) != 0)
11309 /* Reverse the offset. */
11310 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11311 bfd_size_type address_size
= bed
->s
->arch_size
/ 8;
11313 /* address_size and sec->size are in octets. Convert
11314 to bytes before subtracting the original offset. */
11315 offset
= (sec
->size
- address_size
) / bfd_octets_per_byte (abfd
) - offset
;
11321 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
11322 reconstruct an ELF file by reading the segments out of remote memory
11323 based on the ELF file header at EHDR_VMA and the ELF program headers it
11324 points to. If not null, *LOADBASEP is filled in with the difference
11325 between the VMAs from which the segments were read, and the VMAs the
11326 file headers (and hence BFD's idea of each section's VMA) put them at.
11328 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
11329 remote memory at target address VMA into the local buffer at MYADDR; it
11330 should return zero on success or an `errno' code on failure. TEMPL must
11331 be a BFD for an ELF target with the word size and byte order found in
11332 the remote memory. */
11335 bfd_elf_bfd_from_remote_memory
11338 bfd_size_type size
,
11339 bfd_vma
*loadbasep
,
11340 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
11342 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
11343 (templ
, ehdr_vma
, size
, loadbasep
, target_read_memory
);
11347 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
11348 long symcount ATTRIBUTE_UNUSED
,
11349 asymbol
**syms ATTRIBUTE_UNUSED
,
11354 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
11357 const char *relplt_name
;
11358 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
11362 Elf_Internal_Shdr
*hdr
;
11368 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
11371 if (dynsymcount
<= 0)
11374 if (!bed
->plt_sym_val
)
11377 relplt_name
= bed
->relplt_name
;
11378 if (relplt_name
== NULL
)
11379 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
11380 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
11381 if (relplt
== NULL
)
11384 hdr
= &elf_section_data (relplt
)->this_hdr
;
11385 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
11386 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
11389 plt
= bfd_get_section_by_name (abfd
, ".plt");
11393 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
11394 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
11397 count
= relplt
->size
/ hdr
->sh_entsize
;
11398 size
= count
* sizeof (asymbol
);
11399 p
= relplt
->relocation
;
11400 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
11402 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
11403 if (p
->addend
!= 0)
11406 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
11408 size
+= sizeof ("+0x") - 1 + 8;
11413 s
= *ret
= (asymbol
*) bfd_malloc (size
);
11417 names
= (char *) (s
+ count
);
11418 p
= relplt
->relocation
;
11420 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
11425 addr
= bed
->plt_sym_val (i
, plt
, p
);
11426 if (addr
== (bfd_vma
) -1)
11429 *s
= **p
->sym_ptr_ptr
;
11430 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
11431 we are defining a symbol, ensure one of them is set. */
11432 if ((s
->flags
& BSF_LOCAL
) == 0)
11433 s
->flags
|= BSF_GLOBAL
;
11434 s
->flags
|= BSF_SYNTHETIC
;
11436 s
->value
= addr
- plt
->vma
;
11439 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
11440 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
11442 if (p
->addend
!= 0)
11446 memcpy (names
, "+0x", sizeof ("+0x") - 1);
11447 names
+= sizeof ("+0x") - 1;
11448 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
11449 for (a
= buf
; *a
== '0'; ++a
)
11452 memcpy (names
, a
, len
);
11455 memcpy (names
, "@plt", sizeof ("@plt"));
11456 names
+= sizeof ("@plt");
11463 /* It is only used by x86-64 so far.
11464 ??? This repeats *COM* id of zero. sec->id is supposed to be unique,
11465 but current usage would allow all of _bfd_std_section to be zero. */
11466 static const asymbol lcomm_sym
11467 = GLOBAL_SYM_INIT ("LARGE_COMMON", &_bfd_elf_large_com_section
);
11468 asection _bfd_elf_large_com_section
11469 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
, &lcomm_sym
,
11470 "LARGE_COMMON", 0, SEC_IS_COMMON
);
11473 _bfd_elf_post_process_headers (bfd
* abfd
,
11474 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
11476 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
11478 i_ehdrp
= elf_elfheader (abfd
);
11480 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
11482 /* To make things simpler for the loader on Linux systems we set the
11483 osabi field to ELFOSABI_GNU if the binary contains symbols of
11484 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
11485 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
11486 && elf_tdata (abfd
)->has_gnu_symbols
)
11487 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_GNU
;
11491 /* Return TRUE for ELF symbol types that represent functions.
11492 This is the default version of this function, which is sufficient for
11493 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
11496 _bfd_elf_is_function_type (unsigned int type
)
11498 return (type
== STT_FUNC
11499 || type
== STT_GNU_IFUNC
);
11502 /* If the ELF symbol SYM might be a function in SEC, return the
11503 function size and set *CODE_OFF to the function's entry point,
11504 otherwise return zero. */
11507 _bfd_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
11510 bfd_size_type size
;
11512 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
11513 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0
11514 || sym
->section
!= sec
)
11517 *code_off
= sym
->value
;
11519 if (!(sym
->flags
& BSF_SYNTHETIC
))
11520 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;