1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
29 BFD support for ELF formats is being worked on.
30 Currently, the best supported back ends are for sparc and i386
31 (running svr4 or Solaris 2).
33 Documentation of the internals of the support code still needs
34 to be written. The code is changing quickly enough that we
35 haven't bothered yet. */
37 /* For sparc64-cross-sparc32. */
45 #include "libiberty.h"
46 #include "safe-ctype.h"
52 static int elf_sort_sections (const void *, const void *);
53 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
54 static bfd_boolean
prep_headers (bfd
*);
55 static bfd_boolean
swap_out_syms (bfd
*, struct bfd_strtab_hash
**, int) ;
56 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
,
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 elf_program_header_size (abfd
) = (bfd_size_type
) -1;
253 bfd_elf_make_generic_object (bfd
*abfd
)
255 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
260 bfd_elf_mkcorefile (bfd
*abfd
)
262 /* I think this can be done just like an object file. */
263 return bfd_elf_make_generic_object (abfd
);
267 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
269 Elf_Internal_Shdr
**i_shdrp
;
270 bfd_byte
*shstrtab
= NULL
;
272 bfd_size_type shstrtabsize
;
274 i_shdrp
= elf_elfsections (abfd
);
276 || shindex
>= elf_numsections (abfd
)
277 || i_shdrp
[shindex
] == 0)
280 shstrtab
= i_shdrp
[shindex
]->contents
;
281 if (shstrtab
== NULL
)
283 /* No cached one, attempt to read, and cache what we read. */
284 offset
= i_shdrp
[shindex
]->sh_offset
;
285 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
287 /* Allocate and clear an extra byte at the end, to prevent crashes
288 in case the string table is not terminated. */
289 if (shstrtabsize
+ 1 <= 1
290 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
291 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
293 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
295 if (bfd_get_error () != bfd_error_system_call
)
296 bfd_set_error (bfd_error_file_truncated
);
298 /* Once we've failed to read it, make sure we don't keep
299 trying. Otherwise, we'll keep allocating space for
300 the string table over and over. */
301 i_shdrp
[shindex
]->sh_size
= 0;
304 shstrtab
[shstrtabsize
] = '\0';
305 i_shdrp
[shindex
]->contents
= shstrtab
;
307 return (char *) shstrtab
;
311 bfd_elf_string_from_elf_section (bfd
*abfd
,
312 unsigned int shindex
,
313 unsigned int strindex
)
315 Elf_Internal_Shdr
*hdr
;
320 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
323 hdr
= elf_elfsections (abfd
)[shindex
];
325 if (hdr
->contents
== NULL
326 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
329 if (strindex
>= hdr
->sh_size
)
331 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
332 (*_bfd_error_handler
)
333 (_("%B: invalid string offset %u >= %lu for section `%s'"),
334 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
335 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
337 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
341 return ((char *) hdr
->contents
) + strindex
;
344 /* Read and convert symbols to internal format.
345 SYMCOUNT specifies the number of symbols to read, starting from
346 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
347 are non-NULL, they are used to store the internal symbols, external
348 symbols, and symbol section index extensions, respectively.
349 Returns a pointer to the internal symbol buffer (malloced if necessary)
350 or NULL if there were no symbols or some kind of problem. */
353 bfd_elf_get_elf_syms (bfd
*ibfd
,
354 Elf_Internal_Shdr
*symtab_hdr
,
357 Elf_Internal_Sym
*intsym_buf
,
359 Elf_External_Sym_Shndx
*extshndx_buf
)
361 Elf_Internal_Shdr
*shndx_hdr
;
363 const bfd_byte
*esym
;
364 Elf_External_Sym_Shndx
*alloc_extshndx
;
365 Elf_External_Sym_Shndx
*shndx
;
366 Elf_Internal_Sym
*alloc_intsym
;
367 Elf_Internal_Sym
*isym
;
368 Elf_Internal_Sym
*isymend
;
369 const struct elf_backend_data
*bed
;
374 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
380 /* Normal syms might have section extension entries. */
382 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
383 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
385 /* Read the symbols. */
387 alloc_extshndx
= NULL
;
389 bed
= get_elf_backend_data (ibfd
);
390 extsym_size
= bed
->s
->sizeof_sym
;
391 amt
= symcount
* extsym_size
;
392 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
393 if (extsym_buf
== NULL
)
395 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
396 extsym_buf
= alloc_ext
;
398 if (extsym_buf
== NULL
399 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
400 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
406 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
410 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
411 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
412 if (extshndx_buf
== NULL
)
414 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
415 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
416 extshndx_buf
= alloc_extshndx
;
418 if (extshndx_buf
== NULL
419 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
420 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
427 if (intsym_buf
== NULL
)
429 alloc_intsym
= (Elf_Internal_Sym
*)
430 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
431 intsym_buf
= alloc_intsym
;
432 if (intsym_buf
== NULL
)
436 /* Convert the symbols to internal form. */
437 isymend
= intsym_buf
+ symcount
;
438 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
439 shndx
= extshndx_buf
;
441 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
442 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
444 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
445 (*_bfd_error_handler
) (_("%B symbol number %lu references "
446 "nonexistent SHT_SYMTAB_SHNDX section"),
447 ibfd
, (unsigned long) symoffset
);
448 if (alloc_intsym
!= NULL
)
455 if (alloc_ext
!= NULL
)
457 if (alloc_extshndx
!= NULL
)
458 free (alloc_extshndx
);
463 /* Look up a symbol name. */
465 bfd_elf_sym_name (bfd
*abfd
,
466 Elf_Internal_Shdr
*symtab_hdr
,
467 Elf_Internal_Sym
*isym
,
471 unsigned int iname
= isym
->st_name
;
472 unsigned int shindex
= symtab_hdr
->sh_link
;
474 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
475 /* Check for a bogus st_shndx to avoid crashing. */
476 && isym
->st_shndx
< elf_numsections (abfd
))
478 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
479 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
482 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
485 else if (sym_sec
&& *name
== '\0')
486 name
= bfd_section_name (abfd
, sym_sec
);
491 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
492 sections. The first element is the flags, the rest are section
495 typedef union elf_internal_group
{
496 Elf_Internal_Shdr
*shdr
;
498 } Elf_Internal_Group
;
500 /* Return the name of the group signature symbol. Why isn't the
501 signature just a string? */
504 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
506 Elf_Internal_Shdr
*hdr
;
507 unsigned char esym
[sizeof (Elf64_External_Sym
)];
508 Elf_External_Sym_Shndx eshndx
;
509 Elf_Internal_Sym isym
;
511 /* First we need to ensure the symbol table is available. Make sure
512 that it is a symbol table section. */
513 if (ghdr
->sh_link
>= elf_numsections (abfd
))
515 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
516 if (hdr
->sh_type
!= SHT_SYMTAB
517 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
520 /* Go read the symbol. */
521 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
522 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
523 &isym
, esym
, &eshndx
) == NULL
)
526 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
529 /* Set next_in_group list pointer, and group name for NEWSECT. */
532 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
534 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
536 /* If num_group is zero, read in all SHT_GROUP sections. The count
537 is set to -1 if there are no SHT_GROUP sections. */
540 unsigned int i
, shnum
;
542 /* First count the number of groups. If we have a SHT_GROUP
543 section with just a flag word (ie. sh_size is 4), ignore it. */
544 shnum
= elf_numsections (abfd
);
547 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
548 ( (shdr)->sh_type == SHT_GROUP \
549 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
550 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
551 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
553 for (i
= 0; i
< shnum
; i
++)
555 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
557 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
563 num_group
= (unsigned) -1;
564 elf_tdata (abfd
)->num_group
= num_group
;
568 /* We keep a list of elf section headers for group sections,
569 so we can find them quickly. */
572 elf_tdata (abfd
)->num_group
= num_group
;
573 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
574 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
575 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
579 for (i
= 0; i
< shnum
; i
++)
581 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
583 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
586 Elf_Internal_Group
*dest
;
588 /* Add to list of sections. */
589 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
592 /* Read the raw contents. */
593 BFD_ASSERT (sizeof (*dest
) >= 4);
594 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
595 shdr
->contents
= (unsigned char *)
596 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
597 /* PR binutils/4110: Handle corrupt group headers. */
598 if (shdr
->contents
== NULL
)
601 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
602 bfd_set_error (bfd_error_bad_value
);
606 memset (shdr
->contents
, 0, amt
);
608 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
609 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
613 /* Translate raw contents, a flag word followed by an
614 array of elf section indices all in target byte order,
615 to the flag word followed by an array of elf section
617 src
= shdr
->contents
+ shdr
->sh_size
;
618 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
625 idx
= H_GET_32 (abfd
, src
);
626 if (src
== shdr
->contents
)
629 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
630 shdr
->bfd_section
->flags
631 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
636 ((*_bfd_error_handler
)
637 (_("%B: invalid SHT_GROUP entry"), abfd
));
640 dest
->shdr
= elf_elfsections (abfd
)[idx
];
647 if (num_group
!= (unsigned) -1)
651 for (i
= 0; i
< num_group
; i
++)
653 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
654 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
655 unsigned int n_elt
= shdr
->sh_size
/ 4;
657 /* Look through this group's sections to see if current
658 section is a member. */
660 if ((++idx
)->shdr
== hdr
)
664 /* We are a member of this group. Go looking through
665 other members to see if any others are linked via
667 idx
= (Elf_Internal_Group
*) shdr
->contents
;
668 n_elt
= shdr
->sh_size
/ 4;
670 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
671 && elf_next_in_group (s
) != NULL
)
675 /* Snarf the group name from other member, and
676 insert current section in circular list. */
677 elf_group_name (newsect
) = elf_group_name (s
);
678 elf_next_in_group (newsect
) = elf_next_in_group (s
);
679 elf_next_in_group (s
) = newsect
;
685 gname
= group_signature (abfd
, shdr
);
688 elf_group_name (newsect
) = gname
;
690 /* Start a circular list with one element. */
691 elf_next_in_group (newsect
) = newsect
;
694 /* If the group section has been created, point to the
696 if (shdr
->bfd_section
!= NULL
)
697 elf_next_in_group (shdr
->bfd_section
) = newsect
;
705 if (elf_group_name (newsect
) == NULL
)
707 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
714 _bfd_elf_setup_sections (bfd
*abfd
)
717 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
718 bfd_boolean result
= TRUE
;
721 /* Process SHF_LINK_ORDER. */
722 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
724 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
725 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
727 unsigned int elfsec
= this_hdr
->sh_link
;
728 /* FIXME: The old Intel compiler and old strip/objcopy may
729 not set the sh_link or sh_info fields. Hence we could
730 get the situation where elfsec is 0. */
733 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
734 if (bed
->link_order_error_handler
)
735 bed
->link_order_error_handler
736 (_("%B: warning: sh_link not set for section `%A'"),
741 asection
*linksec
= NULL
;
743 if (elfsec
< elf_numsections (abfd
))
745 this_hdr
= elf_elfsections (abfd
)[elfsec
];
746 linksec
= this_hdr
->bfd_section
;
750 Some strip/objcopy may leave an incorrect value in
751 sh_link. We don't want to proceed. */
754 (*_bfd_error_handler
)
755 (_("%B: sh_link [%d] in section `%A' is incorrect"),
756 s
->owner
, s
, elfsec
);
760 elf_linked_to_section (s
) = linksec
;
765 /* Process section groups. */
766 if (num_group
== (unsigned) -1)
769 for (i
= 0; i
< num_group
; i
++)
771 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
772 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
773 unsigned int n_elt
= shdr
->sh_size
/ 4;
776 if ((++idx
)->shdr
->bfd_section
)
777 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
778 else if (idx
->shdr
->sh_type
== SHT_RELA
779 || idx
->shdr
->sh_type
== SHT_REL
)
780 /* We won't include relocation sections in section groups in
781 output object files. We adjust the group section size here
782 so that relocatable link will work correctly when
783 relocation sections are in section group in input object
785 shdr
->bfd_section
->size
-= 4;
788 /* There are some unknown sections in the group. */
789 (*_bfd_error_handler
)
790 (_("%B: unknown [%d] section `%s' in group [%s]"),
792 (unsigned int) idx
->shdr
->sh_type
,
793 bfd_elf_string_from_elf_section (abfd
,
794 (elf_elfheader (abfd
)
797 shdr
->bfd_section
->name
);
805 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
807 return elf_next_in_group (sec
) != NULL
;
810 /* Make a BFD section from an ELF section. We store a pointer to the
811 BFD section in the bfd_section field of the header. */
814 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
815 Elf_Internal_Shdr
*hdr
,
821 const struct elf_backend_data
*bed
;
823 if (hdr
->bfd_section
!= NULL
)
825 BFD_ASSERT (strcmp (name
,
826 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
830 newsect
= bfd_make_section_anyway (abfd
, name
);
834 hdr
->bfd_section
= newsect
;
835 elf_section_data (newsect
)->this_hdr
= *hdr
;
836 elf_section_data (newsect
)->this_idx
= shindex
;
838 /* Always use the real type/flags. */
839 elf_section_type (newsect
) = hdr
->sh_type
;
840 elf_section_flags (newsect
) = hdr
->sh_flags
;
842 newsect
->filepos
= hdr
->sh_offset
;
844 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
845 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
846 || ! bfd_set_section_alignment (abfd
, newsect
,
847 bfd_log2 (hdr
->sh_addralign
)))
850 flags
= SEC_NO_FLAGS
;
851 if (hdr
->sh_type
!= SHT_NOBITS
)
852 flags
|= SEC_HAS_CONTENTS
;
853 if (hdr
->sh_type
== SHT_GROUP
)
854 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
855 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
858 if (hdr
->sh_type
!= SHT_NOBITS
)
861 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
862 flags
|= SEC_READONLY
;
863 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
865 else if ((flags
& SEC_LOAD
) != 0)
867 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
870 newsect
->entsize
= hdr
->sh_entsize
;
871 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
872 flags
|= SEC_STRINGS
;
874 if (hdr
->sh_flags
& SHF_GROUP
)
875 if (!setup_group (abfd
, hdr
, newsect
))
877 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
878 flags
|= SEC_THREAD_LOCAL
;
879 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
880 flags
|= SEC_EXCLUDE
;
882 if ((flags
& SEC_ALLOC
) == 0)
884 /* The debugging sections appear to be recognized only by name,
885 not any sort of flag. Their SEC_ALLOC bits are cleared. */
890 } debug_sections
[] =
892 { STRING_COMMA_LEN ("debug") }, /* 'd' */
893 { NULL
, 0 }, /* 'e' */
894 { NULL
, 0 }, /* 'f' */
895 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
896 { NULL
, 0 }, /* 'h' */
897 { NULL
, 0 }, /* 'i' */
898 { NULL
, 0 }, /* 'j' */
899 { NULL
, 0 }, /* 'k' */
900 { STRING_COMMA_LEN ("line") }, /* 'l' */
901 { NULL
, 0 }, /* 'm' */
902 { NULL
, 0 }, /* 'n' */
903 { NULL
, 0 }, /* 'o' */
904 { NULL
, 0 }, /* 'p' */
905 { NULL
, 0 }, /* 'q' */
906 { NULL
, 0 }, /* 'r' */
907 { STRING_COMMA_LEN ("stab") }, /* 's' */
908 { NULL
, 0 }, /* 't' */
909 { NULL
, 0 }, /* 'u' */
910 { NULL
, 0 }, /* 'v' */
911 { NULL
, 0 }, /* 'w' */
912 { NULL
, 0 }, /* 'x' */
913 { NULL
, 0 }, /* 'y' */
914 { STRING_COMMA_LEN ("zdebug") } /* 'z' */
919 int i
= name
[1] - 'd';
921 && i
< (int) ARRAY_SIZE (debug_sections
)
922 && debug_sections
[i
].name
!= NULL
923 && strncmp (&name
[1], debug_sections
[i
].name
,
924 debug_sections
[i
].len
) == 0)
925 flags
|= SEC_DEBUGGING
;
929 /* As a GNU extension, if the name begins with .gnu.linkonce, we
930 only link a single copy of the section. This is used to support
931 g++. g++ will emit each template expansion in its own section.
932 The symbols will be defined as weak, so that multiple definitions
933 are permitted. The GNU linker extension is to actually discard
934 all but one of the sections. */
935 if (CONST_STRNEQ (name
, ".gnu.linkonce")
936 && elf_next_in_group (newsect
) == NULL
)
937 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
939 bed
= get_elf_backend_data (abfd
);
940 if (bed
->elf_backend_section_flags
)
941 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
944 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
947 /* We do not parse the PT_NOTE segments as we are interested even in the
948 separate debug info files which may have the segments offsets corrupted.
949 PT_NOTEs from the core files are currently not parsed using BFD. */
950 if (hdr
->sh_type
== SHT_NOTE
)
954 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
957 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
, -1);
961 if ((flags
& SEC_ALLOC
) != 0)
963 Elf_Internal_Phdr
*phdr
;
964 unsigned int i
, nload
;
966 /* Some ELF linkers produce binaries with all the program header
967 p_paddr fields zero. If we have such a binary with more than
968 one PT_LOAD header, then leave the section lma equal to vma
969 so that we don't create sections with overlapping lma. */
970 phdr
= elf_tdata (abfd
)->phdr
;
971 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
972 if (phdr
->p_paddr
!= 0)
974 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
976 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
979 phdr
= elf_tdata (abfd
)->phdr
;
980 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
982 if (phdr
->p_type
== PT_LOAD
983 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
985 if ((flags
& SEC_LOAD
) == 0)
986 newsect
->lma
= (phdr
->p_paddr
987 + hdr
->sh_addr
- phdr
->p_vaddr
);
989 /* We used to use the same adjustment for SEC_LOAD
990 sections, but that doesn't work if the segment
991 is packed with code from multiple VMAs.
992 Instead we calculate the section LMA based on
993 the segment LMA. It is assumed that the
994 segment will contain sections with contiguous
995 LMAs, even if the VMAs are not. */
996 newsect
->lma
= (phdr
->p_paddr
997 + hdr
->sh_offset
- phdr
->p_offset
);
999 /* With contiguous segments, we can't tell from file
1000 offsets whether a section with zero size should
1001 be placed at the end of one segment or the
1002 beginning of the next. Decide based on vaddr. */
1003 if (hdr
->sh_addr
>= phdr
->p_vaddr
1004 && (hdr
->sh_addr
+ hdr
->sh_size
1005 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1014 const char *const bfd_elf_section_type_names
[] = {
1015 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1016 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1017 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1020 /* ELF relocs are against symbols. If we are producing relocatable
1021 output, and the reloc is against an external symbol, and nothing
1022 has given us any additional addend, the resulting reloc will also
1023 be against the same symbol. In such a case, we don't want to
1024 change anything about the way the reloc is handled, since it will
1025 all be done at final link time. Rather than put special case code
1026 into bfd_perform_relocation, all the reloc types use this howto
1027 function. It just short circuits the reloc if producing
1028 relocatable output against an external symbol. */
1030 bfd_reloc_status_type
1031 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1032 arelent
*reloc_entry
,
1034 void *data ATTRIBUTE_UNUSED
,
1035 asection
*input_section
,
1037 char **error_message ATTRIBUTE_UNUSED
)
1039 if (output_bfd
!= NULL
1040 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1041 && (! reloc_entry
->howto
->partial_inplace
1042 || reloc_entry
->addend
== 0))
1044 reloc_entry
->address
+= input_section
->output_offset
;
1045 return bfd_reloc_ok
;
1048 return bfd_reloc_continue
;
1051 /* Copy the program header and other data from one object module to
1055 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1057 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1058 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1061 BFD_ASSERT (!elf_flags_init (obfd
)
1062 || (elf_elfheader (obfd
)->e_flags
1063 == elf_elfheader (ibfd
)->e_flags
));
1065 elf_gp (obfd
) = elf_gp (ibfd
);
1066 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1067 elf_flags_init (obfd
) = TRUE
;
1069 /* Copy object attributes. */
1070 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1075 get_segment_type (unsigned int p_type
)
1080 case PT_NULL
: pt
= "NULL"; break;
1081 case PT_LOAD
: pt
= "LOAD"; break;
1082 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1083 case PT_INTERP
: pt
= "INTERP"; break;
1084 case PT_NOTE
: pt
= "NOTE"; break;
1085 case PT_SHLIB
: pt
= "SHLIB"; break;
1086 case PT_PHDR
: pt
= "PHDR"; break;
1087 case PT_TLS
: pt
= "TLS"; break;
1088 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1089 case PT_GNU_STACK
: pt
= "STACK"; break;
1090 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1091 default: pt
= NULL
; break;
1096 /* Print out the program headers. */
1099 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1101 FILE *f
= (FILE *) farg
;
1102 Elf_Internal_Phdr
*p
;
1104 bfd_byte
*dynbuf
= NULL
;
1106 p
= elf_tdata (abfd
)->phdr
;
1111 fprintf (f
, _("\nProgram Header:\n"));
1112 c
= elf_elfheader (abfd
)->e_phnum
;
1113 for (i
= 0; i
< c
; i
++, p
++)
1115 const char *pt
= get_segment_type (p
->p_type
);
1120 sprintf (buf
, "0x%lx", p
->p_type
);
1123 fprintf (f
, "%8s off 0x", pt
);
1124 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1125 fprintf (f
, " vaddr 0x");
1126 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1127 fprintf (f
, " paddr 0x");
1128 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1129 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1130 fprintf (f
, " filesz 0x");
1131 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1132 fprintf (f
, " memsz 0x");
1133 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1134 fprintf (f
, " flags %c%c%c",
1135 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1136 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1137 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1138 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1139 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1144 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1147 unsigned int elfsec
;
1148 unsigned long shlink
;
1149 bfd_byte
*extdyn
, *extdynend
;
1151 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1153 fprintf (f
, _("\nDynamic Section:\n"));
1155 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1158 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1159 if (elfsec
== SHN_BAD
)
1161 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1163 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1164 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1167 extdynend
= extdyn
+ s
->size
;
1168 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1170 Elf_Internal_Dyn dyn
;
1171 const char *name
= "";
1173 bfd_boolean stringp
;
1174 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1176 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1178 if (dyn
.d_tag
== DT_NULL
)
1185 if (bed
->elf_backend_get_target_dtag
)
1186 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1188 if (!strcmp (name
, ""))
1190 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1195 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1196 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1197 case DT_PLTGOT
: name
= "PLTGOT"; break;
1198 case DT_HASH
: name
= "HASH"; break;
1199 case DT_STRTAB
: name
= "STRTAB"; break;
1200 case DT_SYMTAB
: name
= "SYMTAB"; break;
1201 case DT_RELA
: name
= "RELA"; break;
1202 case DT_RELASZ
: name
= "RELASZ"; break;
1203 case DT_RELAENT
: name
= "RELAENT"; break;
1204 case DT_STRSZ
: name
= "STRSZ"; break;
1205 case DT_SYMENT
: name
= "SYMENT"; break;
1206 case DT_INIT
: name
= "INIT"; break;
1207 case DT_FINI
: name
= "FINI"; break;
1208 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1209 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1210 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1211 case DT_REL
: name
= "REL"; break;
1212 case DT_RELSZ
: name
= "RELSZ"; break;
1213 case DT_RELENT
: name
= "RELENT"; break;
1214 case DT_PLTREL
: name
= "PLTREL"; break;
1215 case DT_DEBUG
: name
= "DEBUG"; break;
1216 case DT_TEXTREL
: name
= "TEXTREL"; break;
1217 case DT_JMPREL
: name
= "JMPREL"; break;
1218 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1219 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1220 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1221 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1222 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1223 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1224 case DT_FLAGS
: name
= "FLAGS"; break;
1225 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1226 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1227 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1228 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1229 case DT_MOVEENT
: name
= "MOVEENT"; break;
1230 case DT_MOVESZ
: name
= "MOVESZ"; break;
1231 case DT_FEATURE
: name
= "FEATURE"; break;
1232 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1233 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1234 case DT_SYMINENT
: name
= "SYMINENT"; break;
1235 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1236 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1237 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1238 case DT_PLTPAD
: name
= "PLTPAD"; break;
1239 case DT_MOVETAB
: name
= "MOVETAB"; break;
1240 case DT_SYMINFO
: name
= "SYMINFO"; break;
1241 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1242 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1243 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1244 case DT_VERSYM
: name
= "VERSYM"; break;
1245 case DT_VERDEF
: name
= "VERDEF"; break;
1246 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1247 case DT_VERNEED
: name
= "VERNEED"; break;
1248 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1249 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1250 case DT_USED
: name
= "USED"; break;
1251 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1252 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1255 fprintf (f
, " %-20s ", name
);
1259 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1264 unsigned int tagv
= dyn
.d_un
.d_val
;
1266 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1269 fprintf (f
, "%s", string
);
1278 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1279 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1281 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1285 if (elf_dynverdef (abfd
) != 0)
1287 Elf_Internal_Verdef
*t
;
1289 fprintf (f
, _("\nVersion definitions:\n"));
1290 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1292 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1293 t
->vd_flags
, t
->vd_hash
,
1294 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1295 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1297 Elf_Internal_Verdaux
*a
;
1300 for (a
= t
->vd_auxptr
->vda_nextptr
;
1304 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1310 if (elf_dynverref (abfd
) != 0)
1312 Elf_Internal_Verneed
*t
;
1314 fprintf (f
, _("\nVersion References:\n"));
1315 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1317 Elf_Internal_Vernaux
*a
;
1319 fprintf (f
, _(" required from %s:\n"),
1320 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1321 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1322 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1323 a
->vna_flags
, a
->vna_other
,
1324 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1336 /* Display ELF-specific fields of a symbol. */
1339 bfd_elf_print_symbol (bfd
*abfd
,
1342 bfd_print_symbol_type how
)
1344 FILE *file
= (FILE *) filep
;
1347 case bfd_print_symbol_name
:
1348 fprintf (file
, "%s", symbol
->name
);
1350 case bfd_print_symbol_more
:
1351 fprintf (file
, "elf ");
1352 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1353 fprintf (file
, " %lx", (unsigned long) symbol
->flags
);
1355 case bfd_print_symbol_all
:
1357 const char *section_name
;
1358 const char *name
= NULL
;
1359 const struct elf_backend_data
*bed
;
1360 unsigned char st_other
;
1363 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1365 bed
= get_elf_backend_data (abfd
);
1366 if (bed
->elf_backend_print_symbol_all
)
1367 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1371 name
= symbol
->name
;
1372 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1375 fprintf (file
, " %s\t", section_name
);
1376 /* Print the "other" value for a symbol. For common symbols,
1377 we've already printed the size; now print the alignment.
1378 For other symbols, we have no specified alignment, and
1379 we've printed the address; now print the size. */
1380 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1381 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1383 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1384 bfd_fprintf_vma (abfd
, file
, val
);
1386 /* If we have version information, print it. */
1387 if (elf_tdata (abfd
)->dynversym_section
!= 0
1388 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1389 || elf_tdata (abfd
)->dynverref_section
!= 0))
1391 unsigned int vernum
;
1392 const char *version_string
;
1394 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1397 version_string
= "";
1398 else if (vernum
== 1)
1399 version_string
= "Base";
1400 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1402 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1405 Elf_Internal_Verneed
*t
;
1407 version_string
= "";
1408 for (t
= elf_tdata (abfd
)->verref
;
1412 Elf_Internal_Vernaux
*a
;
1414 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1416 if (a
->vna_other
== vernum
)
1418 version_string
= a
->vna_nodename
;
1425 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1426 fprintf (file
, " %-11s", version_string
);
1431 fprintf (file
, " (%s)", version_string
);
1432 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1437 /* If the st_other field is not zero, print it. */
1438 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1443 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1444 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1445 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1447 /* Some other non-defined flags are also present, so print
1449 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1452 fprintf (file
, " %s", name
);
1458 /* Allocate an ELF string table--force the first byte to be zero. */
1460 struct bfd_strtab_hash
*
1461 _bfd_elf_stringtab_init (void)
1463 struct bfd_strtab_hash
*ret
;
1465 ret
= _bfd_stringtab_init ();
1470 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1471 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1472 if (loc
== (bfd_size_type
) -1)
1474 _bfd_stringtab_free (ret
);
1481 /* ELF .o/exec file reading */
1483 /* Create a new bfd section from an ELF section header. */
1486 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1488 Elf_Internal_Shdr
*hdr
;
1489 Elf_Internal_Ehdr
*ehdr
;
1490 const struct elf_backend_data
*bed
;
1493 if (shindex
>= elf_numsections (abfd
))
1496 hdr
= elf_elfsections (abfd
)[shindex
];
1497 ehdr
= elf_elfheader (abfd
);
1498 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1503 bed
= get_elf_backend_data (abfd
);
1504 switch (hdr
->sh_type
)
1507 /* Inactive section. Throw it away. */
1510 case SHT_PROGBITS
: /* Normal section with contents. */
1511 case SHT_NOBITS
: /* .bss section. */
1512 case SHT_HASH
: /* .hash section. */
1513 case SHT_NOTE
: /* .note section. */
1514 case SHT_INIT_ARRAY
: /* .init_array section. */
1515 case SHT_FINI_ARRAY
: /* .fini_array section. */
1516 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1517 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1518 case SHT_GNU_HASH
: /* .gnu.hash section. */
1519 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1521 case SHT_DYNAMIC
: /* Dynamic linking information. */
1522 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1524 if (hdr
->sh_link
> elf_numsections (abfd
))
1526 /* PR 10478: Accept Solaris binaries with a sh_link
1527 field set to SHN_BEFORE or SHN_AFTER. */
1528 switch (bfd_get_arch (abfd
))
1531 case bfd_arch_sparc
:
1532 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
1533 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
1535 /* Otherwise fall through. */
1540 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1542 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1544 Elf_Internal_Shdr
*dynsymhdr
;
1546 /* The shared libraries distributed with hpux11 have a bogus
1547 sh_link field for the ".dynamic" section. Find the
1548 string table for the ".dynsym" section instead. */
1549 if (elf_dynsymtab (abfd
) != 0)
1551 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1552 hdr
->sh_link
= dynsymhdr
->sh_link
;
1556 unsigned int i
, num_sec
;
1558 num_sec
= elf_numsections (abfd
);
1559 for (i
= 1; i
< num_sec
; i
++)
1561 dynsymhdr
= elf_elfsections (abfd
)[i
];
1562 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1564 hdr
->sh_link
= dynsymhdr
->sh_link
;
1572 case SHT_SYMTAB
: /* A symbol table */
1573 if (elf_onesymtab (abfd
) == shindex
)
1576 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1578 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1580 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1581 elf_onesymtab (abfd
) = shindex
;
1582 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1583 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1584 abfd
->flags
|= HAS_SYMS
;
1586 /* Sometimes a shared object will map in the symbol table. If
1587 SHF_ALLOC is set, and this is a shared object, then we also
1588 treat this section as a BFD section. We can not base the
1589 decision purely on SHF_ALLOC, because that flag is sometimes
1590 set in a relocatable object file, which would confuse the
1592 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1593 && (abfd
->flags
& DYNAMIC
) != 0
1594 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1598 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1599 can't read symbols without that section loaded as well. It
1600 is most likely specified by the next section header. */
1601 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1603 unsigned int i
, num_sec
;
1605 num_sec
= elf_numsections (abfd
);
1606 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1608 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1609 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1610 && hdr2
->sh_link
== shindex
)
1614 for (i
= 1; i
< shindex
; i
++)
1616 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1617 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1618 && hdr2
->sh_link
== shindex
)
1622 return bfd_section_from_shdr (abfd
, i
);
1626 case SHT_DYNSYM
: /* A dynamic symbol table */
1627 if (elf_dynsymtab (abfd
) == shindex
)
1630 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1632 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1633 elf_dynsymtab (abfd
) = shindex
;
1634 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1635 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1636 abfd
->flags
|= HAS_SYMS
;
1638 /* Besides being a symbol table, we also treat this as a regular
1639 section, so that objcopy can handle it. */
1640 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1642 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1643 if (elf_symtab_shndx (abfd
) == shindex
)
1646 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1647 elf_symtab_shndx (abfd
) = shindex
;
1648 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1649 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1652 case SHT_STRTAB
: /* A string table */
1653 if (hdr
->bfd_section
!= NULL
)
1655 if (ehdr
->e_shstrndx
== shindex
)
1657 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1658 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1661 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1664 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1665 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1668 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1671 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1672 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1673 elf_elfsections (abfd
)[shindex
] = hdr
;
1674 /* We also treat this as a regular section, so that objcopy
1676 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1680 /* If the string table isn't one of the above, then treat it as a
1681 regular section. We need to scan all the headers to be sure,
1682 just in case this strtab section appeared before the above. */
1683 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1685 unsigned int i
, num_sec
;
1687 num_sec
= elf_numsections (abfd
);
1688 for (i
= 1; i
< num_sec
; i
++)
1690 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1691 if (hdr2
->sh_link
== shindex
)
1693 /* Prevent endless recursion on broken objects. */
1696 if (! bfd_section_from_shdr (abfd
, i
))
1698 if (elf_onesymtab (abfd
) == i
)
1700 if (elf_dynsymtab (abfd
) == i
)
1701 goto dynsymtab_strtab
;
1705 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1709 /* *These* do a lot of work -- but build no sections! */
1711 asection
*target_sect
;
1712 Elf_Internal_Shdr
*hdr2
;
1713 unsigned int num_sec
= elf_numsections (abfd
);
1716 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1717 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1720 /* Check for a bogus link to avoid crashing. */
1721 if (hdr
->sh_link
>= num_sec
)
1723 ((*_bfd_error_handler
)
1724 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1725 abfd
, hdr
->sh_link
, name
, shindex
));
1726 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1730 /* For some incomprehensible reason Oracle distributes
1731 libraries for Solaris in which some of the objects have
1732 bogus sh_link fields. It would be nice if we could just
1733 reject them, but, unfortunately, some people need to use
1734 them. We scan through the section headers; if we find only
1735 one suitable symbol table, we clobber the sh_link to point
1736 to it. I hope this doesn't break anything.
1738 Don't do it on executable nor shared library. */
1739 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
1740 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1741 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1747 for (scan
= 1; scan
< num_sec
; scan
++)
1749 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1750 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1761 hdr
->sh_link
= found
;
1764 /* Get the symbol table. */
1765 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1766 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1767 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1770 /* If this reloc section does not use the main symbol table we
1771 don't treat it as a reloc section. BFD can't adequately
1772 represent such a section, so at least for now, we don't
1773 try. We just present it as a normal section. We also
1774 can't use it as a reloc section if it points to the null
1775 section, an invalid section, another reloc section, or its
1776 sh_link points to the null section. */
1777 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1778 || hdr
->sh_link
== SHN_UNDEF
1779 || hdr
->sh_info
== SHN_UNDEF
1780 || hdr
->sh_info
>= num_sec
1781 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1782 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1783 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1786 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1788 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1789 if (target_sect
== NULL
)
1792 if ((target_sect
->flags
& SEC_RELOC
) == 0
1793 || target_sect
->reloc_count
== 0)
1794 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1798 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1799 amt
= sizeof (*hdr2
);
1800 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
1803 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1806 elf_elfsections (abfd
)[shindex
] = hdr2
;
1807 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1808 target_sect
->flags
|= SEC_RELOC
;
1809 target_sect
->relocation
= NULL
;
1810 target_sect
->rel_filepos
= hdr
->sh_offset
;
1811 /* In the section to which the relocations apply, mark whether
1812 its relocations are of the REL or RELA variety. */
1813 if (hdr
->sh_size
!= 0)
1814 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1815 abfd
->flags
|= HAS_RELOC
;
1819 case SHT_GNU_verdef
:
1820 elf_dynverdef (abfd
) = shindex
;
1821 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1822 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1824 case SHT_GNU_versym
:
1825 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
1827 elf_dynversym (abfd
) = shindex
;
1828 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1829 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1831 case SHT_GNU_verneed
:
1832 elf_dynverref (abfd
) = shindex
;
1833 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1834 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1840 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
1842 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1844 if (hdr
->contents
!= NULL
)
1846 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1847 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
1850 if (idx
->flags
& GRP_COMDAT
)
1851 hdr
->bfd_section
->flags
1852 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1854 /* We try to keep the same section order as it comes in. */
1856 while (--n_elt
!= 0)
1860 if (idx
->shdr
!= NULL
1861 && (s
= idx
->shdr
->bfd_section
) != NULL
1862 && elf_next_in_group (s
) != NULL
)
1864 elf_next_in_group (hdr
->bfd_section
) = s
;
1872 /* Possibly an attributes section. */
1873 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
1874 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
1876 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1878 _bfd_elf_parse_attributes (abfd
, hdr
);
1882 /* Check for any processor-specific section types. */
1883 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
1886 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
1888 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1889 /* FIXME: How to properly handle allocated section reserved
1890 for applications? */
1891 (*_bfd_error_handler
)
1892 (_("%B: don't know how to handle allocated, application "
1893 "specific section `%s' [0x%8x]"),
1894 abfd
, name
, hdr
->sh_type
);
1896 /* Allow sections reserved for applications. */
1897 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1900 else if (hdr
->sh_type
>= SHT_LOPROC
1901 && hdr
->sh_type
<= SHT_HIPROC
)
1902 /* FIXME: We should handle this section. */
1903 (*_bfd_error_handler
)
1904 (_("%B: don't know how to handle processor specific section "
1906 abfd
, name
, hdr
->sh_type
);
1907 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
1909 /* Unrecognised OS-specific sections. */
1910 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
1911 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1912 required to correctly process the section and the file should
1913 be rejected with an error message. */
1914 (*_bfd_error_handler
)
1915 (_("%B: don't know how to handle OS specific section "
1917 abfd
, name
, hdr
->sh_type
);
1919 /* Otherwise it should be processed. */
1920 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1923 /* FIXME: We should handle this section. */
1924 (*_bfd_error_handler
)
1925 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1926 abfd
, name
, hdr
->sh_type
);
1934 /* Return the local symbol specified by ABFD, R_SYMNDX. */
1937 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
1939 unsigned long r_symndx
)
1941 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1943 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
1945 Elf_Internal_Shdr
*symtab_hdr
;
1946 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1947 Elf_External_Sym_Shndx eshndx
;
1949 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1950 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1951 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
1954 if (cache
->abfd
!= abfd
)
1956 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1959 cache
->indx
[ent
] = r_symndx
;
1962 return &cache
->sym
[ent
];
1965 /* Given an ELF section number, retrieve the corresponding BFD
1969 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
1971 if (sec_index
>= elf_numsections (abfd
))
1973 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
1976 static const struct bfd_elf_special_section special_sections_b
[] =
1978 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1979 { NULL
, 0, 0, 0, 0 }
1982 static const struct bfd_elf_special_section special_sections_c
[] =
1984 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
1985 { NULL
, 0, 0, 0, 0 }
1988 static const struct bfd_elf_special_section special_sections_d
[] =
1990 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1991 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1992 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
1993 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
1994 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
1995 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
1996 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
1997 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
1998 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
1999 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2000 { NULL
, 0, 0, 0, 0 }
2003 static const struct bfd_elf_special_section special_sections_f
[] =
2005 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2006 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2007 { NULL
, 0, 0, 0, 0 }
2010 static const struct bfd_elf_special_section special_sections_g
[] =
2012 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2013 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2014 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2015 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2016 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2017 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2018 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2019 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2020 { NULL
, 0, 0, 0, 0 }
2023 static const struct bfd_elf_special_section special_sections_h
[] =
2025 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2026 { NULL
, 0, 0, 0, 0 }
2029 static const struct bfd_elf_special_section special_sections_i
[] =
2031 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2032 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2033 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2034 { NULL
, 0, 0, 0, 0 }
2037 static const struct bfd_elf_special_section special_sections_l
[] =
2039 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2040 { NULL
, 0, 0, 0, 0 }
2043 static const struct bfd_elf_special_section special_sections_n
[] =
2045 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2046 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2047 { NULL
, 0, 0, 0, 0 }
2050 static const struct bfd_elf_special_section special_sections_p
[] =
2052 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2053 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2054 { NULL
, 0, 0, 0, 0 }
2057 static const struct bfd_elf_special_section special_sections_r
[] =
2059 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2060 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2061 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2062 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2063 { NULL
, 0, 0, 0, 0 }
2066 static const struct bfd_elf_special_section special_sections_s
[] =
2068 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2069 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2070 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2071 /* See struct bfd_elf_special_section declaration for the semantics of
2072 this special case where .prefix_length != strlen (.prefix). */
2073 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2074 { NULL
, 0, 0, 0, 0 }
2077 static const struct bfd_elf_special_section special_sections_t
[] =
2079 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2080 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2081 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2082 { NULL
, 0, 0, 0, 0 }
2085 static const struct bfd_elf_special_section special_sections_z
[] =
2087 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2088 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2089 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2090 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2091 { NULL
, 0, 0, 0, 0 }
2094 static const struct bfd_elf_special_section
*special_sections
[] =
2096 special_sections_b
, /* 'b' */
2097 special_sections_c
, /* 'c' */
2098 special_sections_d
, /* 'd' */
2100 special_sections_f
, /* 'f' */
2101 special_sections_g
, /* 'g' */
2102 special_sections_h
, /* 'h' */
2103 special_sections_i
, /* 'i' */
2106 special_sections_l
, /* 'l' */
2108 special_sections_n
, /* 'n' */
2110 special_sections_p
, /* 'p' */
2112 special_sections_r
, /* 'r' */
2113 special_sections_s
, /* 's' */
2114 special_sections_t
, /* 't' */
2120 special_sections_z
/* 'z' */
2123 const struct bfd_elf_special_section
*
2124 _bfd_elf_get_special_section (const char *name
,
2125 const struct bfd_elf_special_section
*spec
,
2131 len
= strlen (name
);
2133 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2136 int prefix_len
= spec
[i
].prefix_length
;
2138 if (len
< prefix_len
)
2140 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2143 suffix_len
= spec
[i
].suffix_length
;
2144 if (suffix_len
<= 0)
2146 if (name
[prefix_len
] != 0)
2148 if (suffix_len
== 0)
2150 if (name
[prefix_len
] != '.'
2151 && (suffix_len
== -2
2152 || (rela
&& spec
[i
].type
== SHT_REL
)))
2158 if (len
< prefix_len
+ suffix_len
)
2160 if (memcmp (name
+ len
- suffix_len
,
2161 spec
[i
].prefix
+ prefix_len
,
2171 const struct bfd_elf_special_section
*
2172 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2175 const struct bfd_elf_special_section
*spec
;
2176 const struct elf_backend_data
*bed
;
2178 /* See if this is one of the special sections. */
2179 if (sec
->name
== NULL
)
2182 bed
= get_elf_backend_data (abfd
);
2183 spec
= bed
->special_sections
;
2186 spec
= _bfd_elf_get_special_section (sec
->name
,
2187 bed
->special_sections
,
2193 if (sec
->name
[0] != '.')
2196 i
= sec
->name
[1] - 'b';
2197 if (i
< 0 || i
> 'z' - 'b')
2200 spec
= special_sections
[i
];
2205 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2209 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2211 struct bfd_elf_section_data
*sdata
;
2212 const struct elf_backend_data
*bed
;
2213 const struct bfd_elf_special_section
*ssect
;
2215 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2218 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2222 sec
->used_by_bfd
= sdata
;
2225 /* Indicate whether or not this section should use RELA relocations. */
2226 bed
= get_elf_backend_data (abfd
);
2227 sec
->use_rela_p
= bed
->default_use_rela_p
;
2229 /* When we read a file, we don't need to set ELF section type and
2230 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2231 anyway. We will set ELF section type and flags for all linker
2232 created sections. If user specifies BFD section flags, we will
2233 set ELF section type and flags based on BFD section flags in
2234 elf_fake_sections. */
2235 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2236 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2238 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2241 elf_section_type (sec
) = ssect
->type
;
2242 elf_section_flags (sec
) = ssect
->attr
;
2246 return _bfd_generic_new_section_hook (abfd
, sec
);
2249 /* Create a new bfd section from an ELF program header.
2251 Since program segments have no names, we generate a synthetic name
2252 of the form segment<NUM>, where NUM is generally the index in the
2253 program header table. For segments that are split (see below) we
2254 generate the names segment<NUM>a and segment<NUM>b.
2256 Note that some program segments may have a file size that is different than
2257 (less than) the memory size. All this means is that at execution the
2258 system must allocate the amount of memory specified by the memory size,
2259 but only initialize it with the first "file size" bytes read from the
2260 file. This would occur for example, with program segments consisting
2261 of combined data+bss.
2263 To handle the above situation, this routine generates TWO bfd sections
2264 for the single program segment. The first has the length specified by
2265 the file size of the segment, and the second has the length specified
2266 by the difference between the two sizes. In effect, the segment is split
2267 into its initialized and uninitialized parts.
2272 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2273 Elf_Internal_Phdr
*hdr
,
2275 const char *type_name
)
2283 split
= ((hdr
->p_memsz
> 0)
2284 && (hdr
->p_filesz
> 0)
2285 && (hdr
->p_memsz
> hdr
->p_filesz
));
2287 if (hdr
->p_filesz
> 0)
2289 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2290 len
= strlen (namebuf
) + 1;
2291 name
= (char *) bfd_alloc (abfd
, len
);
2294 memcpy (name
, namebuf
, len
);
2295 newsect
= bfd_make_section (abfd
, name
);
2296 if (newsect
== NULL
)
2298 newsect
->vma
= hdr
->p_vaddr
;
2299 newsect
->lma
= hdr
->p_paddr
;
2300 newsect
->size
= hdr
->p_filesz
;
2301 newsect
->filepos
= hdr
->p_offset
;
2302 newsect
->flags
|= SEC_HAS_CONTENTS
;
2303 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2304 if (hdr
->p_type
== PT_LOAD
)
2306 newsect
->flags
|= SEC_ALLOC
;
2307 newsect
->flags
|= SEC_LOAD
;
2308 if (hdr
->p_flags
& PF_X
)
2310 /* FIXME: all we known is that it has execute PERMISSION,
2312 newsect
->flags
|= SEC_CODE
;
2315 if (!(hdr
->p_flags
& PF_W
))
2317 newsect
->flags
|= SEC_READONLY
;
2321 if (hdr
->p_memsz
> hdr
->p_filesz
)
2325 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2326 len
= strlen (namebuf
) + 1;
2327 name
= (char *) bfd_alloc (abfd
, len
);
2330 memcpy (name
, namebuf
, len
);
2331 newsect
= bfd_make_section (abfd
, name
);
2332 if (newsect
== NULL
)
2334 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2335 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2336 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2337 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2338 align
= newsect
->vma
& -newsect
->vma
;
2339 if (align
== 0 || align
> hdr
->p_align
)
2340 align
= hdr
->p_align
;
2341 newsect
->alignment_power
= bfd_log2 (align
);
2342 if (hdr
->p_type
== PT_LOAD
)
2344 /* Hack for gdb. Segments that have not been modified do
2345 not have their contents written to a core file, on the
2346 assumption that a debugger can find the contents in the
2347 executable. We flag this case by setting the fake
2348 section size to zero. Note that "real" bss sections will
2349 always have their contents dumped to the core file. */
2350 if (bfd_get_format (abfd
) == bfd_core
)
2352 newsect
->flags
|= SEC_ALLOC
;
2353 if (hdr
->p_flags
& PF_X
)
2354 newsect
->flags
|= SEC_CODE
;
2356 if (!(hdr
->p_flags
& PF_W
))
2357 newsect
->flags
|= SEC_READONLY
;
2364 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2366 const struct elf_backend_data
*bed
;
2368 switch (hdr
->p_type
)
2371 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2374 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2377 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2380 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2383 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
2385 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2390 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
2393 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
2395 case PT_GNU_EH_FRAME
:
2396 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
2400 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
2403 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
2406 /* Check for any processor-specific program segment types. */
2407 bed
= get_elf_backend_data (abfd
);
2408 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
2412 /* Initialize REL_HDR, the section-header for new section, containing
2413 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2414 relocations; otherwise, we use REL relocations. */
2417 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2418 Elf_Internal_Shdr
*rel_hdr
,
2420 bfd_boolean use_rela_p
)
2423 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2424 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2426 name
= (char *) bfd_alloc (abfd
, amt
);
2429 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2431 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2433 if (rel_hdr
->sh_name
== (unsigned int) -1)
2435 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2436 rel_hdr
->sh_entsize
= (use_rela_p
2437 ? bed
->s
->sizeof_rela
2438 : bed
->s
->sizeof_rel
);
2439 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2440 rel_hdr
->sh_flags
= 0;
2441 rel_hdr
->sh_addr
= 0;
2442 rel_hdr
->sh_size
= 0;
2443 rel_hdr
->sh_offset
= 0;
2448 /* Return the default section type based on the passed in section flags. */
2451 bfd_elf_get_default_section_type (flagword flags
)
2453 if ((flags
& SEC_ALLOC
) != 0
2454 && ((flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0
2455 || (flags
& SEC_NEVER_LOAD
) != 0))
2457 return SHT_PROGBITS
;
2460 /* Set up an ELF internal section header for a section. */
2463 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2465 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2466 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2467 Elf_Internal_Shdr
*this_hdr
;
2468 unsigned int sh_type
;
2472 /* We already failed; just get out of the bfd_map_over_sections
2477 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2479 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2480 asect
->name
, FALSE
);
2481 if (this_hdr
->sh_name
== (unsigned int) -1)
2487 /* Don't clear sh_flags. Assembler may set additional bits. */
2489 if ((asect
->flags
& SEC_ALLOC
) != 0
2490 || asect
->user_set_vma
)
2491 this_hdr
->sh_addr
= asect
->vma
;
2493 this_hdr
->sh_addr
= 0;
2495 this_hdr
->sh_offset
= 0;
2496 this_hdr
->sh_size
= asect
->size
;
2497 this_hdr
->sh_link
= 0;
2498 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2499 /* The sh_entsize and sh_info fields may have been set already by
2500 copy_private_section_data. */
2502 this_hdr
->bfd_section
= asect
;
2503 this_hdr
->contents
= NULL
;
2505 /* If the section type is unspecified, we set it based on
2507 if ((asect
->flags
& SEC_GROUP
) != 0)
2508 sh_type
= SHT_GROUP
;
2510 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
2512 if (this_hdr
->sh_type
== SHT_NULL
)
2513 this_hdr
->sh_type
= sh_type
;
2514 else if (this_hdr
->sh_type
== SHT_NOBITS
2515 && sh_type
== SHT_PROGBITS
2516 && (asect
->flags
& SEC_ALLOC
) != 0)
2518 /* Warn if we are changing a NOBITS section to PROGBITS, but
2519 allow the link to proceed. This can happen when users link
2520 non-bss input sections to bss output sections, or emit data
2521 to a bss output section via a linker script. */
2522 (*_bfd_error_handler
)
2523 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2524 this_hdr
->sh_type
= sh_type
;
2527 switch (this_hdr
->sh_type
)
2533 case SHT_INIT_ARRAY
:
2534 case SHT_FINI_ARRAY
:
2535 case SHT_PREINIT_ARRAY
:
2542 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2546 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2550 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2554 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2555 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2559 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2560 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2563 case SHT_GNU_versym
:
2564 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2567 case SHT_GNU_verdef
:
2568 this_hdr
->sh_entsize
= 0;
2569 /* objcopy or strip will copy over sh_info, but may not set
2570 cverdefs. The linker will set cverdefs, but sh_info will be
2572 if (this_hdr
->sh_info
== 0)
2573 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2575 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2576 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2579 case SHT_GNU_verneed
:
2580 this_hdr
->sh_entsize
= 0;
2581 /* objcopy or strip will copy over sh_info, but may not set
2582 cverrefs. The linker will set cverrefs, but sh_info will be
2584 if (this_hdr
->sh_info
== 0)
2585 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2587 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2588 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2592 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2596 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2600 if ((asect
->flags
& SEC_ALLOC
) != 0)
2601 this_hdr
->sh_flags
|= SHF_ALLOC
;
2602 if ((asect
->flags
& SEC_READONLY
) == 0)
2603 this_hdr
->sh_flags
|= SHF_WRITE
;
2604 if ((asect
->flags
& SEC_CODE
) != 0)
2605 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2606 if ((asect
->flags
& SEC_MERGE
) != 0)
2608 this_hdr
->sh_flags
|= SHF_MERGE
;
2609 this_hdr
->sh_entsize
= asect
->entsize
;
2610 if ((asect
->flags
& SEC_STRINGS
) != 0)
2611 this_hdr
->sh_flags
|= SHF_STRINGS
;
2613 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2614 this_hdr
->sh_flags
|= SHF_GROUP
;
2615 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2617 this_hdr
->sh_flags
|= SHF_TLS
;
2618 if (asect
->size
== 0
2619 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2621 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2623 this_hdr
->sh_size
= 0;
2626 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2627 if (this_hdr
->sh_size
!= 0)
2628 this_hdr
->sh_type
= SHT_NOBITS
;
2632 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2633 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
2635 /* Check for processor-specific section types. */
2636 sh_type
= this_hdr
->sh_type
;
2637 if (bed
->elf_backend_fake_sections
2638 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2641 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2643 /* Don't change the header type from NOBITS if we are being
2644 called for objcopy --only-keep-debug. */
2645 this_hdr
->sh_type
= sh_type
;
2648 /* If the section has relocs, set up a section header for the
2649 SHT_REL[A] section. If two relocation sections are required for
2650 this section, it is up to the processor-specific back-end to
2651 create the other. */
2652 if ((asect
->flags
& SEC_RELOC
) != 0
2653 && !_bfd_elf_init_reloc_shdr (abfd
,
2654 &elf_section_data (asect
)->rel_hdr
,
2660 /* Fill in the contents of a SHT_GROUP section. Called from
2661 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2662 when ELF targets use the generic linker, ld. Called for ld -r
2663 from bfd_elf_final_link. */
2666 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2668 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2669 asection
*elt
, *first
;
2673 /* Ignore linker created group section. See elfNN_ia64_object_p in
2675 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2679 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
2681 unsigned long symindx
= 0;
2683 /* elf_group_id will have been set up by objcopy and the
2685 if (elf_group_id (sec
) != NULL
)
2686 symindx
= elf_group_id (sec
)->udata
.i
;
2690 /* If called from the assembler, swap_out_syms will have set up
2691 elf_section_syms. */
2692 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
2693 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2695 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2697 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
2699 /* The ELF backend linker sets sh_info to -2 when the group
2700 signature symbol is global, and thus the index can't be
2701 set until all local symbols are output. */
2702 asection
*igroup
= elf_sec_group (elf_next_in_group (sec
));
2703 struct bfd_elf_section_data
*sec_data
= elf_section_data (igroup
);
2704 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
2705 unsigned long extsymoff
= 0;
2706 struct elf_link_hash_entry
*h
;
2708 if (!elf_bad_symtab (igroup
->owner
))
2710 Elf_Internal_Shdr
*symtab_hdr
;
2712 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
2713 extsymoff
= symtab_hdr
->sh_info
;
2715 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
2716 while (h
->root
.type
== bfd_link_hash_indirect
2717 || h
->root
.type
== bfd_link_hash_warning
)
2718 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2720 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
2723 /* The contents won't be allocated for "ld -r" or objcopy. */
2725 if (sec
->contents
== NULL
)
2728 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
2730 /* Arrange for the section to be written out. */
2731 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2732 if (sec
->contents
== NULL
)
2739 loc
= sec
->contents
+ sec
->size
;
2741 /* Get the pointer to the first section in the group that gas
2742 squirreled away here. objcopy arranges for this to be set to the
2743 start of the input section group. */
2744 first
= elt
= elf_next_in_group (sec
);
2746 /* First element is a flag word. Rest of section is elf section
2747 indices for all the sections of the group. Write them backwards
2748 just to keep the group in the same order as given in .section
2749 directives, not that it matters. */
2756 s
= s
->output_section
;
2758 && !bfd_is_abs_section (s
))
2760 unsigned int idx
= elf_section_data (s
)->this_idx
;
2763 H_PUT_32 (abfd
, idx
, loc
);
2765 elt
= elf_next_in_group (elt
);
2770 if ((loc
-= 4) != sec
->contents
)
2773 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2776 /* Assign all ELF section numbers. The dummy first section is handled here
2777 too. The link/info pointers for the standard section types are filled
2778 in here too, while we're at it. */
2781 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2783 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2785 unsigned int section_number
, secn
;
2786 Elf_Internal_Shdr
**i_shdrp
;
2787 struct bfd_elf_section_data
*d
;
2788 bfd_boolean need_symtab
;
2792 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2794 /* SHT_GROUP sections are in relocatable files only. */
2795 if (link_info
== NULL
|| link_info
->relocatable
)
2797 /* Put SHT_GROUP sections first. */
2798 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2800 d
= elf_section_data (sec
);
2802 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2804 if (sec
->flags
& SEC_LINKER_CREATED
)
2806 /* Remove the linker created SHT_GROUP sections. */
2807 bfd_section_list_remove (abfd
, sec
);
2808 abfd
->section_count
--;
2811 d
->this_idx
= section_number
++;
2816 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2818 d
= elf_section_data (sec
);
2820 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2821 d
->this_idx
= section_number
++;
2822 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2823 if ((sec
->flags
& SEC_RELOC
) == 0)
2827 d
->rel_idx
= section_number
++;
2828 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2833 d
->rel_idx2
= section_number
++;
2834 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2840 t
->shstrtab_section
= section_number
++;
2841 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2842 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2844 need_symtab
= (bfd_get_symcount (abfd
) > 0
2845 || (link_info
== NULL
2846 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
2850 t
->symtab_section
= section_number
++;
2851 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2852 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
2854 t
->symtab_shndx_section
= section_number
++;
2855 t
->symtab_shndx_hdr
.sh_name
2856 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2857 ".symtab_shndx", FALSE
);
2858 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2861 t
->strtab_section
= section_number
++;
2862 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2865 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2866 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2868 elf_numsections (abfd
) = section_number
;
2869 elf_elfheader (abfd
)->e_shnum
= section_number
;
2871 /* Set up the list of section header pointers, in agreement with the
2873 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
2874 sizeof (Elf_Internal_Shdr
*));
2875 if (i_shdrp
== NULL
)
2878 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
2879 sizeof (Elf_Internal_Shdr
));
2880 if (i_shdrp
[0] == NULL
)
2882 bfd_release (abfd
, i_shdrp
);
2886 elf_elfsections (abfd
) = i_shdrp
;
2888 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2891 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2892 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
2894 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2895 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2897 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2898 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2901 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2906 d
= elf_section_data (sec
);
2908 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2909 if (d
->rel_idx
!= 0)
2910 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2911 if (d
->rel_idx2
!= 0)
2912 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2914 /* Fill in the sh_link and sh_info fields while we're at it. */
2916 /* sh_link of a reloc section is the section index of the symbol
2917 table. sh_info is the section index of the section to which
2918 the relocation entries apply. */
2919 if (d
->rel_idx
!= 0)
2921 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2922 d
->rel_hdr
.sh_info
= d
->this_idx
;
2924 if (d
->rel_idx2
!= 0)
2926 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2927 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2930 /* We need to set up sh_link for SHF_LINK_ORDER. */
2931 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
2933 s
= elf_linked_to_section (sec
);
2936 /* elf_linked_to_section points to the input section. */
2937 if (link_info
!= NULL
)
2939 /* Check discarded linkonce section. */
2940 if (elf_discarded_section (s
))
2943 (*_bfd_error_handler
)
2944 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2945 abfd
, d
->this_hdr
.bfd_section
,
2947 /* Point to the kept section if it has the same
2948 size as the discarded one. */
2949 kept
= _bfd_elf_check_kept_section (s
, link_info
);
2952 bfd_set_error (bfd_error_bad_value
);
2958 s
= s
->output_section
;
2959 BFD_ASSERT (s
!= NULL
);
2963 /* Handle objcopy. */
2964 if (s
->output_section
== NULL
)
2966 (*_bfd_error_handler
)
2967 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2968 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
2969 bfd_set_error (bfd_error_bad_value
);
2972 s
= s
->output_section
;
2974 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2979 The Intel C compiler generates SHT_IA_64_UNWIND with
2980 SHF_LINK_ORDER. But it doesn't set the sh_link or
2981 sh_info fields. Hence we could get the situation
2983 const struct elf_backend_data
*bed
2984 = get_elf_backend_data (abfd
);
2985 if (bed
->link_order_error_handler
)
2986 bed
->link_order_error_handler
2987 (_("%B: warning: sh_link not set for section `%A'"),
2992 switch (d
->this_hdr
.sh_type
)
2996 /* A reloc section which we are treating as a normal BFD
2997 section. sh_link is the section index of the symbol
2998 table. sh_info is the section index of the section to
2999 which the relocation entries apply. We assume that an
3000 allocated reloc section uses the dynamic symbol table.
3001 FIXME: How can we be sure? */
3002 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3004 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3006 /* We look up the section the relocs apply to by name. */
3008 if (d
->this_hdr
.sh_type
== SHT_REL
)
3012 s
= bfd_get_section_by_name (abfd
, name
);
3014 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3018 /* We assume that a section named .stab*str is a stabs
3019 string section. We look for a section with the same name
3020 but without the trailing ``str'', and set its sh_link
3021 field to point to this section. */
3022 if (CONST_STRNEQ (sec
->name
, ".stab")
3023 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3028 len
= strlen (sec
->name
);
3029 alc
= (char *) bfd_malloc (len
- 2);
3032 memcpy (alc
, sec
->name
, len
- 3);
3033 alc
[len
- 3] = '\0';
3034 s
= bfd_get_section_by_name (abfd
, alc
);
3038 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3040 /* This is a .stab section. */
3041 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3042 elf_section_data (s
)->this_hdr
.sh_entsize
3043 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3050 case SHT_GNU_verneed
:
3051 case SHT_GNU_verdef
:
3052 /* sh_link is the section header index of the string table
3053 used for the dynamic entries, or the symbol table, or the
3055 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3057 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3060 case SHT_GNU_LIBLIST
:
3061 /* sh_link is the section header index of the prelink library
3062 list used for the dynamic entries, or the symbol table, or
3063 the version strings. */
3064 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3065 ? ".dynstr" : ".gnu.libstr");
3067 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3072 case SHT_GNU_versym
:
3073 /* sh_link is the section header index of the symbol table
3074 this hash table or version table is for. */
3075 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3077 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3081 d
->this_hdr
.sh_link
= t
->symtab_section
;
3085 for (secn
= 1; secn
< section_number
; ++secn
)
3086 if (i_shdrp
[secn
] == NULL
)
3087 i_shdrp
[secn
] = i_shdrp
[0];
3089 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3090 i_shdrp
[secn
]->sh_name
);
3094 /* Map symbol from it's internal number to the external number, moving
3095 all local symbols to be at the head of the list. */
3098 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3100 /* If the backend has a special mapping, use it. */
3101 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3102 if (bed
->elf_backend_sym_is_global
)
3103 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3105 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3106 || bfd_is_und_section (bfd_get_section (sym
))
3107 || bfd_is_com_section (bfd_get_section (sym
)));
3110 /* Don't output section symbols for sections that are not going to be
3114 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3116 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3117 && !(sym
->section
->owner
== abfd
3118 || (sym
->section
->output_section
->owner
== abfd
3119 && sym
->section
->output_offset
== 0)));
3123 elf_map_symbols (bfd
*abfd
)
3125 unsigned int symcount
= bfd_get_symcount (abfd
);
3126 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3127 asymbol
**sect_syms
;
3128 unsigned int num_locals
= 0;
3129 unsigned int num_globals
= 0;
3130 unsigned int num_locals2
= 0;
3131 unsigned int num_globals2
= 0;
3138 fprintf (stderr
, "elf_map_symbols\n");
3142 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3144 if (max_index
< asect
->index
)
3145 max_index
= asect
->index
;
3149 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3150 if (sect_syms
== NULL
)
3152 elf_section_syms (abfd
) = sect_syms
;
3153 elf_num_section_syms (abfd
) = max_index
;
3155 /* Init sect_syms entries for any section symbols we have already
3156 decided to output. */
3157 for (idx
= 0; idx
< symcount
; idx
++)
3159 asymbol
*sym
= syms
[idx
];
3161 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3163 && !ignore_section_sym (abfd
, sym
))
3165 asection
*sec
= sym
->section
;
3167 if (sec
->owner
!= abfd
)
3168 sec
= sec
->output_section
;
3170 sect_syms
[sec
->index
] = syms
[idx
];
3174 /* Classify all of the symbols. */
3175 for (idx
= 0; idx
< symcount
; idx
++)
3177 if (ignore_section_sym (abfd
, syms
[idx
]))
3179 if (!sym_is_global (abfd
, syms
[idx
]))
3185 /* We will be adding a section symbol for each normal BFD section. Most
3186 sections will already have a section symbol in outsymbols, but
3187 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3188 at least in that case. */
3189 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3191 if (sect_syms
[asect
->index
] == NULL
)
3193 if (!sym_is_global (abfd
, asect
->symbol
))
3200 /* Now sort the symbols so the local symbols are first. */
3201 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
3202 sizeof (asymbol
*));
3204 if (new_syms
== NULL
)
3207 for (idx
= 0; idx
< symcount
; idx
++)
3209 asymbol
*sym
= syms
[idx
];
3212 if (ignore_section_sym (abfd
, sym
))
3214 if (!sym_is_global (abfd
, sym
))
3217 i
= num_locals
+ num_globals2
++;
3219 sym
->udata
.i
= i
+ 1;
3221 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3223 if (sect_syms
[asect
->index
] == NULL
)
3225 asymbol
*sym
= asect
->symbol
;
3228 sect_syms
[asect
->index
] = sym
;
3229 if (!sym_is_global (abfd
, sym
))
3232 i
= num_locals
+ num_globals2
++;
3234 sym
->udata
.i
= i
+ 1;
3238 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3240 elf_num_locals (abfd
) = num_locals
;
3241 elf_num_globals (abfd
) = num_globals
;
3245 /* Align to the maximum file alignment that could be required for any
3246 ELF data structure. */
3248 static inline file_ptr
3249 align_file_position (file_ptr off
, int align
)
3251 return (off
+ align
- 1) & ~(align
- 1);
3254 /* Assign a file position to a section, optionally aligning to the
3255 required section alignment. */
3258 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3262 if (align
&& i_shdrp
->sh_addralign
> 1)
3263 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3264 i_shdrp
->sh_offset
= offset
;
3265 if (i_shdrp
->bfd_section
!= NULL
)
3266 i_shdrp
->bfd_section
->filepos
= offset
;
3267 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3268 offset
+= i_shdrp
->sh_size
;
3272 /* Compute the file positions we are going to put the sections at, and
3273 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3274 is not NULL, this is being called by the ELF backend linker. */
3277 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3278 struct bfd_link_info
*link_info
)
3280 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3282 struct bfd_strtab_hash
*strtab
= NULL
;
3283 Elf_Internal_Shdr
*shstrtab_hdr
;
3284 bfd_boolean need_symtab
;
3286 if (abfd
->output_has_begun
)
3289 /* Do any elf backend specific processing first. */
3290 if (bed
->elf_backend_begin_write_processing
)
3291 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3293 if (! prep_headers (abfd
))
3296 /* Post process the headers if necessary. */
3297 if (bed
->elf_backend_post_process_headers
)
3298 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3301 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3305 if (!assign_section_numbers (abfd
, link_info
))
3308 /* The backend linker builds symbol table information itself. */
3309 need_symtab
= (link_info
== NULL
3310 && (bfd_get_symcount (abfd
) > 0
3311 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3315 /* Non-zero if doing a relocatable link. */
3316 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3318 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3322 if (link_info
== NULL
)
3324 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3329 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3330 /* sh_name was set in prep_headers. */
3331 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3332 shstrtab_hdr
->sh_flags
= 0;
3333 shstrtab_hdr
->sh_addr
= 0;
3334 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3335 shstrtab_hdr
->sh_entsize
= 0;
3336 shstrtab_hdr
->sh_link
= 0;
3337 shstrtab_hdr
->sh_info
= 0;
3338 /* sh_offset is set in assign_file_positions_except_relocs. */
3339 shstrtab_hdr
->sh_addralign
= 1;
3341 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3347 Elf_Internal_Shdr
*hdr
;
3349 off
= elf_tdata (abfd
)->next_file_pos
;
3351 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3352 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3354 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3355 if (hdr
->sh_size
!= 0)
3356 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3358 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3359 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3361 elf_tdata (abfd
)->next_file_pos
= off
;
3363 /* Now that we know where the .strtab section goes, write it
3365 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3366 || ! _bfd_stringtab_emit (abfd
, strtab
))
3368 _bfd_stringtab_free (strtab
);
3371 abfd
->output_has_begun
= TRUE
;
3376 /* Make an initial estimate of the size of the program header. If we
3377 get the number wrong here, we'll redo section placement. */
3379 static bfd_size_type
3380 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3384 const struct elf_backend_data
*bed
;
3386 /* Assume we will need exactly two PT_LOAD segments: one for text
3387 and one for data. */
3390 s
= bfd_get_section_by_name (abfd
, ".interp");
3391 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3393 /* If we have a loadable interpreter section, we need a
3394 PT_INTERP segment. In this case, assume we also need a
3395 PT_PHDR segment, although that may not be true for all
3400 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3402 /* We need a PT_DYNAMIC segment. */
3406 if (info
!= NULL
&& info
->relro
)
3408 /* We need a PT_GNU_RELRO segment. */
3412 if (elf_tdata (abfd
)->eh_frame_hdr
)
3414 /* We need a PT_GNU_EH_FRAME segment. */
3418 if (elf_tdata (abfd
)->stack_flags
)
3420 /* We need a PT_GNU_STACK segment. */
3424 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3426 if ((s
->flags
& SEC_LOAD
) != 0
3427 && CONST_STRNEQ (s
->name
, ".note"))
3429 /* We need a PT_NOTE segment. */
3431 /* Try to create just one PT_NOTE segment
3432 for all adjacent loadable .note* sections.
3433 gABI requires that within a PT_NOTE segment
3434 (and also inside of each SHT_NOTE section)
3435 each note is padded to a multiple of 4 size,
3436 so we check whether the sections are correctly
3438 if (s
->alignment_power
== 2)
3439 while (s
->next
!= NULL
3440 && s
->next
->alignment_power
== 2
3441 && (s
->next
->flags
& SEC_LOAD
) != 0
3442 && CONST_STRNEQ (s
->next
->name
, ".note"))
3447 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3449 if (s
->flags
& SEC_THREAD_LOCAL
)
3451 /* We need a PT_TLS segment. */
3457 /* Let the backend count up any program headers it might need. */
3458 bed
= get_elf_backend_data (abfd
);
3459 if (bed
->elf_backend_additional_program_headers
)
3463 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3469 return segs
* bed
->s
->sizeof_phdr
;
3472 /* Find the segment that contains the output_section of section. */
3475 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3477 struct elf_segment_map
*m
;
3478 Elf_Internal_Phdr
*p
;
3480 for (m
= elf_tdata (abfd
)->segment_map
,
3481 p
= elf_tdata (abfd
)->phdr
;
3487 for (i
= m
->count
- 1; i
>= 0; i
--)
3488 if (m
->sections
[i
] == section
)
3495 /* Create a mapping from a set of sections to a program segment. */
3497 static struct elf_segment_map
*
3498 make_mapping (bfd
*abfd
,
3499 asection
**sections
,
3504 struct elf_segment_map
*m
;
3509 amt
= sizeof (struct elf_segment_map
);
3510 amt
+= (to
- from
- 1) * sizeof (asection
*);
3511 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3515 m
->p_type
= PT_LOAD
;
3516 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3517 m
->sections
[i
- from
] = *hdrpp
;
3518 m
->count
= to
- from
;
3520 if (from
== 0 && phdr
)
3522 /* Include the headers in the first PT_LOAD segment. */
3523 m
->includes_filehdr
= 1;
3524 m
->includes_phdrs
= 1;
3530 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3533 struct elf_segment_map
*
3534 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3536 struct elf_segment_map
*m
;
3538 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
3539 sizeof (struct elf_segment_map
));
3543 m
->p_type
= PT_DYNAMIC
;
3545 m
->sections
[0] = dynsec
;
3550 /* Possibly add or remove segments from the segment map. */
3553 elf_modify_segment_map (bfd
*abfd
,
3554 struct bfd_link_info
*info
,
3555 bfd_boolean remove_empty_load
)
3557 struct elf_segment_map
**m
;
3558 const struct elf_backend_data
*bed
;
3560 /* The placement algorithm assumes that non allocated sections are
3561 not in PT_LOAD segments. We ensure this here by removing such
3562 sections from the segment map. We also remove excluded
3563 sections. Finally, any PT_LOAD segment without sections is
3565 m
= &elf_tdata (abfd
)->segment_map
;
3568 unsigned int i
, new_count
;
3570 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3572 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3573 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3574 || (*m
)->p_type
!= PT_LOAD
))
3576 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3580 (*m
)->count
= new_count
;
3582 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3588 bed
= get_elf_backend_data (abfd
);
3589 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3591 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3598 /* Set up a mapping from BFD sections to program segments. */
3601 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3604 struct elf_segment_map
*m
;
3605 asection
**sections
= NULL
;
3606 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3607 bfd_boolean no_user_phdrs
;
3609 no_user_phdrs
= elf_tdata (abfd
)->segment_map
== NULL
;
3610 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3614 struct elf_segment_map
*mfirst
;
3615 struct elf_segment_map
**pm
;
3618 unsigned int phdr_index
;
3619 bfd_vma maxpagesize
;
3621 bfd_boolean phdr_in_segment
= TRUE
;
3622 bfd_boolean writable
;
3624 asection
*first_tls
= NULL
;
3625 asection
*dynsec
, *eh_frame_hdr
;
3628 /* Select the allocated sections, and sort them. */
3630 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
3631 sizeof (asection
*));
3632 if (sections
== NULL
)
3636 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3638 if ((s
->flags
& SEC_ALLOC
) != 0)
3644 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3647 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3649 /* Build the mapping. */
3654 /* If we have a .interp section, then create a PT_PHDR segment for
3655 the program headers and a PT_INTERP segment for the .interp
3657 s
= bfd_get_section_by_name (abfd
, ".interp");
3658 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3660 amt
= sizeof (struct elf_segment_map
);
3661 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3665 m
->p_type
= PT_PHDR
;
3666 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3667 m
->p_flags
= PF_R
| PF_X
;
3668 m
->p_flags_valid
= 1;
3669 m
->includes_phdrs
= 1;
3674 amt
= sizeof (struct elf_segment_map
);
3675 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3679 m
->p_type
= PT_INTERP
;
3687 /* Look through the sections. We put sections in the same program
3688 segment when the start of the second section can be placed within
3689 a few bytes of the end of the first section. */
3693 maxpagesize
= bed
->maxpagesize
;
3695 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3697 && (dynsec
->flags
& SEC_LOAD
) == 0)
3700 /* Deal with -Ttext or something similar such that the first section
3701 is not adjacent to the program headers. This is an
3702 approximation, since at this point we don't know exactly how many
3703 program headers we will need. */
3706 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3708 if (phdr_size
== (bfd_size_type
) -1)
3709 phdr_size
= get_program_header_size (abfd
, info
);
3710 if ((abfd
->flags
& D_PAGED
) == 0
3711 || sections
[0]->lma
< phdr_size
3712 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3713 phdr_in_segment
= FALSE
;
3716 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3719 bfd_boolean new_segment
;
3723 /* See if this section and the last one will fit in the same
3726 if (last_hdr
== NULL
)
3728 /* If we don't have a segment yet, then we don't need a new
3729 one (we build the last one after this loop). */
3730 new_segment
= FALSE
;
3732 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3734 /* If this section has a different relation between the
3735 virtual address and the load address, then we need a new
3739 else if (hdr
->lma
< last_hdr
->lma
+ last_size
3740 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
3742 /* If this section has a load address that makes it overlap
3743 the previous section, then we need a new segment. */
3746 /* In the next test we have to be careful when last_hdr->lma is close
3747 to the end of the address space. If the aligned address wraps
3748 around to the start of the address space, then there are no more
3749 pages left in memory and it is OK to assume that the current
3750 section can be included in the current segment. */
3751 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
3753 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
3756 /* If putting this section in this segment would force us to
3757 skip a page in the segment, then we need a new segment. */
3760 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3761 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3763 /* We don't want to put a loadable section after a
3764 nonloadable section in the same segment.
3765 Consider .tbss sections as loadable for this purpose. */
3768 else if ((abfd
->flags
& D_PAGED
) == 0)
3770 /* If the file is not demand paged, which means that we
3771 don't require the sections to be correctly aligned in the
3772 file, then there is no other reason for a new segment. */
3773 new_segment
= FALSE
;
3776 && (hdr
->flags
& SEC_READONLY
) == 0
3777 && (((last_hdr
->lma
+ last_size
- 1)
3778 & ~(maxpagesize
- 1))
3779 != (hdr
->lma
& ~(maxpagesize
- 1))))
3781 /* We don't want to put a writable section in a read only
3782 segment, unless they are on the same page in memory
3783 anyhow. We already know that the last section does not
3784 bring us past the current section on the page, so the
3785 only case in which the new section is not on the same
3786 page as the previous section is when the previous section
3787 ends precisely on a page boundary. */
3792 /* Otherwise, we can use the same segment. */
3793 new_segment
= FALSE
;
3796 /* Allow interested parties a chance to override our decision. */
3797 if (last_hdr
!= NULL
3799 && info
->callbacks
->override_segment_assignment
!= NULL
)
3801 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
3807 if ((hdr
->flags
& SEC_READONLY
) == 0)
3810 /* .tbss sections effectively have zero size. */
3811 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
3812 != SEC_THREAD_LOCAL
)
3813 last_size
= hdr
->size
;
3819 /* We need a new program segment. We must create a new program
3820 header holding all the sections from phdr_index until hdr. */
3822 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3829 if ((hdr
->flags
& SEC_READONLY
) == 0)
3835 /* .tbss sections effectively have zero size. */
3836 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3837 last_size
= hdr
->size
;
3841 phdr_in_segment
= FALSE
;
3844 /* Create a final PT_LOAD program segment. */
3845 if (last_hdr
!= NULL
)
3847 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3855 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3858 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3865 /* For each batch of consecutive loadable .note sections,
3866 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3867 because if we link together nonloadable .note sections and
3868 loadable .note sections, we will generate two .note sections
3869 in the output file. FIXME: Using names for section types is
3871 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3873 if ((s
->flags
& SEC_LOAD
) != 0
3874 && CONST_STRNEQ (s
->name
, ".note"))
3879 amt
= sizeof (struct elf_segment_map
);
3880 if (s
->alignment_power
== 2)
3881 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
3883 if (s2
->next
->alignment_power
== 2
3884 && (s2
->next
->flags
& SEC_LOAD
) != 0
3885 && CONST_STRNEQ (s2
->next
->name
, ".note")
3886 && align_power (s2
->vma
+ s2
->size
, 2)
3892 amt
+= (count
- 1) * sizeof (asection
*);
3893 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3897 m
->p_type
= PT_NOTE
;
3901 m
->sections
[m
->count
- count
--] = s
;
3902 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3905 m
->sections
[m
->count
- 1] = s
;
3906 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3910 if (s
->flags
& SEC_THREAD_LOCAL
)
3918 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3921 amt
= sizeof (struct elf_segment_map
);
3922 amt
+= (tls_count
- 1) * sizeof (asection
*);
3923 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3928 m
->count
= tls_count
;
3929 /* Mandated PF_R. */
3931 m
->p_flags_valid
= 1;
3932 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
3934 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3935 m
->sections
[i
] = first_tls
;
3936 first_tls
= first_tls
->next
;
3943 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3945 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3946 if (eh_frame_hdr
!= NULL
3947 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3949 amt
= sizeof (struct elf_segment_map
);
3950 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3954 m
->p_type
= PT_GNU_EH_FRAME
;
3956 m
->sections
[0] = eh_frame_hdr
->output_section
;
3962 if (elf_tdata (abfd
)->stack_flags
)
3964 amt
= sizeof (struct elf_segment_map
);
3965 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3969 m
->p_type
= PT_GNU_STACK
;
3970 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3971 m
->p_flags_valid
= 1;
3977 if (info
!= NULL
&& info
->relro
)
3979 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3981 if (m
->p_type
== PT_LOAD
)
3983 asection
*last
= m
->sections
[m
->count
- 1];
3984 bfd_vma vaddr
= m
->sections
[0]->vma
;
3985 bfd_vma filesz
= last
->vma
- vaddr
+ last
->size
;
3987 if (vaddr
< info
->relro_end
3988 && vaddr
>= info
->relro_start
3989 && (vaddr
+ filesz
) >= info
->relro_end
)
3994 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3997 amt
= sizeof (struct elf_segment_map
);
3998 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4002 m
->p_type
= PT_GNU_RELRO
;
4004 m
->p_flags_valid
= 1;
4012 elf_tdata (abfd
)->segment_map
= mfirst
;
4015 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
4018 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4020 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
4025 if (sections
!= NULL
)
4030 /* Sort sections by address. */
4033 elf_sort_sections (const void *arg1
, const void *arg2
)
4035 const asection
*sec1
= *(const asection
**) arg1
;
4036 const asection
*sec2
= *(const asection
**) arg2
;
4037 bfd_size_type size1
, size2
;
4039 /* Sort by LMA first, since this is the address used to
4040 place the section into a segment. */
4041 if (sec1
->lma
< sec2
->lma
)
4043 else if (sec1
->lma
> sec2
->lma
)
4046 /* Then sort by VMA. Normally the LMA and the VMA will be
4047 the same, and this will do nothing. */
4048 if (sec1
->vma
< sec2
->vma
)
4050 else if (sec1
->vma
> sec2
->vma
)
4053 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4055 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4061 /* If the indicies are the same, do not return 0
4062 here, but continue to try the next comparison. */
4063 if (sec1
->target_index
- sec2
->target_index
!= 0)
4064 return sec1
->target_index
- sec2
->target_index
;
4069 else if (TOEND (sec2
))
4074 /* Sort by size, to put zero sized sections
4075 before others at the same address. */
4077 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4078 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4085 return sec1
->target_index
- sec2
->target_index
;
4088 /* Ian Lance Taylor writes:
4090 We shouldn't be using % with a negative signed number. That's just
4091 not good. We have to make sure either that the number is not
4092 negative, or that the number has an unsigned type. When the types
4093 are all the same size they wind up as unsigned. When file_ptr is a
4094 larger signed type, the arithmetic winds up as signed long long,
4097 What we're trying to say here is something like ``increase OFF by
4098 the least amount that will cause it to be equal to the VMA modulo
4100 /* In other words, something like:
4102 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4103 off_offset = off % bed->maxpagesize;
4104 if (vma_offset < off_offset)
4105 adjustment = vma_offset + bed->maxpagesize - off_offset;
4107 adjustment = vma_offset - off_offset;
4109 which can can be collapsed into the expression below. */
4112 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4114 return ((vma
- off
) % maxpagesize
);
4118 print_segment_map (const struct elf_segment_map
*m
)
4121 const char *pt
= get_segment_type (m
->p_type
);
4126 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4127 sprintf (buf
, "LOPROC+%7.7x",
4128 (unsigned int) (m
->p_type
- PT_LOPROC
));
4129 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4130 sprintf (buf
, "LOOS+%7.7x",
4131 (unsigned int) (m
->p_type
- PT_LOOS
));
4133 snprintf (buf
, sizeof (buf
), "%8.8x",
4134 (unsigned int) m
->p_type
);
4137 fprintf (stderr
, "%s:", pt
);
4138 for (j
= 0; j
< m
->count
; j
++)
4139 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4144 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
4149 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4151 buf
= bfd_zmalloc (len
);
4154 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
4159 /* Assign file positions to the sections based on the mapping from
4160 sections to segments. This function also sets up some fields in
4164 assign_file_positions_for_load_sections (bfd
*abfd
,
4165 struct bfd_link_info
*link_info
)
4167 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4168 struct elf_segment_map
*m
;
4169 Elf_Internal_Phdr
*phdrs
;
4170 Elf_Internal_Phdr
*p
;
4172 bfd_size_type maxpagesize
;
4175 bfd_vma header_pad
= 0;
4177 if (link_info
== NULL
4178 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
4182 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4186 header_pad
= m
->header_size
;
4189 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4190 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4191 elf_elfheader (abfd
)->e_phnum
= alloc
;
4193 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4194 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4196 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4197 >= alloc
* bed
->s
->sizeof_phdr
);
4201 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4205 /* We're writing the size in elf_tdata (abfd)->program_header_size,
4206 see assign_file_positions_except_relocs, so make sure we have
4207 that amount allocated, with trailing space cleared.
4208 The variable alloc contains the computed need, while elf_tdata
4209 (abfd)->program_header_size contains the size used for the
4211 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4212 where the layout is forced to according to a larger size in the
4213 last iterations for the testcase ld-elf/header. */
4214 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
% bed
->s
->sizeof_phdr
4216 phdrs
= (Elf_Internal_Phdr
*)
4218 (elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
),
4219 sizeof (Elf_Internal_Phdr
));
4220 elf_tdata (abfd
)->phdr
= phdrs
;
4225 if ((abfd
->flags
& D_PAGED
) != 0)
4226 maxpagesize
= bed
->maxpagesize
;
4228 off
= bed
->s
->sizeof_ehdr
;
4229 off
+= alloc
* bed
->s
->sizeof_phdr
;
4230 if (header_pad
< (bfd_vma
) off
)
4236 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4238 m
= m
->next
, p
++, j
++)
4242 bfd_boolean no_contents
;
4244 /* If elf_segment_map is not from map_sections_to_segments, the
4245 sections may not be correctly ordered. NOTE: sorting should
4246 not be done to the PT_NOTE section of a corefile, which may
4247 contain several pseudo-sections artificially created by bfd.
4248 Sorting these pseudo-sections breaks things badly. */
4250 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4251 && m
->p_type
== PT_NOTE
))
4252 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4255 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4256 number of sections with contents contributing to both p_filesz
4257 and p_memsz, followed by a number of sections with no contents
4258 that just contribute to p_memsz. In this loop, OFF tracks next
4259 available file offset for PT_LOAD and PT_NOTE segments. */
4260 p
->p_type
= m
->p_type
;
4261 p
->p_flags
= m
->p_flags
;
4266 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4268 if (m
->p_paddr_valid
)
4269 p
->p_paddr
= m
->p_paddr
;
4270 else if (m
->count
== 0)
4273 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4275 if (p
->p_type
== PT_LOAD
4276 && (abfd
->flags
& D_PAGED
) != 0)
4278 /* p_align in demand paged PT_LOAD segments effectively stores
4279 the maximum page size. When copying an executable with
4280 objcopy, we set m->p_align from the input file. Use this
4281 value for maxpagesize rather than bed->maxpagesize, which
4282 may be different. Note that we use maxpagesize for PT_TLS
4283 segment alignment later in this function, so we are relying
4284 on at least one PT_LOAD segment appearing before a PT_TLS
4286 if (m
->p_align_valid
)
4287 maxpagesize
= m
->p_align
;
4289 p
->p_align
= maxpagesize
;
4291 else if (m
->p_align_valid
)
4292 p
->p_align
= m
->p_align
;
4293 else if (m
->count
== 0)
4294 p
->p_align
= 1 << bed
->s
->log_file_align
;
4298 no_contents
= FALSE
;
4300 if (p
->p_type
== PT_LOAD
4303 bfd_size_type align
;
4304 unsigned int align_power
= 0;
4306 if (m
->p_align_valid
)
4310 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4312 unsigned int secalign
;
4314 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4315 if (secalign
> align_power
)
4316 align_power
= secalign
;
4318 align
= (bfd_size_type
) 1 << align_power
;
4319 if (align
< maxpagesize
)
4320 align
= maxpagesize
;
4323 for (i
= 0; i
< m
->count
; i
++)
4324 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4325 /* If we aren't making room for this section, then
4326 it must be SHT_NOBITS regardless of what we've
4327 set via struct bfd_elf_special_section. */
4328 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4330 /* Find out whether this segment contains any loadable
4333 for (i
= 0; i
< m
->count
; i
++)
4334 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
4336 no_contents
= FALSE
;
4340 off_adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4344 /* We shouldn't need to align the segment on disk since
4345 the segment doesn't need file space, but the gABI
4346 arguably requires the alignment and glibc ld.so
4347 checks it. So to comply with the alignment
4348 requirement but not waste file space, we adjust
4349 p_offset for just this segment. (OFF_ADJUST is
4350 subtracted from OFF later.) This may put p_offset
4351 past the end of file, but that shouldn't matter. */
4356 /* Make sure the .dynamic section is the first section in the
4357 PT_DYNAMIC segment. */
4358 else if (p
->p_type
== PT_DYNAMIC
4360 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4363 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4365 bfd_set_error (bfd_error_bad_value
);
4368 /* Set the note section type to SHT_NOTE. */
4369 else if (p
->p_type
== PT_NOTE
)
4370 for (i
= 0; i
< m
->count
; i
++)
4371 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
4377 if (m
->includes_filehdr
)
4379 if (!m
->p_flags_valid
)
4381 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4382 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4385 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4387 if (p
->p_vaddr
< (bfd_vma
) off
)
4389 (*_bfd_error_handler
)
4390 (_("%B: Not enough room for program headers, try linking with -N"),
4392 bfd_set_error (bfd_error_bad_value
);
4397 if (!m
->p_paddr_valid
)
4402 if (m
->includes_phdrs
)
4404 if (!m
->p_flags_valid
)
4407 if (!m
->includes_filehdr
)
4409 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4413 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4414 p
->p_vaddr
-= off
- p
->p_offset
;
4415 if (!m
->p_paddr_valid
)
4416 p
->p_paddr
-= off
- p
->p_offset
;
4420 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4421 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4424 p
->p_filesz
+= header_pad
;
4425 p
->p_memsz
+= header_pad
;
4429 if (p
->p_type
== PT_LOAD
4430 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4432 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4438 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4440 p
->p_filesz
+= adjust
;
4441 p
->p_memsz
+= adjust
;
4445 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4446 maps. Set filepos for sections in PT_LOAD segments, and in
4447 core files, for sections in PT_NOTE segments.
4448 assign_file_positions_for_non_load_sections will set filepos
4449 for other sections and update p_filesz for other segments. */
4450 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4453 bfd_size_type align
;
4454 Elf_Internal_Shdr
*this_hdr
;
4457 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4458 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4460 if ((p
->p_type
== PT_LOAD
4461 || p
->p_type
== PT_TLS
)
4462 && (this_hdr
->sh_type
!= SHT_NOBITS
4463 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4464 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4465 || p
->p_type
== PT_TLS
))))
4467 bfd_vma p_start
= p
->p_paddr
;
4468 bfd_vma p_end
= p_start
+ p
->p_memsz
;
4469 bfd_vma s_start
= sec
->lma
;
4470 bfd_vma adjust
= s_start
- p_end
;
4475 (*_bfd_error_handler
)
4476 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd
, sec
,
4477 (unsigned long) s_start
, (unsigned long) p_end
);
4481 p
->p_memsz
+= adjust
;
4483 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4485 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
4487 /* We have a PROGBITS section following NOBITS ones.
4488 Allocate file space for the NOBITS section(s) and
4490 adjust
= p
->p_memsz
- p
->p_filesz
;
4491 if (!write_zeros (abfd
, off
, adjust
))
4495 p
->p_filesz
+= adjust
;
4499 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4501 /* The section at i == 0 is the one that actually contains
4505 this_hdr
->sh_offset
= sec
->filepos
= off
;
4506 off
+= this_hdr
->sh_size
;
4507 p
->p_filesz
= this_hdr
->sh_size
;
4513 /* The rest are fake sections that shouldn't be written. */
4522 if (p
->p_type
== PT_LOAD
)
4524 this_hdr
->sh_offset
= sec
->filepos
= off
;
4525 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4526 off
+= this_hdr
->sh_size
;
4529 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4531 p
->p_filesz
+= this_hdr
->sh_size
;
4532 /* A load section without SHF_ALLOC is something like
4533 a note section in a PT_NOTE segment. These take
4534 file space but are not loaded into memory. */
4535 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4536 p
->p_memsz
+= this_hdr
->sh_size
;
4538 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4540 if (p
->p_type
== PT_TLS
)
4541 p
->p_memsz
+= this_hdr
->sh_size
;
4543 /* .tbss is special. It doesn't contribute to p_memsz of
4545 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4546 p
->p_memsz
+= this_hdr
->sh_size
;
4549 if (align
> p
->p_align
4550 && !m
->p_align_valid
4551 && (p
->p_type
!= PT_LOAD
4552 || (abfd
->flags
& D_PAGED
) == 0))
4556 if (!m
->p_flags_valid
)
4559 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4561 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4567 /* Check that all sections are in a PT_LOAD segment.
4568 Don't check funky gdb generated core files. */
4569 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4571 bfd_boolean check_vma
= TRUE
;
4573 for (i
= 1; i
< m
->count
; i
++)
4574 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
4575 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
4576 ->this_hdr
), p
) != 0
4577 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
4578 ->this_hdr
), p
) != 0)
4580 /* Looks like we have overlays packed into the segment. */
4585 for (i
= 0; i
< m
->count
; i
++)
4587 Elf_Internal_Shdr
*this_hdr
;
4590 sec
= m
->sections
[i
];
4591 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4592 if (this_hdr
->sh_size
!= 0
4593 && !ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
))
4595 (*_bfd_error_handler
)
4596 (_("%B: section `%A' can't be allocated in segment %d"),
4598 print_segment_map (m
);
4604 elf_tdata (abfd
)->next_file_pos
= off
;
4608 /* Assign file positions for the other sections. */
4611 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4612 struct bfd_link_info
*link_info
)
4614 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4615 Elf_Internal_Shdr
**i_shdrpp
;
4616 Elf_Internal_Shdr
**hdrpp
;
4617 Elf_Internal_Phdr
*phdrs
;
4618 Elf_Internal_Phdr
*p
;
4619 struct elf_segment_map
*m
;
4620 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4621 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4623 unsigned int num_sec
;
4627 i_shdrpp
= elf_elfsections (abfd
);
4628 num_sec
= elf_numsections (abfd
);
4629 off
= elf_tdata (abfd
)->next_file_pos
;
4630 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4632 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4633 Elf_Internal_Shdr
*hdr
;
4636 if (hdr
->bfd_section
!= NULL
4637 && (hdr
->bfd_section
->filepos
!= 0
4638 || (hdr
->sh_type
== SHT_NOBITS
4639 && hdr
->contents
== NULL
)))
4640 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4641 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4643 if (hdr
->sh_size
!= 0)
4644 ((*_bfd_error_handler
)
4645 (_("%B: warning: allocated section `%s' not in segment"),
4647 (hdr
->bfd_section
== NULL
4649 : hdr
->bfd_section
->name
)));
4650 /* We don't need to page align empty sections. */
4651 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4652 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4655 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4657 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4660 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4661 && hdr
->bfd_section
== NULL
)
4662 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4663 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4664 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4665 hdr
->sh_offset
= -1;
4667 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4670 /* Now that we have set the section file positions, we can set up
4671 the file positions for the non PT_LOAD segments. */
4675 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4677 phdrs
= elf_tdata (abfd
)->phdr
;
4678 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4683 if (p
->p_type
!= PT_LOAD
)
4686 if (m
->includes_filehdr
)
4688 filehdr_vaddr
= p
->p_vaddr
;
4689 filehdr_paddr
= p
->p_paddr
;
4691 if (m
->includes_phdrs
)
4693 phdrs_vaddr
= p
->p_vaddr
;
4694 phdrs_paddr
= p
->p_paddr
;
4695 if (m
->includes_filehdr
)
4697 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4698 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4703 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4707 if (p
->p_type
== PT_GNU_RELRO
)
4709 const Elf_Internal_Phdr
*lp
;
4711 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4713 if (link_info
!= NULL
)
4715 /* During linking the range of the RELRO segment is passed
4717 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4719 if (lp
->p_type
== PT_LOAD
4720 && lp
->p_vaddr
>= link_info
->relro_start
4721 && lp
->p_vaddr
< link_info
->relro_end
4722 && lp
->p_vaddr
+ lp
->p_filesz
>= link_info
->relro_end
)
4728 /* Otherwise we are copying an executable or shared
4729 library, but we need to use the same linker logic. */
4730 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4732 if (lp
->p_type
== PT_LOAD
4733 && lp
->p_paddr
== p
->p_paddr
)
4738 if (lp
< phdrs
+ count
)
4740 p
->p_vaddr
= lp
->p_vaddr
;
4741 p
->p_paddr
= lp
->p_paddr
;
4742 p
->p_offset
= lp
->p_offset
;
4743 if (link_info
!= NULL
)
4744 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4745 else if (m
->p_size_valid
)
4746 p
->p_filesz
= m
->p_size
;
4749 p
->p_memsz
= p
->p_filesz
;
4751 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4755 memset (p
, 0, sizeof *p
);
4756 p
->p_type
= PT_NULL
;
4759 else if (m
->count
!= 0)
4761 if (p
->p_type
!= PT_LOAD
4762 && (p
->p_type
!= PT_NOTE
4763 || bfd_get_format (abfd
) != bfd_core
))
4765 Elf_Internal_Shdr
*hdr
;
4768 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4770 sect
= m
->sections
[m
->count
- 1];
4771 hdr
= &elf_section_data (sect
)->this_hdr
;
4772 p
->p_filesz
= sect
->filepos
- m
->sections
[0]->filepos
;
4773 if (hdr
->sh_type
!= SHT_NOBITS
)
4774 p
->p_filesz
+= hdr
->sh_size
;
4775 p
->p_offset
= m
->sections
[0]->filepos
;
4778 else if (m
->includes_filehdr
)
4780 p
->p_vaddr
= filehdr_vaddr
;
4781 if (! m
->p_paddr_valid
)
4782 p
->p_paddr
= filehdr_paddr
;
4784 else if (m
->includes_phdrs
)
4786 p
->p_vaddr
= phdrs_vaddr
;
4787 if (! m
->p_paddr_valid
)
4788 p
->p_paddr
= phdrs_paddr
;
4792 elf_tdata (abfd
)->next_file_pos
= off
;
4797 /* Work out the file positions of all the sections. This is called by
4798 _bfd_elf_compute_section_file_positions. All the section sizes and
4799 VMAs must be known before this is called.
4801 Reloc sections come in two flavours: Those processed specially as
4802 "side-channel" data attached to a section to which they apply, and
4803 those that bfd doesn't process as relocations. The latter sort are
4804 stored in a normal bfd section by bfd_section_from_shdr. We don't
4805 consider the former sort here, unless they form part of the loadable
4806 image. Reloc sections not assigned here will be handled later by
4807 assign_file_positions_for_relocs.
4809 We also don't set the positions of the .symtab and .strtab here. */
4812 assign_file_positions_except_relocs (bfd
*abfd
,
4813 struct bfd_link_info
*link_info
)
4815 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4816 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4818 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4820 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4821 && bfd_get_format (abfd
) != bfd_core
)
4823 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4824 unsigned int num_sec
= elf_numsections (abfd
);
4825 Elf_Internal_Shdr
**hdrpp
;
4828 /* Start after the ELF header. */
4829 off
= i_ehdrp
->e_ehsize
;
4831 /* We are not creating an executable, which means that we are
4832 not creating a program header, and that the actual order of
4833 the sections in the file is unimportant. */
4834 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4836 Elf_Internal_Shdr
*hdr
;
4839 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4840 && hdr
->bfd_section
== NULL
)
4841 || i
== tdata
->symtab_section
4842 || i
== tdata
->symtab_shndx_section
4843 || i
== tdata
->strtab_section
)
4845 hdr
->sh_offset
= -1;
4848 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4855 /* Assign file positions for the loaded sections based on the
4856 assignment of sections to segments. */
4857 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4860 /* And for non-load sections. */
4861 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4864 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4866 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4870 /* Write out the program headers. */
4871 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4872 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4873 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4876 off
= tdata
->next_file_pos
;
4879 /* Place the section headers. */
4880 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4881 i_ehdrp
->e_shoff
= off
;
4882 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4884 tdata
->next_file_pos
= off
;
4890 prep_headers (bfd
*abfd
)
4892 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
4893 struct elf_strtab_hash
*shstrtab
;
4894 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4896 i_ehdrp
= elf_elfheader (abfd
);
4898 shstrtab
= _bfd_elf_strtab_init ();
4899 if (shstrtab
== NULL
)
4902 elf_shstrtab (abfd
) = shstrtab
;
4904 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4905 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4906 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4907 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4909 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4910 i_ehdrp
->e_ident
[EI_DATA
] =
4911 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4912 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4914 if ((abfd
->flags
& DYNAMIC
) != 0)
4915 i_ehdrp
->e_type
= ET_DYN
;
4916 else if ((abfd
->flags
& EXEC_P
) != 0)
4917 i_ehdrp
->e_type
= ET_EXEC
;
4918 else if (bfd_get_format (abfd
) == bfd_core
)
4919 i_ehdrp
->e_type
= ET_CORE
;
4921 i_ehdrp
->e_type
= ET_REL
;
4923 switch (bfd_get_arch (abfd
))
4925 case bfd_arch_unknown
:
4926 i_ehdrp
->e_machine
= EM_NONE
;
4929 /* There used to be a long list of cases here, each one setting
4930 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4931 in the corresponding bfd definition. To avoid duplication,
4932 the switch was removed. Machines that need special handling
4933 can generally do it in elf_backend_final_write_processing(),
4934 unless they need the information earlier than the final write.
4935 Such need can generally be supplied by replacing the tests for
4936 e_machine with the conditions used to determine it. */
4938 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4941 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4942 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4944 /* No program header, for now. */
4945 i_ehdrp
->e_phoff
= 0;
4946 i_ehdrp
->e_phentsize
= 0;
4947 i_ehdrp
->e_phnum
= 0;
4949 /* Each bfd section is section header entry. */
4950 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4951 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4953 /* If we're building an executable, we'll need a program header table. */
4954 if (abfd
->flags
& EXEC_P
)
4955 /* It all happens later. */
4959 i_ehdrp
->e_phentsize
= 0;
4960 i_ehdrp
->e_phoff
= 0;
4963 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4964 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4965 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4966 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4967 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4968 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4969 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4970 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4971 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4977 /* Assign file positions for all the reloc sections which are not part
4978 of the loadable file image. */
4981 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4984 unsigned int i
, num_sec
;
4985 Elf_Internal_Shdr
**shdrpp
;
4987 off
= elf_tdata (abfd
)->next_file_pos
;
4989 num_sec
= elf_numsections (abfd
);
4990 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4992 Elf_Internal_Shdr
*shdrp
;
4995 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4996 && shdrp
->sh_offset
== -1)
4997 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
5000 elf_tdata (abfd
)->next_file_pos
= off
;
5004 _bfd_elf_write_object_contents (bfd
*abfd
)
5006 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5007 Elf_Internal_Shdr
**i_shdrp
;
5009 unsigned int count
, num_sec
;
5011 if (! abfd
->output_has_begun
5012 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
5015 i_shdrp
= elf_elfsections (abfd
);
5018 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
5022 _bfd_elf_assign_file_positions_for_relocs (abfd
);
5024 /* After writing the headers, we need to write the sections too... */
5025 num_sec
= elf_numsections (abfd
);
5026 for (count
= 1; count
< num_sec
; count
++)
5028 if (bed
->elf_backend_section_processing
)
5029 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
5030 if (i_shdrp
[count
]->contents
)
5032 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
5034 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
5035 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
5040 /* Write out the section header names. */
5041 if (elf_shstrtab (abfd
) != NULL
5042 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
5043 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
5046 if (bed
->elf_backend_final_write_processing
)
5047 (*bed
->elf_backend_final_write_processing
) (abfd
,
5048 elf_tdata (abfd
)->linker
);
5050 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
5053 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5054 if (elf_tdata (abfd
)->after_write_object_contents
)
5055 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
5061 _bfd_elf_write_corefile_contents (bfd
*abfd
)
5063 /* Hopefully this can be done just like an object file. */
5064 return _bfd_elf_write_object_contents (abfd
);
5067 /* Given a section, search the header to find them. */
5070 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
5072 const struct elf_backend_data
*bed
;
5073 unsigned int sec_index
;
5075 if (elf_section_data (asect
) != NULL
5076 && elf_section_data (asect
)->this_idx
!= 0)
5077 return elf_section_data (asect
)->this_idx
;
5079 if (bfd_is_abs_section (asect
))
5080 sec_index
= SHN_ABS
;
5081 else if (bfd_is_com_section (asect
))
5082 sec_index
= SHN_COMMON
;
5083 else if (bfd_is_und_section (asect
))
5084 sec_index
= SHN_UNDEF
;
5086 sec_index
= SHN_BAD
;
5088 bed
= get_elf_backend_data (abfd
);
5089 if (bed
->elf_backend_section_from_bfd_section
)
5091 int retval
= sec_index
;
5093 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5097 if (sec_index
== SHN_BAD
)
5098 bfd_set_error (bfd_error_nonrepresentable_section
);
5103 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5107 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5109 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5111 flagword flags
= asym_ptr
->flags
;
5113 /* When gas creates relocations against local labels, it creates its
5114 own symbol for the section, but does put the symbol into the
5115 symbol chain, so udata is 0. When the linker is generating
5116 relocatable output, this section symbol may be for one of the
5117 input sections rather than the output section. */
5118 if (asym_ptr
->udata
.i
== 0
5119 && (flags
& BSF_SECTION_SYM
)
5120 && asym_ptr
->section
)
5125 sec
= asym_ptr
->section
;
5126 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5127 sec
= sec
->output_section
;
5128 if (sec
->owner
== abfd
5129 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5130 && elf_section_syms (abfd
)[indx
] != NULL
)
5131 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5134 idx
= asym_ptr
->udata
.i
;
5138 /* This case can occur when using --strip-symbol on a symbol
5139 which is used in a relocation entry. */
5140 (*_bfd_error_handler
)
5141 (_("%B: symbol `%s' required but not present"),
5142 abfd
, bfd_asymbol_name (asym_ptr
));
5143 bfd_set_error (bfd_error_no_symbols
);
5150 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5151 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
5152 elf_symbol_flags (flags
));
5160 /* Rewrite program header information. */
5163 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5165 Elf_Internal_Ehdr
*iehdr
;
5166 struct elf_segment_map
*map
;
5167 struct elf_segment_map
*map_first
;
5168 struct elf_segment_map
**pointer_to_map
;
5169 Elf_Internal_Phdr
*segment
;
5172 unsigned int num_segments
;
5173 bfd_boolean phdr_included
= FALSE
;
5174 bfd_boolean p_paddr_valid
;
5175 bfd_vma maxpagesize
;
5176 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5177 unsigned int phdr_adjust_num
= 0;
5178 const struct elf_backend_data
*bed
;
5180 bed
= get_elf_backend_data (ibfd
);
5181 iehdr
= elf_elfheader (ibfd
);
5184 pointer_to_map
= &map_first
;
5186 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5187 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5189 /* Returns the end address of the segment + 1. */
5190 #define SEGMENT_END(segment, start) \
5191 (start + (segment->p_memsz > segment->p_filesz \
5192 ? segment->p_memsz : segment->p_filesz))
5194 #define SECTION_SIZE(section, segment) \
5195 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5196 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5197 ? section->size : 0)
5199 /* Returns TRUE if the given section is contained within
5200 the given segment. VMA addresses are compared. */
5201 #define IS_CONTAINED_BY_VMA(section, segment) \
5202 (section->vma >= segment->p_vaddr \
5203 && (section->vma + SECTION_SIZE (section, segment) \
5204 <= (SEGMENT_END (segment, segment->p_vaddr))))
5206 /* Returns TRUE if the given section is contained within
5207 the given segment. LMA addresses are compared. */
5208 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5209 (section->lma >= base \
5210 && (section->lma + SECTION_SIZE (section, segment) \
5211 <= SEGMENT_END (segment, base)))
5213 /* Handle PT_NOTE segment. */
5214 #define IS_NOTE(p, s) \
5215 (p->p_type == PT_NOTE \
5216 && elf_section_type (s) == SHT_NOTE \
5217 && (bfd_vma) s->filepos >= p->p_offset \
5218 && ((bfd_vma) s->filepos + s->size \
5219 <= p->p_offset + p->p_filesz))
5221 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5223 #define IS_COREFILE_NOTE(p, s) \
5225 && bfd_get_format (ibfd) == bfd_core \
5229 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5230 linker, which generates a PT_INTERP section with p_vaddr and
5231 p_memsz set to 0. */
5232 #define IS_SOLARIS_PT_INTERP(p, s) \
5234 && p->p_paddr == 0 \
5235 && p->p_memsz == 0 \
5236 && p->p_filesz > 0 \
5237 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5239 && (bfd_vma) s->filepos >= p->p_offset \
5240 && ((bfd_vma) s->filepos + s->size \
5241 <= p->p_offset + p->p_filesz))
5243 /* Decide if the given section should be included in the given segment.
5244 A section will be included if:
5245 1. It is within the address space of the segment -- we use the LMA
5246 if that is set for the segment and the VMA otherwise,
5247 2. It is an allocated section or a NOTE section in a PT_NOTE
5249 3. There is an output section associated with it,
5250 4. The section has not already been allocated to a previous segment.
5251 5. PT_GNU_STACK segments do not include any sections.
5252 6. PT_TLS segment includes only SHF_TLS sections.
5253 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5254 8. PT_DYNAMIC should not contain empty sections at the beginning
5255 (with the possible exception of .dynamic). */
5256 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5257 ((((segment->p_paddr \
5258 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5259 : IS_CONTAINED_BY_VMA (section, segment)) \
5260 && (section->flags & SEC_ALLOC) != 0) \
5261 || IS_NOTE (segment, section)) \
5262 && segment->p_type != PT_GNU_STACK \
5263 && (segment->p_type != PT_TLS \
5264 || (section->flags & SEC_THREAD_LOCAL)) \
5265 && (segment->p_type == PT_LOAD \
5266 || segment->p_type == PT_TLS \
5267 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5268 && (segment->p_type != PT_DYNAMIC \
5269 || SECTION_SIZE (section, segment) > 0 \
5270 || (segment->p_paddr \
5271 ? segment->p_paddr != section->lma \
5272 : segment->p_vaddr != section->vma) \
5273 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5275 && !section->segment_mark)
5277 /* If the output section of a section in the input segment is NULL,
5278 it is removed from the corresponding output segment. */
5279 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5280 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5281 && section->output_section != NULL)
5283 /* Returns TRUE iff seg1 starts after the end of seg2. */
5284 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5285 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5287 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5288 their VMA address ranges and their LMA address ranges overlap.
5289 It is possible to have overlapping VMA ranges without overlapping LMA
5290 ranges. RedBoot images for example can have both .data and .bss mapped
5291 to the same VMA range, but with the .data section mapped to a different
5293 #define SEGMENT_OVERLAPS(seg1, seg2) \
5294 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5295 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5296 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5297 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5299 /* Initialise the segment mark field. */
5300 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5301 section
->segment_mark
= FALSE
;
5303 /* The Solaris linker creates program headers in which all the
5304 p_paddr fields are zero. When we try to objcopy or strip such a
5305 file, we get confused. Check for this case, and if we find it
5306 don't set the p_paddr_valid fields. */
5307 p_paddr_valid
= FALSE
;
5308 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5311 if (segment
->p_paddr
!= 0)
5313 p_paddr_valid
= TRUE
;
5317 /* Scan through the segments specified in the program header
5318 of the input BFD. For this first scan we look for overlaps
5319 in the loadable segments. These can be created by weird
5320 parameters to objcopy. Also, fix some solaris weirdness. */
5321 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5326 Elf_Internal_Phdr
*segment2
;
5328 if (segment
->p_type
== PT_INTERP
)
5329 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5330 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5332 /* Mininal change so that the normal section to segment
5333 assignment code will work. */
5334 segment
->p_vaddr
= section
->vma
;
5338 if (segment
->p_type
!= PT_LOAD
)
5340 /* Remove PT_GNU_RELRO segment. */
5341 if (segment
->p_type
== PT_GNU_RELRO
)
5342 segment
->p_type
= PT_NULL
;
5346 /* Determine if this segment overlaps any previous segments. */
5347 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5349 bfd_signed_vma extra_length
;
5351 if (segment2
->p_type
!= PT_LOAD
5352 || !SEGMENT_OVERLAPS (segment
, segment2
))
5355 /* Merge the two segments together. */
5356 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5358 /* Extend SEGMENT2 to include SEGMENT and then delete
5360 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5361 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5363 if (extra_length
> 0)
5365 segment2
->p_memsz
+= extra_length
;
5366 segment2
->p_filesz
+= extra_length
;
5369 segment
->p_type
= PT_NULL
;
5371 /* Since we have deleted P we must restart the outer loop. */
5373 segment
= elf_tdata (ibfd
)->phdr
;
5378 /* Extend SEGMENT to include SEGMENT2 and then delete
5380 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5381 - SEGMENT_END (segment
, segment
->p_vaddr
));
5383 if (extra_length
> 0)
5385 segment
->p_memsz
+= extra_length
;
5386 segment
->p_filesz
+= extra_length
;
5389 segment2
->p_type
= PT_NULL
;
5394 /* The second scan attempts to assign sections to segments. */
5395 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5399 unsigned int section_count
;
5400 asection
**sections
;
5401 asection
*output_section
;
5403 bfd_vma matching_lma
;
5404 bfd_vma suggested_lma
;
5407 asection
*first_section
;
5408 bfd_boolean first_matching_lma
;
5409 bfd_boolean first_suggested_lma
;
5411 if (segment
->p_type
== PT_NULL
)
5414 first_section
= NULL
;
5415 /* Compute how many sections might be placed into this segment. */
5416 for (section
= ibfd
->sections
, section_count
= 0;
5418 section
= section
->next
)
5420 /* Find the first section in the input segment, which may be
5421 removed from the corresponding output segment. */
5422 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5424 if (first_section
== NULL
)
5425 first_section
= section
;
5426 if (section
->output_section
!= NULL
)
5431 /* Allocate a segment map big enough to contain
5432 all of the sections we have selected. */
5433 amt
= sizeof (struct elf_segment_map
);
5434 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5435 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
5439 /* Initialise the fields of the segment map. Default to
5440 using the physical address of the segment in the input BFD. */
5442 map
->p_type
= segment
->p_type
;
5443 map
->p_flags
= segment
->p_flags
;
5444 map
->p_flags_valid
= 1;
5446 /* If the first section in the input segment is removed, there is
5447 no need to preserve segment physical address in the corresponding
5449 if (!first_section
|| first_section
->output_section
!= NULL
)
5451 map
->p_paddr
= segment
->p_paddr
;
5452 map
->p_paddr_valid
= p_paddr_valid
;
5455 /* Determine if this segment contains the ELF file header
5456 and if it contains the program headers themselves. */
5457 map
->includes_filehdr
= (segment
->p_offset
== 0
5458 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5459 map
->includes_phdrs
= 0;
5461 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
5463 map
->includes_phdrs
=
5464 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5465 && (segment
->p_offset
+ segment
->p_filesz
5466 >= ((bfd_vma
) iehdr
->e_phoff
5467 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5469 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5470 phdr_included
= TRUE
;
5473 if (section_count
== 0)
5475 /* Special segments, such as the PT_PHDR segment, may contain
5476 no sections, but ordinary, loadable segments should contain
5477 something. They are allowed by the ELF spec however, so only
5478 a warning is produced. */
5479 if (segment
->p_type
== PT_LOAD
)
5480 (*_bfd_error_handler
) (_("%B: warning: Empty loadable segment"
5481 " detected, is this intentional ?\n"),
5485 *pointer_to_map
= map
;
5486 pointer_to_map
= &map
->next
;
5491 /* Now scan the sections in the input BFD again and attempt
5492 to add their corresponding output sections to the segment map.
5493 The problem here is how to handle an output section which has
5494 been moved (ie had its LMA changed). There are four possibilities:
5496 1. None of the sections have been moved.
5497 In this case we can continue to use the segment LMA from the
5500 2. All of the sections have been moved by the same amount.
5501 In this case we can change the segment's LMA to match the LMA
5502 of the first section.
5504 3. Some of the sections have been moved, others have not.
5505 In this case those sections which have not been moved can be
5506 placed in the current segment which will have to have its size,
5507 and possibly its LMA changed, and a new segment or segments will
5508 have to be created to contain the other sections.
5510 4. The sections have been moved, but not by the same amount.
5511 In this case we can change the segment's LMA to match the LMA
5512 of the first section and we will have to create a new segment
5513 or segments to contain the other sections.
5515 In order to save time, we allocate an array to hold the section
5516 pointers that we are interested in. As these sections get assigned
5517 to a segment, they are removed from this array. */
5519 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
5520 if (sections
== NULL
)
5523 /* Step One: Scan for segment vs section LMA conflicts.
5524 Also add the sections to the section array allocated above.
5525 Also add the sections to the current segment. In the common
5526 case, where the sections have not been moved, this means that
5527 we have completely filled the segment, and there is nothing
5532 first_matching_lma
= TRUE
;
5533 first_suggested_lma
= TRUE
;
5535 for (section
= ibfd
->sections
;
5537 section
= section
->next
)
5538 if (section
== first_section
)
5541 for (j
= 0; section
!= NULL
; section
= section
->next
)
5543 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5545 output_section
= section
->output_section
;
5547 sections
[j
++] = section
;
5549 /* The Solaris native linker always sets p_paddr to 0.
5550 We try to catch that case here, and set it to the
5551 correct value. Note - some backends require that
5552 p_paddr be left as zero. */
5554 && segment
->p_vaddr
!= 0
5555 && !bed
->want_p_paddr_set_to_zero
5557 && output_section
->lma
!= 0
5558 && output_section
->vma
== (segment
->p_vaddr
5559 + (map
->includes_filehdr
5562 + (map
->includes_phdrs
5564 * iehdr
->e_phentsize
)
5566 map
->p_paddr
= segment
->p_vaddr
;
5568 /* Match up the physical address of the segment with the
5569 LMA address of the output section. */
5570 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5571 || IS_COREFILE_NOTE (segment
, section
)
5572 || (bed
->want_p_paddr_set_to_zero
5573 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
5575 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
5577 matching_lma
= output_section
->lma
;
5578 first_matching_lma
= FALSE
;
5581 /* We assume that if the section fits within the segment
5582 then it does not overlap any other section within that
5584 map
->sections
[isec
++] = output_section
;
5586 else if (first_suggested_lma
)
5588 suggested_lma
= output_section
->lma
;
5589 first_suggested_lma
= FALSE
;
5592 if (j
== section_count
)
5597 BFD_ASSERT (j
== section_count
);
5599 /* Step Two: Adjust the physical address of the current segment,
5601 if (isec
== section_count
)
5603 /* All of the sections fitted within the segment as currently
5604 specified. This is the default case. Add the segment to
5605 the list of built segments and carry on to process the next
5606 program header in the input BFD. */
5607 map
->count
= section_count
;
5608 *pointer_to_map
= map
;
5609 pointer_to_map
= &map
->next
;
5612 && !bed
->want_p_paddr_set_to_zero
5613 && matching_lma
!= map
->p_paddr
5614 && !map
->includes_filehdr
5615 && !map
->includes_phdrs
)
5616 /* There is some padding before the first section in the
5617 segment. So, we must account for that in the output
5619 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5626 if (!first_matching_lma
)
5628 /* At least one section fits inside the current segment.
5629 Keep it, but modify its physical address to match the
5630 LMA of the first section that fitted. */
5631 map
->p_paddr
= matching_lma
;
5635 /* None of the sections fitted inside the current segment.
5636 Change the current segment's physical address to match
5637 the LMA of the first section. */
5638 map
->p_paddr
= suggested_lma
;
5641 /* Offset the segment physical address from the lma
5642 to allow for space taken up by elf headers. */
5643 if (map
->includes_filehdr
)
5645 if (map
->p_paddr
>= iehdr
->e_ehsize
)
5646 map
->p_paddr
-= iehdr
->e_ehsize
;
5649 map
->includes_filehdr
= FALSE
;
5650 map
->includes_phdrs
= FALSE
;
5654 if (map
->includes_phdrs
)
5656 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
5658 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5660 /* iehdr->e_phnum is just an estimate of the number
5661 of program headers that we will need. Make a note
5662 here of the number we used and the segment we chose
5663 to hold these headers, so that we can adjust the
5664 offset when we know the correct value. */
5665 phdr_adjust_num
= iehdr
->e_phnum
;
5666 phdr_adjust_seg
= map
;
5669 map
->includes_phdrs
= FALSE
;
5673 /* Step Three: Loop over the sections again, this time assigning
5674 those that fit to the current segment and removing them from the
5675 sections array; but making sure not to leave large gaps. Once all
5676 possible sections have been assigned to the current segment it is
5677 added to the list of built segments and if sections still remain
5678 to be assigned, a new segment is constructed before repeating
5685 first_suggested_lma
= TRUE
;
5687 /* Fill the current segment with sections that fit. */
5688 for (j
= 0; j
< section_count
; j
++)
5690 section
= sections
[j
];
5692 if (section
== NULL
)
5695 output_section
= section
->output_section
;
5697 BFD_ASSERT (output_section
!= NULL
);
5699 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5700 || IS_COREFILE_NOTE (segment
, section
))
5702 if (map
->count
== 0)
5704 /* If the first section in a segment does not start at
5705 the beginning of the segment, then something is
5707 if (output_section
->lma
5709 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5710 + (map
->includes_phdrs
5711 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5719 prev_sec
= map
->sections
[map
->count
- 1];
5721 /* If the gap between the end of the previous section
5722 and the start of this section is more than
5723 maxpagesize then we need to start a new segment. */
5724 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5726 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5727 || (prev_sec
->lma
+ prev_sec
->size
5728 > output_section
->lma
))
5730 if (first_suggested_lma
)
5732 suggested_lma
= output_section
->lma
;
5733 first_suggested_lma
= FALSE
;
5740 map
->sections
[map
->count
++] = output_section
;
5743 section
->segment_mark
= TRUE
;
5745 else if (first_suggested_lma
)
5747 suggested_lma
= output_section
->lma
;
5748 first_suggested_lma
= FALSE
;
5752 BFD_ASSERT (map
->count
> 0);
5754 /* Add the current segment to the list of built segments. */
5755 *pointer_to_map
= map
;
5756 pointer_to_map
= &map
->next
;
5758 if (isec
< section_count
)
5760 /* We still have not allocated all of the sections to
5761 segments. Create a new segment here, initialise it
5762 and carry on looping. */
5763 amt
= sizeof (struct elf_segment_map
);
5764 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5765 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
5772 /* Initialise the fields of the segment map. Set the physical
5773 physical address to the LMA of the first section that has
5774 not yet been assigned. */
5776 map
->p_type
= segment
->p_type
;
5777 map
->p_flags
= segment
->p_flags
;
5778 map
->p_flags_valid
= 1;
5779 map
->p_paddr
= suggested_lma
;
5780 map
->p_paddr_valid
= p_paddr_valid
;
5781 map
->includes_filehdr
= 0;
5782 map
->includes_phdrs
= 0;
5785 while (isec
< section_count
);
5790 elf_tdata (obfd
)->segment_map
= map_first
;
5792 /* If we had to estimate the number of program headers that were
5793 going to be needed, then check our estimate now and adjust
5794 the offset if necessary. */
5795 if (phdr_adjust_seg
!= NULL
)
5799 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5802 if (count
> phdr_adjust_num
)
5803 phdr_adjust_seg
->p_paddr
5804 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5809 #undef IS_CONTAINED_BY_VMA
5810 #undef IS_CONTAINED_BY_LMA
5812 #undef IS_COREFILE_NOTE
5813 #undef IS_SOLARIS_PT_INTERP
5814 #undef IS_SECTION_IN_INPUT_SEGMENT
5815 #undef INCLUDE_SECTION_IN_SEGMENT
5816 #undef SEGMENT_AFTER_SEGMENT
5817 #undef SEGMENT_OVERLAPS
5821 /* Copy ELF program header information. */
5824 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5826 Elf_Internal_Ehdr
*iehdr
;
5827 struct elf_segment_map
*map
;
5828 struct elf_segment_map
*map_first
;
5829 struct elf_segment_map
**pointer_to_map
;
5830 Elf_Internal_Phdr
*segment
;
5832 unsigned int num_segments
;
5833 bfd_boolean phdr_included
= FALSE
;
5834 bfd_boolean p_paddr_valid
;
5836 iehdr
= elf_elfheader (ibfd
);
5839 pointer_to_map
= &map_first
;
5841 /* If all the segment p_paddr fields are zero, don't set
5842 map->p_paddr_valid. */
5843 p_paddr_valid
= FALSE
;
5844 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5845 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5848 if (segment
->p_paddr
!= 0)
5850 p_paddr_valid
= TRUE
;
5854 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5859 unsigned int section_count
;
5861 Elf_Internal_Shdr
*this_hdr
;
5862 asection
*first_section
= NULL
;
5863 asection
*lowest_section
= NULL
;
5865 /* Compute how many sections are in this segment. */
5866 for (section
= ibfd
->sections
, section_count
= 0;
5868 section
= section
->next
)
5870 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5871 if (this_hdr
->sh_size
!= 0
5872 && ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
5875 first_section
= lowest_section
= section
;
5876 if (section
->lma
< lowest_section
->lma
)
5877 lowest_section
= section
;
5882 /* Allocate a segment map big enough to contain
5883 all of the sections we have selected. */
5884 amt
= sizeof (struct elf_segment_map
);
5885 if (section_count
!= 0)
5886 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5887 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
5891 /* Initialize the fields of the output segment map with the
5894 map
->p_type
= segment
->p_type
;
5895 map
->p_flags
= segment
->p_flags
;
5896 map
->p_flags_valid
= 1;
5897 map
->p_paddr
= segment
->p_paddr
;
5898 map
->p_paddr_valid
= p_paddr_valid
;
5899 map
->p_align
= segment
->p_align
;
5900 map
->p_align_valid
= 1;
5901 map
->p_vaddr_offset
= 0;
5903 if (map
->p_type
== PT_GNU_RELRO
)
5905 /* The PT_GNU_RELRO segment may contain the first a few
5906 bytes in the .got.plt section even if the whole .got.plt
5907 section isn't in the PT_GNU_RELRO segment. We won't
5908 change the size of the PT_GNU_RELRO segment. */
5909 map
->p_size
= segment
->p_memsz
;
5910 map
->p_size_valid
= 1;
5913 /* Determine if this segment contains the ELF file header
5914 and if it contains the program headers themselves. */
5915 map
->includes_filehdr
= (segment
->p_offset
== 0
5916 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5918 map
->includes_phdrs
= 0;
5919 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5921 map
->includes_phdrs
=
5922 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5923 && (segment
->p_offset
+ segment
->p_filesz
5924 >= ((bfd_vma
) iehdr
->e_phoff
5925 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5927 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5928 phdr_included
= TRUE
;
5931 if (map
->includes_filehdr
&& first_section
)
5932 /* We need to keep the space used by the headers fixed. */
5933 map
->header_size
= first_section
->vma
- segment
->p_vaddr
;
5935 if (!map
->includes_phdrs
5936 && !map
->includes_filehdr
5937 && map
->p_paddr_valid
)
5938 /* There is some other padding before the first section. */
5939 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
5940 - segment
->p_paddr
);
5942 if (section_count
!= 0)
5944 unsigned int isec
= 0;
5946 for (section
= first_section
;
5948 section
= section
->next
)
5950 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5951 if (this_hdr
->sh_size
!= 0
5952 && ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
5954 map
->sections
[isec
++] = section
->output_section
;
5955 if (isec
== section_count
)
5961 map
->count
= section_count
;
5962 *pointer_to_map
= map
;
5963 pointer_to_map
= &map
->next
;
5966 elf_tdata (obfd
)->segment_map
= map_first
;
5970 /* Copy private BFD data. This copies or rewrites ELF program header
5974 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5976 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5977 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5980 if (elf_tdata (ibfd
)->phdr
== NULL
)
5983 if (ibfd
->xvec
== obfd
->xvec
)
5985 /* Check to see if any sections in the input BFD
5986 covered by ELF program header have changed. */
5987 Elf_Internal_Phdr
*segment
;
5988 asection
*section
, *osec
;
5989 unsigned int i
, num_segments
;
5990 Elf_Internal_Shdr
*this_hdr
;
5991 const struct elf_backend_data
*bed
;
5993 bed
= get_elf_backend_data (ibfd
);
5995 /* Regenerate the segment map if p_paddr is set to 0. */
5996 if (bed
->want_p_paddr_set_to_zero
)
5999 /* Initialize the segment mark field. */
6000 for (section
= obfd
->sections
; section
!= NULL
;
6001 section
= section
->next
)
6002 section
->segment_mark
= FALSE
;
6004 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6005 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6009 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6010 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6011 which severly confuses things, so always regenerate the segment
6012 map in this case. */
6013 if (segment
->p_paddr
== 0
6014 && segment
->p_memsz
== 0
6015 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
6018 for (section
= ibfd
->sections
;
6019 section
!= NULL
; section
= section
->next
)
6021 /* We mark the output section so that we know it comes
6022 from the input BFD. */
6023 osec
= section
->output_section
;
6025 osec
->segment_mark
= TRUE
;
6027 /* Check if this section is covered by the segment. */
6028 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6029 if (this_hdr
->sh_size
!= 0
6030 && ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6032 /* FIXME: Check if its output section is changed or
6033 removed. What else do we need to check? */
6035 || section
->flags
!= osec
->flags
6036 || section
->lma
!= osec
->lma
6037 || section
->vma
!= osec
->vma
6038 || section
->size
!= osec
->size
6039 || section
->rawsize
!= osec
->rawsize
6040 || section
->alignment_power
!= osec
->alignment_power
)
6046 /* Check to see if any output section do not come from the
6048 for (section
= obfd
->sections
; section
!= NULL
;
6049 section
= section
->next
)
6051 if (section
->segment_mark
== FALSE
)
6054 section
->segment_mark
= FALSE
;
6057 return copy_elf_program_header (ibfd
, obfd
);
6061 return rewrite_elf_program_header (ibfd
, obfd
);
6064 /* Initialize private output section information from input section. */
6067 _bfd_elf_init_private_section_data (bfd
*ibfd
,
6071 struct bfd_link_info
*link_info
)
6074 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6075 bfd_boolean final_link
= link_info
!= NULL
&& !link_info
->relocatable
;
6077 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6078 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6081 /* For objcopy and relocatable link, don't copy the output ELF
6082 section type from input if the output BFD section flags have been
6083 set to something different. For a final link allow some flags
6084 that the linker clears to differ. */
6085 if (elf_section_type (osec
) == SHT_NULL
6086 && (osec
->flags
== isec
->flags
6088 && ((osec
->flags
^ isec
->flags
)
6089 & ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
)) == 0)))
6090 elf_section_type (osec
) = elf_section_type (isec
);
6092 /* FIXME: Is this correct for all OS/PROC specific flags? */
6093 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6094 & (SHF_MASKOS
| SHF_MASKPROC
));
6096 /* Set things up for objcopy and relocatable link. The output
6097 SHT_GROUP section will have its elf_next_in_group pointing back
6098 to the input group members. Ignore linker created group section.
6099 See elfNN_ia64_object_p in elfxx-ia64.c. */
6102 if (elf_sec_group (isec
) == NULL
6103 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
6105 if (elf_section_flags (isec
) & SHF_GROUP
)
6106 elf_section_flags (osec
) |= SHF_GROUP
;
6107 elf_next_in_group (osec
) = elf_next_in_group (isec
);
6108 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
6112 ihdr
= &elf_section_data (isec
)->this_hdr
;
6114 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6115 don't use the output section of the linked-to section since it
6116 may be NULL at this point. */
6117 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
6119 ohdr
= &elf_section_data (osec
)->this_hdr
;
6120 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
6121 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6124 osec
->use_rela_p
= isec
->use_rela_p
;
6129 /* Copy private section information. This copies over the entsize
6130 field, and sometimes the info field. */
6133 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6138 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6140 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6141 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6144 ihdr
= &elf_section_data (isec
)->this_hdr
;
6145 ohdr
= &elf_section_data (osec
)->this_hdr
;
6147 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6149 if (ihdr
->sh_type
== SHT_SYMTAB
6150 || ihdr
->sh_type
== SHT_DYNSYM
6151 || ihdr
->sh_type
== SHT_GNU_verneed
6152 || ihdr
->sh_type
== SHT_GNU_verdef
)
6153 ohdr
->sh_info
= ihdr
->sh_info
;
6155 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6159 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6160 necessary if we are removing either the SHT_GROUP section or any of
6161 the group member sections. DISCARDED is the value that a section's
6162 output_section has if the section will be discarded, NULL when this
6163 function is called from objcopy, bfd_abs_section_ptr when called
6167 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
6171 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6172 if (elf_section_type (isec
) == SHT_GROUP
)
6174 asection
*first
= elf_next_in_group (isec
);
6175 asection
*s
= first
;
6176 bfd_size_type removed
= 0;
6180 /* If this member section is being output but the
6181 SHT_GROUP section is not, then clear the group info
6182 set up by _bfd_elf_copy_private_section_data. */
6183 if (s
->output_section
!= discarded
6184 && isec
->output_section
== discarded
)
6186 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6187 elf_group_name (s
->output_section
) = NULL
;
6189 /* Conversely, if the member section is not being output
6190 but the SHT_GROUP section is, then adjust its size. */
6191 else if (s
->output_section
== discarded
6192 && isec
->output_section
!= discarded
)
6194 s
= elf_next_in_group (s
);
6200 if (discarded
!= NULL
)
6202 /* If we've been called for ld -r, then we need to
6203 adjust the input section size. This function may
6204 be called multiple times, so save the original
6206 if (isec
->rawsize
== 0)
6207 isec
->rawsize
= isec
->size
;
6208 isec
->size
= isec
->rawsize
- removed
;
6212 /* Adjust the output section size when called from
6214 isec
->output_section
->size
-= removed
;
6222 /* Copy private header information. */
6225 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6227 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6228 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6231 /* Copy over private BFD data if it has not already been copied.
6232 This must be done here, rather than in the copy_private_bfd_data
6233 entry point, because the latter is called after the section
6234 contents have been set, which means that the program headers have
6235 already been worked out. */
6236 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6238 if (! copy_private_bfd_data (ibfd
, obfd
))
6242 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
6245 /* Copy private symbol information. If this symbol is in a section
6246 which we did not map into a BFD section, try to map the section
6247 index correctly. We use special macro definitions for the mapped
6248 section indices; these definitions are interpreted by the
6249 swap_out_syms function. */
6251 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6252 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6253 #define MAP_STRTAB (SHN_HIOS + 3)
6254 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6255 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6258 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6263 elf_symbol_type
*isym
, *osym
;
6265 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6266 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6269 isym
= elf_symbol_from (ibfd
, isymarg
);
6270 osym
= elf_symbol_from (obfd
, osymarg
);
6273 && isym
->internal_elf_sym
.st_shndx
!= 0
6275 && bfd_is_abs_section (isym
->symbol
.section
))
6279 shndx
= isym
->internal_elf_sym
.st_shndx
;
6280 if (shndx
== elf_onesymtab (ibfd
))
6281 shndx
= MAP_ONESYMTAB
;
6282 else if (shndx
== elf_dynsymtab (ibfd
))
6283 shndx
= MAP_DYNSYMTAB
;
6284 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
6286 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
6287 shndx
= MAP_SHSTRTAB
;
6288 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
6289 shndx
= MAP_SYM_SHNDX
;
6290 osym
->internal_elf_sym
.st_shndx
= shndx
;
6296 /* Swap out the symbols. */
6299 swap_out_syms (bfd
*abfd
,
6300 struct bfd_strtab_hash
**sttp
,
6303 const struct elf_backend_data
*bed
;
6306 struct bfd_strtab_hash
*stt
;
6307 Elf_Internal_Shdr
*symtab_hdr
;
6308 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6309 Elf_Internal_Shdr
*symstrtab_hdr
;
6310 bfd_byte
*outbound_syms
;
6311 bfd_byte
*outbound_shndx
;
6314 bfd_boolean name_local_sections
;
6316 if (!elf_map_symbols (abfd
))
6319 /* Dump out the symtabs. */
6320 stt
= _bfd_elf_stringtab_init ();
6324 bed
= get_elf_backend_data (abfd
);
6325 symcount
= bfd_get_symcount (abfd
);
6326 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6327 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6328 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6329 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6330 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6331 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
6333 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6334 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6336 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
6337 bed
->s
->sizeof_sym
);
6338 if (outbound_syms
== NULL
)
6340 _bfd_stringtab_free (stt
);
6343 symtab_hdr
->contents
= outbound_syms
;
6345 outbound_shndx
= NULL
;
6346 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6347 if (symtab_shndx_hdr
->sh_name
!= 0)
6349 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6350 outbound_shndx
= (bfd_byte
*)
6351 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
6352 if (outbound_shndx
== NULL
)
6354 _bfd_stringtab_free (stt
);
6358 symtab_shndx_hdr
->contents
= outbound_shndx
;
6359 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6360 symtab_shndx_hdr
->sh_size
= amt
;
6361 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6362 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6365 /* Now generate the data (for "contents"). */
6367 /* Fill in zeroth symbol and swap it out. */
6368 Elf_Internal_Sym sym
;
6374 sym
.st_shndx
= SHN_UNDEF
;
6375 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6376 outbound_syms
+= bed
->s
->sizeof_sym
;
6377 if (outbound_shndx
!= NULL
)
6378 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6382 = (bed
->elf_backend_name_local_section_symbols
6383 && bed
->elf_backend_name_local_section_symbols (abfd
));
6385 syms
= bfd_get_outsymbols (abfd
);
6386 for (idx
= 0; idx
< symcount
; idx
++)
6388 Elf_Internal_Sym sym
;
6389 bfd_vma value
= syms
[idx
]->value
;
6390 elf_symbol_type
*type_ptr
;
6391 flagword flags
= syms
[idx
]->flags
;
6394 if (!name_local_sections
6395 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6397 /* Local section symbols have no name. */
6402 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6405 if (sym
.st_name
== (unsigned long) -1)
6407 _bfd_stringtab_free (stt
);
6412 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6414 if ((flags
& BSF_SECTION_SYM
) == 0
6415 && bfd_is_com_section (syms
[idx
]->section
))
6417 /* ELF common symbols put the alignment into the `value' field,
6418 and the size into the `size' field. This is backwards from
6419 how BFD handles it, so reverse it here. */
6420 sym
.st_size
= value
;
6421 if (type_ptr
== NULL
6422 || type_ptr
->internal_elf_sym
.st_value
== 0)
6423 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6425 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6426 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6427 (abfd
, syms
[idx
]->section
);
6431 asection
*sec
= syms
[idx
]->section
;
6434 if (sec
->output_section
)
6436 value
+= sec
->output_offset
;
6437 sec
= sec
->output_section
;
6440 /* Don't add in the section vma for relocatable output. */
6441 if (! relocatable_p
)
6443 sym
.st_value
= value
;
6444 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6446 if (bfd_is_abs_section (sec
)
6448 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6450 /* This symbol is in a real ELF section which we did
6451 not create as a BFD section. Undo the mapping done
6452 by copy_private_symbol_data. */
6453 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6457 shndx
= elf_onesymtab (abfd
);
6460 shndx
= elf_dynsymtab (abfd
);
6463 shndx
= elf_tdata (abfd
)->strtab_section
;
6466 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6469 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6477 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6479 if (shndx
== SHN_BAD
)
6483 /* Writing this would be a hell of a lot easier if
6484 we had some decent documentation on bfd, and
6485 knew what to expect of the library, and what to
6486 demand of applications. For example, it
6487 appears that `objcopy' might not set the
6488 section of a symbol to be a section that is
6489 actually in the output file. */
6490 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6493 _bfd_error_handler (_("\
6494 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6495 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6497 bfd_set_error (bfd_error_invalid_operation
);
6498 _bfd_stringtab_free (stt
);
6502 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6503 BFD_ASSERT (shndx
!= SHN_BAD
);
6507 sym
.st_shndx
= shndx
;
6510 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6512 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
6513 type
= STT_GNU_IFUNC
;
6514 else if ((flags
& BSF_FUNCTION
) != 0)
6516 else if ((flags
& BSF_OBJECT
) != 0)
6518 else if ((flags
& BSF_RELC
) != 0)
6520 else if ((flags
& BSF_SRELC
) != 0)
6525 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6528 /* Processor-specific types. */
6529 if (type_ptr
!= NULL
6530 && bed
->elf_backend_get_symbol_type
)
6531 type
= ((*bed
->elf_backend_get_symbol_type
)
6532 (&type_ptr
->internal_elf_sym
, type
));
6534 if (flags
& BSF_SECTION_SYM
)
6536 if (flags
& BSF_GLOBAL
)
6537 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6539 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6541 else if (bfd_is_com_section (syms
[idx
]->section
))
6543 #ifdef USE_STT_COMMON
6544 if (type
== STT_OBJECT
)
6545 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_COMMON
);
6548 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
6550 else if (bfd_is_und_section (syms
[idx
]->section
))
6551 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6555 else if (flags
& BSF_FILE
)
6556 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6559 int bind
= STB_LOCAL
;
6561 if (flags
& BSF_LOCAL
)
6563 else if (flags
& BSF_GNU_UNIQUE
)
6564 bind
= STB_GNU_UNIQUE
;
6565 else if (flags
& BSF_WEAK
)
6567 else if (flags
& BSF_GLOBAL
)
6570 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6573 if (type_ptr
!= NULL
)
6574 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6578 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6579 outbound_syms
+= bed
->s
->sizeof_sym
;
6580 if (outbound_shndx
!= NULL
)
6581 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6585 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6586 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6588 symstrtab_hdr
->sh_flags
= 0;
6589 symstrtab_hdr
->sh_addr
= 0;
6590 symstrtab_hdr
->sh_entsize
= 0;
6591 symstrtab_hdr
->sh_link
= 0;
6592 symstrtab_hdr
->sh_info
= 0;
6593 symstrtab_hdr
->sh_addralign
= 1;
6598 /* Return the number of bytes required to hold the symtab vector.
6600 Note that we base it on the count plus 1, since we will null terminate
6601 the vector allocated based on this size. However, the ELF symbol table
6602 always has a dummy entry as symbol #0, so it ends up even. */
6605 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6609 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6611 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6612 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6614 symtab_size
-= sizeof (asymbol
*);
6620 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6624 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6626 if (elf_dynsymtab (abfd
) == 0)
6628 bfd_set_error (bfd_error_invalid_operation
);
6632 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6633 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6635 symtab_size
-= sizeof (asymbol
*);
6641 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6644 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6647 /* Canonicalize the relocs. */
6650 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6657 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6659 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6662 tblptr
= section
->relocation
;
6663 for (i
= 0; i
< section
->reloc_count
; i
++)
6664 *relptr
++ = tblptr
++;
6668 return section
->reloc_count
;
6672 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6674 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6675 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6678 bfd_get_symcount (abfd
) = symcount
;
6683 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6684 asymbol
**allocation
)
6686 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6687 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6690 bfd_get_dynamic_symcount (abfd
) = symcount
;
6694 /* Return the size required for the dynamic reloc entries. Any loadable
6695 section that was actually installed in the BFD, and has type SHT_REL
6696 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6697 dynamic reloc section. */
6700 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6705 if (elf_dynsymtab (abfd
) == 0)
6707 bfd_set_error (bfd_error_invalid_operation
);
6711 ret
= sizeof (arelent
*);
6712 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6713 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6714 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6715 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6716 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6717 * sizeof (arelent
*));
6722 /* Canonicalize the dynamic relocation entries. Note that we return the
6723 dynamic relocations as a single block, although they are actually
6724 associated with particular sections; the interface, which was
6725 designed for SunOS style shared libraries, expects that there is only
6726 one set of dynamic relocs. Any loadable section that was actually
6727 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6728 dynamic symbol table, is considered to be a dynamic reloc section. */
6731 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6735 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6739 if (elf_dynsymtab (abfd
) == 0)
6741 bfd_set_error (bfd_error_invalid_operation
);
6745 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6747 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6749 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6750 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6751 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6756 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6758 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6760 for (i
= 0; i
< count
; i
++)
6771 /* Read in the version information. */
6774 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6776 bfd_byte
*contents
= NULL
;
6777 unsigned int freeidx
= 0;
6779 if (elf_dynverref (abfd
) != 0)
6781 Elf_Internal_Shdr
*hdr
;
6782 Elf_External_Verneed
*everneed
;
6783 Elf_Internal_Verneed
*iverneed
;
6785 bfd_byte
*contents_end
;
6787 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6789 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
6790 bfd_zalloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
6791 if (elf_tdata (abfd
)->verref
== NULL
)
6794 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6796 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
6797 if (contents
== NULL
)
6799 error_return_verref
:
6800 elf_tdata (abfd
)->verref
= NULL
;
6801 elf_tdata (abfd
)->cverrefs
= 0;
6804 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6805 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6806 goto error_return_verref
;
6808 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6809 goto error_return_verref
;
6811 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6812 == sizeof (Elf_External_Vernaux
));
6813 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6814 everneed
= (Elf_External_Verneed
*) contents
;
6815 iverneed
= elf_tdata (abfd
)->verref
;
6816 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6818 Elf_External_Vernaux
*evernaux
;
6819 Elf_Internal_Vernaux
*ivernaux
;
6822 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6824 iverneed
->vn_bfd
= abfd
;
6826 iverneed
->vn_filename
=
6827 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6829 if (iverneed
->vn_filename
== NULL
)
6830 goto error_return_verref
;
6832 if (iverneed
->vn_cnt
== 0)
6833 iverneed
->vn_auxptr
= NULL
;
6836 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
6837 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6838 sizeof (Elf_Internal_Vernaux
));
6839 if (iverneed
->vn_auxptr
== NULL
)
6840 goto error_return_verref
;
6843 if (iverneed
->vn_aux
6844 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6845 goto error_return_verref
;
6847 evernaux
= ((Elf_External_Vernaux
*)
6848 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6849 ivernaux
= iverneed
->vn_auxptr
;
6850 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6852 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6854 ivernaux
->vna_nodename
=
6855 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6856 ivernaux
->vna_name
);
6857 if (ivernaux
->vna_nodename
== NULL
)
6858 goto error_return_verref
;
6860 if (j
+ 1 < iverneed
->vn_cnt
)
6861 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6863 ivernaux
->vna_nextptr
= NULL
;
6865 if (ivernaux
->vna_next
6866 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6867 goto error_return_verref
;
6869 evernaux
= ((Elf_External_Vernaux
*)
6870 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6872 if (ivernaux
->vna_other
> freeidx
)
6873 freeidx
= ivernaux
->vna_other
;
6876 if (i
+ 1 < hdr
->sh_info
)
6877 iverneed
->vn_nextref
= iverneed
+ 1;
6879 iverneed
->vn_nextref
= NULL
;
6881 if (iverneed
->vn_next
6882 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6883 goto error_return_verref
;
6885 everneed
= ((Elf_External_Verneed
*)
6886 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6893 if (elf_dynverdef (abfd
) != 0)
6895 Elf_Internal_Shdr
*hdr
;
6896 Elf_External_Verdef
*everdef
;
6897 Elf_Internal_Verdef
*iverdef
;
6898 Elf_Internal_Verdef
*iverdefarr
;
6899 Elf_Internal_Verdef iverdefmem
;
6901 unsigned int maxidx
;
6902 bfd_byte
*contents_end_def
, *contents_end_aux
;
6904 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6906 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
6907 if (contents
== NULL
)
6909 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6910 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6913 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6916 BFD_ASSERT (sizeof (Elf_External_Verdef
)
6917 >= sizeof (Elf_External_Verdaux
));
6918 contents_end_def
= contents
+ hdr
->sh_size
6919 - sizeof (Elf_External_Verdef
);
6920 contents_end_aux
= contents
+ hdr
->sh_size
6921 - sizeof (Elf_External_Verdaux
);
6923 /* We know the number of entries in the section but not the maximum
6924 index. Therefore we have to run through all entries and find
6926 everdef
= (Elf_External_Verdef
*) contents
;
6928 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6930 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6932 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6933 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6935 if (iverdefmem
.vd_next
6936 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
6939 everdef
= ((Elf_External_Verdef
*)
6940 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6943 if (default_imported_symver
)
6945 if (freeidx
> maxidx
)
6950 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
6951 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
6952 if (elf_tdata (abfd
)->verdef
== NULL
)
6955 elf_tdata (abfd
)->cverdefs
= maxidx
;
6957 everdef
= (Elf_External_Verdef
*) contents
;
6958 iverdefarr
= elf_tdata (abfd
)->verdef
;
6959 for (i
= 0; i
< hdr
->sh_info
; i
++)
6961 Elf_External_Verdaux
*everdaux
;
6962 Elf_Internal_Verdaux
*iverdaux
;
6965 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6967 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
6969 error_return_verdef
:
6970 elf_tdata (abfd
)->verdef
= NULL
;
6971 elf_tdata (abfd
)->cverdefs
= 0;
6975 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6976 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6978 iverdef
->vd_bfd
= abfd
;
6980 if (iverdef
->vd_cnt
== 0)
6981 iverdef
->vd_auxptr
= NULL
;
6984 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
6985 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
6986 sizeof (Elf_Internal_Verdaux
));
6987 if (iverdef
->vd_auxptr
== NULL
)
6988 goto error_return_verdef
;
6992 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
6993 goto error_return_verdef
;
6995 everdaux
= ((Elf_External_Verdaux
*)
6996 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6997 iverdaux
= iverdef
->vd_auxptr
;
6998 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
7000 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
7002 iverdaux
->vda_nodename
=
7003 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7004 iverdaux
->vda_name
);
7005 if (iverdaux
->vda_nodename
== NULL
)
7006 goto error_return_verdef
;
7008 if (j
+ 1 < iverdef
->vd_cnt
)
7009 iverdaux
->vda_nextptr
= iverdaux
+ 1;
7011 iverdaux
->vda_nextptr
= NULL
;
7013 if (iverdaux
->vda_next
7014 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
7015 goto error_return_verdef
;
7017 everdaux
= ((Elf_External_Verdaux
*)
7018 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
7021 if (iverdef
->vd_cnt
)
7022 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
7024 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
7025 iverdef
->vd_nextdef
= iverdef
+ 1;
7027 iverdef
->vd_nextdef
= NULL
;
7029 everdef
= ((Elf_External_Verdef
*)
7030 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
7036 else if (default_imported_symver
)
7043 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7044 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
7045 if (elf_tdata (abfd
)->verdef
== NULL
)
7048 elf_tdata (abfd
)->cverdefs
= freeidx
;
7051 /* Create a default version based on the soname. */
7052 if (default_imported_symver
)
7054 Elf_Internal_Verdef
*iverdef
;
7055 Elf_Internal_Verdaux
*iverdaux
;
7057 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
7059 iverdef
->vd_version
= VER_DEF_CURRENT
;
7060 iverdef
->vd_flags
= 0;
7061 iverdef
->vd_ndx
= freeidx
;
7062 iverdef
->vd_cnt
= 1;
7064 iverdef
->vd_bfd
= abfd
;
7066 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
7067 if (iverdef
->vd_nodename
== NULL
)
7068 goto error_return_verdef
;
7069 iverdef
->vd_nextdef
= NULL
;
7070 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
7071 bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
7072 if (iverdef
->vd_auxptr
== NULL
)
7073 goto error_return_verdef
;
7075 iverdaux
= iverdef
->vd_auxptr
;
7076 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
7077 iverdaux
->vda_nextptr
= NULL
;
7083 if (contents
!= NULL
)
7089 _bfd_elf_make_empty_symbol (bfd
*abfd
)
7091 elf_symbol_type
*newsym
;
7092 bfd_size_type amt
= sizeof (elf_symbol_type
);
7094 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
7099 newsym
->symbol
.the_bfd
= abfd
;
7100 return &newsym
->symbol
;
7105 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
7109 bfd_symbol_info (symbol
, ret
);
7112 /* Return whether a symbol name implies a local symbol. Most targets
7113 use this function for the is_local_label_name entry point, but some
7117 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
7120 /* Normal local symbols start with ``.L''. */
7121 if (name
[0] == '.' && name
[1] == 'L')
7124 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7125 DWARF debugging symbols starting with ``..''. */
7126 if (name
[0] == '.' && name
[1] == '.')
7129 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7130 emitting DWARF debugging output. I suspect this is actually a
7131 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7132 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7133 underscore to be emitted on some ELF targets). For ease of use,
7134 we treat such symbols as local. */
7135 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
7142 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
7143 asymbol
*symbol ATTRIBUTE_UNUSED
)
7150 _bfd_elf_set_arch_mach (bfd
*abfd
,
7151 enum bfd_architecture arch
,
7152 unsigned long machine
)
7154 /* If this isn't the right architecture for this backend, and this
7155 isn't the generic backend, fail. */
7156 if (arch
!= get_elf_backend_data (abfd
)->arch
7157 && arch
!= bfd_arch_unknown
7158 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
7161 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
7164 /* Find the function to a particular section and offset,
7165 for error reporting. */
7168 elf_find_function (bfd
*abfd
,
7172 const char **filename_ptr
,
7173 const char **functionname_ptr
)
7175 const char *filename
;
7176 asymbol
*func
, *file
;
7179 /* ??? Given multiple file symbols, it is impossible to reliably
7180 choose the right file name for global symbols. File symbols are
7181 local symbols, and thus all file symbols must sort before any
7182 global symbols. The ELF spec may be interpreted to say that a
7183 file symbol must sort before other local symbols, but currently
7184 ld -r doesn't do this. So, for ld -r output, it is possible to
7185 make a better choice of file name for local symbols by ignoring
7186 file symbols appearing after a given local symbol. */
7187 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
7188 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7194 state
= nothing_seen
;
7196 for (p
= symbols
; *p
!= NULL
; p
++)
7201 q
= (elf_symbol_type
*) *p
;
7203 type
= ELF_ST_TYPE (q
->internal_elf_sym
.st_info
);
7208 if (state
== symbol_seen
)
7209 state
= file_after_symbol_seen
;
7212 if (!bed
->is_function_type (type
))
7215 if (bfd_get_section (&q
->symbol
) == section
7216 && q
->symbol
.value
>= low_func
7217 && q
->symbol
.value
<= offset
)
7219 func
= (asymbol
*) q
;
7220 low_func
= q
->symbol
.value
;
7223 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
7224 || state
!= file_after_symbol_seen
))
7225 filename
= bfd_asymbol_name (file
);
7229 if (state
== nothing_seen
)
7230 state
= symbol_seen
;
7237 *filename_ptr
= filename
;
7238 if (functionname_ptr
)
7239 *functionname_ptr
= bfd_asymbol_name (func
);
7244 /* Find the nearest line to a particular section and offset,
7245 for error reporting. */
7248 _bfd_elf_find_nearest_line (bfd
*abfd
,
7252 const char **filename_ptr
,
7253 const char **functionname_ptr
,
7254 unsigned int *line_ptr
)
7258 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7259 filename_ptr
, functionname_ptr
,
7262 if (!*functionname_ptr
)
7263 elf_find_function (abfd
, section
, symbols
, offset
,
7264 *filename_ptr
? NULL
: filename_ptr
,
7270 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7271 filename_ptr
, functionname_ptr
,
7273 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7275 if (!*functionname_ptr
)
7276 elf_find_function (abfd
, section
, symbols
, offset
,
7277 *filename_ptr
? NULL
: filename_ptr
,
7283 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7284 &found
, filename_ptr
,
7285 functionname_ptr
, line_ptr
,
7286 &elf_tdata (abfd
)->line_info
))
7288 if (found
&& (*functionname_ptr
|| *line_ptr
))
7291 if (symbols
== NULL
)
7294 if (! elf_find_function (abfd
, section
, symbols
, offset
,
7295 filename_ptr
, functionname_ptr
))
7302 /* Find the line for a symbol. */
7305 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7306 const char **filename_ptr
, unsigned int *line_ptr
)
7308 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
7309 filename_ptr
, line_ptr
, 0,
7310 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7313 /* After a call to bfd_find_nearest_line, successive calls to
7314 bfd_find_inliner_info can be used to get source information about
7315 each level of function inlining that terminated at the address
7316 passed to bfd_find_nearest_line. Currently this is only supported
7317 for DWARF2 with appropriate DWARF3 extensions. */
7320 _bfd_elf_find_inliner_info (bfd
*abfd
,
7321 const char **filename_ptr
,
7322 const char **functionname_ptr
,
7323 unsigned int *line_ptr
)
7326 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7327 functionname_ptr
, line_ptr
,
7328 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7333 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7335 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7336 int ret
= bed
->s
->sizeof_ehdr
;
7338 if (!info
->relocatable
)
7340 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7342 if (phdr_size
== (bfd_size_type
) -1)
7344 struct elf_segment_map
*m
;
7347 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7348 phdr_size
+= bed
->s
->sizeof_phdr
;
7351 phdr_size
= get_program_header_size (abfd
, info
);
7354 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7362 _bfd_elf_set_section_contents (bfd
*abfd
,
7364 const void *location
,
7366 bfd_size_type count
)
7368 Elf_Internal_Shdr
*hdr
;
7371 if (! abfd
->output_has_begun
7372 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7375 hdr
= &elf_section_data (section
)->this_hdr
;
7376 pos
= hdr
->sh_offset
+ offset
;
7377 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7378 || bfd_bwrite (location
, count
, abfd
) != count
)
7385 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7386 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7387 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7392 /* Try to convert a non-ELF reloc into an ELF one. */
7395 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7397 /* Check whether we really have an ELF howto. */
7399 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7401 bfd_reloc_code_real_type code
;
7402 reloc_howto_type
*howto
;
7404 /* Alien reloc: Try to determine its type to replace it with an
7405 equivalent ELF reloc. */
7407 if (areloc
->howto
->pc_relative
)
7409 switch (areloc
->howto
->bitsize
)
7412 code
= BFD_RELOC_8_PCREL
;
7415 code
= BFD_RELOC_12_PCREL
;
7418 code
= BFD_RELOC_16_PCREL
;
7421 code
= BFD_RELOC_24_PCREL
;
7424 code
= BFD_RELOC_32_PCREL
;
7427 code
= BFD_RELOC_64_PCREL
;
7433 howto
= bfd_reloc_type_lookup (abfd
, code
);
7435 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7437 if (howto
->pcrel_offset
)
7438 areloc
->addend
+= areloc
->address
;
7440 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7445 switch (areloc
->howto
->bitsize
)
7451 code
= BFD_RELOC_14
;
7454 code
= BFD_RELOC_16
;
7457 code
= BFD_RELOC_26
;
7460 code
= BFD_RELOC_32
;
7463 code
= BFD_RELOC_64
;
7469 howto
= bfd_reloc_type_lookup (abfd
, code
);
7473 areloc
->howto
= howto
;
7481 (*_bfd_error_handler
)
7482 (_("%B: unsupported relocation type %s"),
7483 abfd
, areloc
->howto
->name
);
7484 bfd_set_error (bfd_error_bad_value
);
7489 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7491 if (bfd_get_format (abfd
) == bfd_object
)
7493 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7494 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7495 _bfd_dwarf2_cleanup_debug_info (abfd
);
7498 return _bfd_generic_close_and_cleanup (abfd
);
7501 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7502 in the relocation's offset. Thus we cannot allow any sort of sanity
7503 range-checking to interfere. There is nothing else to do in processing
7506 bfd_reloc_status_type
7507 _bfd_elf_rel_vtable_reloc_fn
7508 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7509 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7510 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7511 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7513 return bfd_reloc_ok
;
7516 /* Elf core file support. Much of this only works on native
7517 toolchains, since we rely on knowing the
7518 machine-dependent procfs structure in order to pick
7519 out details about the corefile. */
7521 #ifdef HAVE_SYS_PROCFS_H
7522 /* Needed for new procfs interface on sparc-solaris. */
7523 # define _STRUCTURED_PROC 1
7524 # include <sys/procfs.h>
7527 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7530 elfcore_make_pid (bfd
*abfd
)
7532 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
7533 + (elf_tdata (abfd
)->core_pid
));
7536 /* If there isn't a section called NAME, make one, using
7537 data from SECT. Note, this function will generate a
7538 reference to NAME, so you shouldn't deallocate or
7542 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7546 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7549 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7553 sect2
->size
= sect
->size
;
7554 sect2
->filepos
= sect
->filepos
;
7555 sect2
->alignment_power
= sect
->alignment_power
;
7559 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7560 actually creates up to two pseudosections:
7561 - For the single-threaded case, a section named NAME, unless
7562 such a section already exists.
7563 - For the multi-threaded case, a section named "NAME/PID", where
7564 PID is elfcore_make_pid (abfd).
7565 Both pseudosections have identical contents. */
7567 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7573 char *threaded_name
;
7577 /* Build the section name. */
7579 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7580 len
= strlen (buf
) + 1;
7581 threaded_name
= (char *) bfd_alloc (abfd
, len
);
7582 if (threaded_name
== NULL
)
7584 memcpy (threaded_name
, buf
, len
);
7586 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7591 sect
->filepos
= filepos
;
7592 sect
->alignment_power
= 2;
7594 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7597 /* prstatus_t exists on:
7599 linux 2.[01] + glibc
7603 #if defined (HAVE_PRSTATUS_T)
7606 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7611 if (note
->descsz
== sizeof (prstatus_t
))
7615 size
= sizeof (prstat
.pr_reg
);
7616 offset
= offsetof (prstatus_t
, pr_reg
);
7617 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7619 /* Do not overwrite the core signal if it
7620 has already been set by another thread. */
7621 if (elf_tdata (abfd
)->core_signal
== 0)
7622 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7623 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7625 /* pr_who exists on:
7628 pr_who doesn't exist on:
7631 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7632 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7635 #if defined (HAVE_PRSTATUS32_T)
7636 else if (note
->descsz
== sizeof (prstatus32_t
))
7638 /* 64-bit host, 32-bit corefile */
7639 prstatus32_t prstat
;
7641 size
= sizeof (prstat
.pr_reg
);
7642 offset
= offsetof (prstatus32_t
, pr_reg
);
7643 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7645 /* Do not overwrite the core signal if it
7646 has already been set by another thread. */
7647 if (elf_tdata (abfd
)->core_signal
== 0)
7648 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7649 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7651 /* pr_who exists on:
7654 pr_who doesn't exist on:
7657 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7658 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7661 #endif /* HAVE_PRSTATUS32_T */
7664 /* Fail - we don't know how to handle any other
7665 note size (ie. data object type). */
7669 /* Make a ".reg/999" section and a ".reg" section. */
7670 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7671 size
, note
->descpos
+ offset
);
7673 #endif /* defined (HAVE_PRSTATUS_T) */
7675 /* Create a pseudosection containing the exact contents of NOTE. */
7677 elfcore_make_note_pseudosection (bfd
*abfd
,
7679 Elf_Internal_Note
*note
)
7681 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7682 note
->descsz
, note
->descpos
);
7685 /* There isn't a consistent prfpregset_t across platforms,
7686 but it doesn't matter, because we don't have to pick this
7687 data structure apart. */
7690 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7692 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7695 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7696 type of NT_PRXFPREG. Just include the whole note's contents
7700 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7702 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7705 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
7706 with a note type of NT_X86_XSTATE. Just include the whole note's
7707 contents literally. */
7710 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
7712 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
7716 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
7718 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
7722 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
7724 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
7728 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
7730 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
7734 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
7736 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
7740 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
7742 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
7746 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7748 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
7752 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
7754 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
7758 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
7760 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
7763 #if defined (HAVE_PRPSINFO_T)
7764 typedef prpsinfo_t elfcore_psinfo_t
;
7765 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7766 typedef prpsinfo32_t elfcore_psinfo32_t
;
7770 #if defined (HAVE_PSINFO_T)
7771 typedef psinfo_t elfcore_psinfo_t
;
7772 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7773 typedef psinfo32_t elfcore_psinfo32_t
;
7777 /* return a malloc'ed copy of a string at START which is at
7778 most MAX bytes long, possibly without a terminating '\0'.
7779 the copy will always have a terminating '\0'. */
7782 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7785 char *end
= (char *) memchr (start
, '\0', max
);
7793 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
7797 memcpy (dups
, start
, len
);
7803 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7805 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7807 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7809 elfcore_psinfo_t psinfo
;
7811 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7813 elf_tdata (abfd
)->core_program
7814 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7815 sizeof (psinfo
.pr_fname
));
7817 elf_tdata (abfd
)->core_command
7818 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7819 sizeof (psinfo
.pr_psargs
));
7821 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7822 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7824 /* 64-bit host, 32-bit corefile */
7825 elfcore_psinfo32_t psinfo
;
7827 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7829 elf_tdata (abfd
)->core_program
7830 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7831 sizeof (psinfo
.pr_fname
));
7833 elf_tdata (abfd
)->core_command
7834 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7835 sizeof (psinfo
.pr_psargs
));
7841 /* Fail - we don't know how to handle any other
7842 note size (ie. data object type). */
7846 /* Note that for some reason, a spurious space is tacked
7847 onto the end of the args in some (at least one anyway)
7848 implementations, so strip it off if it exists. */
7851 char *command
= elf_tdata (abfd
)->core_command
;
7852 int n
= strlen (command
);
7854 if (0 < n
&& command
[n
- 1] == ' ')
7855 command
[n
- 1] = '\0';
7860 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7862 #if defined (HAVE_PSTATUS_T)
7864 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7866 if (note
->descsz
== sizeof (pstatus_t
)
7867 #if defined (HAVE_PXSTATUS_T)
7868 || note
->descsz
== sizeof (pxstatus_t
)
7874 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7876 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7878 #if defined (HAVE_PSTATUS32_T)
7879 else if (note
->descsz
== sizeof (pstatus32_t
))
7881 /* 64-bit host, 32-bit corefile */
7884 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7886 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7889 /* Could grab some more details from the "representative"
7890 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7891 NT_LWPSTATUS note, presumably. */
7895 #endif /* defined (HAVE_PSTATUS_T) */
7897 #if defined (HAVE_LWPSTATUS_T)
7899 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7901 lwpstatus_t lwpstat
;
7907 if (note
->descsz
!= sizeof (lwpstat
)
7908 #if defined (HAVE_LWPXSTATUS_T)
7909 && note
->descsz
!= sizeof (lwpxstatus_t
)
7914 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7916 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7917 /* Do not overwrite the core signal if it has already been set by
7919 if (elf_tdata (abfd
)->core_signal
== 0)
7920 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7922 /* Make a ".reg/999" section. */
7924 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7925 len
= strlen (buf
) + 1;
7926 name
= bfd_alloc (abfd
, len
);
7929 memcpy (name
, buf
, len
);
7931 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7935 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7936 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7937 sect
->filepos
= note
->descpos
7938 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7941 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7942 sect
->size
= sizeof (lwpstat
.pr_reg
);
7943 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7946 sect
->alignment_power
= 2;
7948 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7951 /* Make a ".reg2/999" section */
7953 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7954 len
= strlen (buf
) + 1;
7955 name
= bfd_alloc (abfd
, len
);
7958 memcpy (name
, buf
, len
);
7960 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7964 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7965 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7966 sect
->filepos
= note
->descpos
7967 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7970 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7971 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7972 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7975 sect
->alignment_power
= 2;
7977 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7979 #endif /* defined (HAVE_LWPSTATUS_T) */
7982 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7989 int is_active_thread
;
7992 if (note
->descsz
< 728)
7995 if (! CONST_STRNEQ (note
->namedata
, "win32"))
7998 type
= bfd_get_32 (abfd
, note
->descdata
);
8002 case 1 /* NOTE_INFO_PROCESS */:
8003 /* FIXME: need to add ->core_command. */
8004 /* process_info.pid */
8005 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8006 /* process_info.signal */
8007 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
8010 case 2 /* NOTE_INFO_THREAD */:
8011 /* Make a ".reg/999" section. */
8012 /* thread_info.tid */
8013 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
8015 len
= strlen (buf
) + 1;
8016 name
= (char *) bfd_alloc (abfd
, len
);
8020 memcpy (name
, buf
, len
);
8022 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8026 /* sizeof (thread_info.thread_context) */
8028 /* offsetof (thread_info.thread_context) */
8029 sect
->filepos
= note
->descpos
+ 12;
8030 sect
->alignment_power
= 2;
8032 /* thread_info.is_active_thread */
8033 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8035 if (is_active_thread
)
8036 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8040 case 3 /* NOTE_INFO_MODULE */:
8041 /* Make a ".module/xxxxxxxx" section. */
8042 /* module_info.base_address */
8043 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
8044 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
8046 len
= strlen (buf
) + 1;
8047 name
= (char *) bfd_alloc (abfd
, len
);
8051 memcpy (name
, buf
, len
);
8053 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8058 sect
->size
= note
->descsz
;
8059 sect
->filepos
= note
->descpos
;
8060 sect
->alignment_power
= 2;
8071 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8073 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8081 if (bed
->elf_backend_grok_prstatus
)
8082 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
8084 #if defined (HAVE_PRSTATUS_T)
8085 return elfcore_grok_prstatus (abfd
, note
);
8090 #if defined (HAVE_PSTATUS_T)
8092 return elfcore_grok_pstatus (abfd
, note
);
8095 #if defined (HAVE_LWPSTATUS_T)
8097 return elfcore_grok_lwpstatus (abfd
, note
);
8100 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
8101 return elfcore_grok_prfpreg (abfd
, note
);
8103 case NT_WIN32PSTATUS
:
8104 return elfcore_grok_win32pstatus (abfd
, note
);
8106 case NT_PRXFPREG
: /* Linux SSE extension */
8107 if (note
->namesz
== 6
8108 && strcmp (note
->namedata
, "LINUX") == 0)
8109 return elfcore_grok_prxfpreg (abfd
, note
);
8113 case NT_X86_XSTATE
: /* Linux XSAVE extension */
8114 if (note
->namesz
== 6
8115 && strcmp (note
->namedata
, "LINUX") == 0)
8116 return elfcore_grok_xstatereg (abfd
, note
);
8121 if (note
->namesz
== 6
8122 && strcmp (note
->namedata
, "LINUX") == 0)
8123 return elfcore_grok_ppc_vmx (abfd
, note
);
8128 if (note
->namesz
== 6
8129 && strcmp (note
->namedata
, "LINUX") == 0)
8130 return elfcore_grok_ppc_vsx (abfd
, note
);
8134 case NT_S390_HIGH_GPRS
:
8135 if (note
->namesz
== 6
8136 && strcmp (note
->namedata
, "LINUX") == 0)
8137 return elfcore_grok_s390_high_gprs (abfd
, note
);
8142 if (note
->namesz
== 6
8143 && strcmp (note
->namedata
, "LINUX") == 0)
8144 return elfcore_grok_s390_timer (abfd
, note
);
8148 case NT_S390_TODCMP
:
8149 if (note
->namesz
== 6
8150 && strcmp (note
->namedata
, "LINUX") == 0)
8151 return elfcore_grok_s390_todcmp (abfd
, note
);
8155 case NT_S390_TODPREG
:
8156 if (note
->namesz
== 6
8157 && strcmp (note
->namedata
, "LINUX") == 0)
8158 return elfcore_grok_s390_todpreg (abfd
, note
);
8163 if (note
->namesz
== 6
8164 && strcmp (note
->namedata
, "LINUX") == 0)
8165 return elfcore_grok_s390_ctrs (abfd
, note
);
8169 case NT_S390_PREFIX
:
8170 if (note
->namesz
== 6
8171 && strcmp (note
->namedata
, "LINUX") == 0)
8172 return elfcore_grok_s390_prefix (abfd
, note
);
8178 if (bed
->elf_backend_grok_psinfo
)
8179 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
8181 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8182 return elfcore_grok_psinfo (abfd
, note
);
8189 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
8194 sect
->size
= note
->descsz
;
8195 sect
->filepos
= note
->descpos
;
8196 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8204 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
8206 elf_tdata (abfd
)->build_id_size
= note
->descsz
;
8207 elf_tdata (abfd
)->build_id
= (bfd_byte
*) bfd_alloc (abfd
, note
->descsz
);
8208 if (elf_tdata (abfd
)->build_id
== NULL
)
8211 memcpy (elf_tdata (abfd
)->build_id
, note
->descdata
, note
->descsz
);
8217 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8224 case NT_GNU_BUILD_ID
:
8225 return elfobj_grok_gnu_build_id (abfd
, note
);
8230 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
8234 cp
= strchr (note
->namedata
, '@');
8237 *lwpidp
= atoi(cp
+ 1);
8244 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8246 /* Signal number at offset 0x08. */
8247 elf_tdata (abfd
)->core_signal
8248 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8250 /* Process ID at offset 0x50. */
8251 elf_tdata (abfd
)->core_pid
8252 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
8254 /* Command name at 0x7c (max 32 bytes, including nul). */
8255 elf_tdata (abfd
)->core_command
8256 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
8258 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
8263 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8267 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
8268 elf_tdata (abfd
)->core_lwpid
= lwp
;
8270 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
8272 /* NetBSD-specific core "procinfo". Note that we expect to
8273 find this note before any of the others, which is fine,
8274 since the kernel writes this note out first when it
8275 creates a core file. */
8277 return elfcore_grok_netbsd_procinfo (abfd
, note
);
8280 /* As of Jan 2002 there are no other machine-independent notes
8281 defined for NetBSD core files. If the note type is less
8282 than the start of the machine-dependent note types, we don't
8285 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
8289 switch (bfd_get_arch (abfd
))
8291 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8292 PT_GETFPREGS == mach+2. */
8294 case bfd_arch_alpha
:
8295 case bfd_arch_sparc
:
8298 case NT_NETBSDCORE_FIRSTMACH
+0:
8299 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8301 case NT_NETBSDCORE_FIRSTMACH
+2:
8302 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8308 /* On all other arch's, PT_GETREGS == mach+1 and
8309 PT_GETFPREGS == mach+3. */
8314 case NT_NETBSDCORE_FIRSTMACH
+1:
8315 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8317 case NT_NETBSDCORE_FIRSTMACH
+3:
8318 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8328 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8330 /* Signal number at offset 0x08. */
8331 elf_tdata (abfd
)->core_signal
8332 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8334 /* Process ID at offset 0x20. */
8335 elf_tdata (abfd
)->core_pid
8336 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
8338 /* Command name at 0x48 (max 32 bytes, including nul). */
8339 elf_tdata (abfd
)->core_command
8340 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
8346 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8348 if (note
->type
== NT_OPENBSD_PROCINFO
)
8349 return elfcore_grok_openbsd_procinfo (abfd
, note
);
8351 if (note
->type
== NT_OPENBSD_REGS
)
8352 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8354 if (note
->type
== NT_OPENBSD_FPREGS
)
8355 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8357 if (note
->type
== NT_OPENBSD_XFPREGS
)
8358 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
8360 if (note
->type
== NT_OPENBSD_AUXV
)
8362 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
8367 sect
->size
= note
->descsz
;
8368 sect
->filepos
= note
->descpos
;
8369 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8374 if (note
->type
== NT_OPENBSD_WCOOKIE
)
8376 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
8381 sect
->size
= note
->descsz
;
8382 sect
->filepos
= note
->descpos
;
8383 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8392 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
8394 void *ddata
= note
->descdata
;
8401 /* nto_procfs_status 'pid' field is at offset 0. */
8402 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
8404 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8405 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
8407 /* nto_procfs_status 'flags' field is at offset 8. */
8408 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
8410 /* nto_procfs_status 'what' field is at offset 14. */
8411 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
8413 elf_tdata (abfd
)->core_signal
= sig
;
8414 elf_tdata (abfd
)->core_lwpid
= *tid
;
8417 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8418 do not come from signals so we make sure we set the current
8419 thread just in case. */
8420 if (flags
& 0x00000080)
8421 elf_tdata (abfd
)->core_lwpid
= *tid
;
8423 /* Make a ".qnx_core_status/%d" section. */
8424 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
8426 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
8431 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8435 sect
->size
= note
->descsz
;
8436 sect
->filepos
= note
->descpos
;
8437 sect
->alignment_power
= 2;
8439 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
8443 elfcore_grok_nto_regs (bfd
*abfd
,
8444 Elf_Internal_Note
*note
,
8452 /* Make a "(base)/%d" section. */
8453 sprintf (buf
, "%s/%ld", base
, tid
);
8455 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
8460 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8464 sect
->size
= note
->descsz
;
8465 sect
->filepos
= note
->descpos
;
8466 sect
->alignment_power
= 2;
8468 /* This is the current thread. */
8469 if (elf_tdata (abfd
)->core_lwpid
== tid
)
8470 return elfcore_maybe_make_sect (abfd
, base
, sect
);
8475 #define BFD_QNT_CORE_INFO 7
8476 #define BFD_QNT_CORE_STATUS 8
8477 #define BFD_QNT_CORE_GREG 9
8478 #define BFD_QNT_CORE_FPREG 10
8481 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8483 /* Every GREG section has a STATUS section before it. Store the
8484 tid from the previous call to pass down to the next gregs
8486 static long tid
= 1;
8490 case BFD_QNT_CORE_INFO
:
8491 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
8492 case BFD_QNT_CORE_STATUS
:
8493 return elfcore_grok_nto_status (abfd
, note
, &tid
);
8494 case BFD_QNT_CORE_GREG
:
8495 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
8496 case BFD_QNT_CORE_FPREG
:
8497 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
8504 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8510 /* Use note name as section name. */
8512 name
= (char *) bfd_alloc (abfd
, len
);
8515 memcpy (name
, note
->namedata
, len
);
8516 name
[len
- 1] = '\0';
8518 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8522 sect
->size
= note
->descsz
;
8523 sect
->filepos
= note
->descpos
;
8524 sect
->alignment_power
= 1;
8529 /* Function: elfcore_write_note
8532 buffer to hold note, and current size of buffer
8536 size of data for note
8538 Writes note to end of buffer. ELF64 notes are written exactly as
8539 for ELF32, despite the current (as of 2006) ELF gabi specifying
8540 that they ought to have 8-byte namesz and descsz field, and have
8541 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8544 Pointer to realloc'd buffer, *BUFSIZ updated. */
8547 elfcore_write_note (bfd
*abfd
,
8555 Elf_External_Note
*xnp
;
8562 namesz
= strlen (name
) + 1;
8564 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8566 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
8569 dest
= buf
+ *bufsiz
;
8570 *bufsiz
+= newspace
;
8571 xnp
= (Elf_External_Note
*) dest
;
8572 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8573 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8574 H_PUT_32 (abfd
, type
, xnp
->type
);
8578 memcpy (dest
, name
, namesz
);
8586 memcpy (dest
, input
, size
);
8596 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8598 elfcore_write_prpsinfo (bfd
*abfd
,
8604 const char *note_name
= "CORE";
8605 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8607 if (bed
->elf_backend_write_core_note
!= NULL
)
8610 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8611 NT_PRPSINFO
, fname
, psargs
);
8616 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8617 if (bed
->s
->elfclass
== ELFCLASS32
)
8619 #if defined (HAVE_PSINFO32_T)
8621 int note_type
= NT_PSINFO
;
8624 int note_type
= NT_PRPSINFO
;
8627 memset (&data
, 0, sizeof (data
));
8628 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8629 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8630 return elfcore_write_note (abfd
, buf
, bufsiz
,
8631 note_name
, note_type
, &data
, sizeof (data
));
8636 #if defined (HAVE_PSINFO_T)
8638 int note_type
= NT_PSINFO
;
8641 int note_type
= NT_PRPSINFO
;
8644 memset (&data
, 0, sizeof (data
));
8645 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8646 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8647 return elfcore_write_note (abfd
, buf
, bufsiz
,
8648 note_name
, note_type
, &data
, sizeof (data
));
8651 #endif /* PSINFO_T or PRPSINFO_T */
8653 #if defined (HAVE_PRSTATUS_T)
8655 elfcore_write_prstatus (bfd
*abfd
,
8662 const char *note_name
= "CORE";
8663 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8665 if (bed
->elf_backend_write_core_note
!= NULL
)
8668 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8670 pid
, cursig
, gregs
);
8675 #if defined (HAVE_PRSTATUS32_T)
8676 if (bed
->s
->elfclass
== ELFCLASS32
)
8678 prstatus32_t prstat
;
8680 memset (&prstat
, 0, sizeof (prstat
));
8681 prstat
.pr_pid
= pid
;
8682 prstat
.pr_cursig
= cursig
;
8683 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8684 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8685 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8692 memset (&prstat
, 0, sizeof (prstat
));
8693 prstat
.pr_pid
= pid
;
8694 prstat
.pr_cursig
= cursig
;
8695 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8696 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8697 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8700 #endif /* HAVE_PRSTATUS_T */
8702 #if defined (HAVE_LWPSTATUS_T)
8704 elfcore_write_lwpstatus (bfd
*abfd
,
8711 lwpstatus_t lwpstat
;
8712 const char *note_name
= "CORE";
8714 memset (&lwpstat
, 0, sizeof (lwpstat
));
8715 lwpstat
.pr_lwpid
= pid
>> 16;
8716 lwpstat
.pr_cursig
= cursig
;
8717 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8718 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8719 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8721 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8722 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8724 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8725 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8728 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8729 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8731 #endif /* HAVE_LWPSTATUS_T */
8733 #if defined (HAVE_PSTATUS_T)
8735 elfcore_write_pstatus (bfd
*abfd
,
8739 int cursig ATTRIBUTE_UNUSED
,
8740 const void *gregs ATTRIBUTE_UNUSED
)
8742 const char *note_name
= "CORE";
8743 #if defined (HAVE_PSTATUS32_T)
8744 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8746 if (bed
->s
->elfclass
== ELFCLASS32
)
8750 memset (&pstat
, 0, sizeof (pstat
));
8751 pstat
.pr_pid
= pid
& 0xffff;
8752 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8753 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8761 memset (&pstat
, 0, sizeof (pstat
));
8762 pstat
.pr_pid
= pid
& 0xffff;
8763 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8764 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8768 #endif /* HAVE_PSTATUS_T */
8771 elfcore_write_prfpreg (bfd
*abfd
,
8777 const char *note_name
= "CORE";
8778 return elfcore_write_note (abfd
, buf
, bufsiz
,
8779 note_name
, NT_FPREGSET
, fpregs
, size
);
8783 elfcore_write_prxfpreg (bfd
*abfd
,
8786 const void *xfpregs
,
8789 char *note_name
= "LINUX";
8790 return elfcore_write_note (abfd
, buf
, bufsiz
,
8791 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8795 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
8796 const void *xfpregs
, int size
)
8798 char *note_name
= "LINUX";
8799 return elfcore_write_note (abfd
, buf
, bufsiz
,
8800 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
8804 elfcore_write_ppc_vmx (bfd
*abfd
,
8807 const void *ppc_vmx
,
8810 char *note_name
= "LINUX";
8811 return elfcore_write_note (abfd
, buf
, bufsiz
,
8812 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
8816 elfcore_write_ppc_vsx (bfd
*abfd
,
8819 const void *ppc_vsx
,
8822 char *note_name
= "LINUX";
8823 return elfcore_write_note (abfd
, buf
, bufsiz
,
8824 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
8828 elfcore_write_s390_high_gprs (bfd
*abfd
,
8831 const void *s390_high_gprs
,
8834 char *note_name
= "LINUX";
8835 return elfcore_write_note (abfd
, buf
, bufsiz
,
8836 note_name
, NT_S390_HIGH_GPRS
,
8837 s390_high_gprs
, size
);
8841 elfcore_write_s390_timer (bfd
*abfd
,
8844 const void *s390_timer
,
8847 char *note_name
= "LINUX";
8848 return elfcore_write_note (abfd
, buf
, bufsiz
,
8849 note_name
, NT_S390_TIMER
, s390_timer
, size
);
8853 elfcore_write_s390_todcmp (bfd
*abfd
,
8856 const void *s390_todcmp
,
8859 char *note_name
= "LINUX";
8860 return elfcore_write_note (abfd
, buf
, bufsiz
,
8861 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
8865 elfcore_write_s390_todpreg (bfd
*abfd
,
8868 const void *s390_todpreg
,
8871 char *note_name
= "LINUX";
8872 return elfcore_write_note (abfd
, buf
, bufsiz
,
8873 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
8877 elfcore_write_s390_ctrs (bfd
*abfd
,
8880 const void *s390_ctrs
,
8883 char *note_name
= "LINUX";
8884 return elfcore_write_note (abfd
, buf
, bufsiz
,
8885 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
8889 elfcore_write_s390_prefix (bfd
*abfd
,
8892 const void *s390_prefix
,
8895 char *note_name
= "LINUX";
8896 return elfcore_write_note (abfd
, buf
, bufsiz
,
8897 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
8901 elfcore_write_register_note (bfd
*abfd
,
8904 const char *section
,
8908 if (strcmp (section
, ".reg2") == 0)
8909 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
8910 if (strcmp (section
, ".reg-xfp") == 0)
8911 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
8912 if (strcmp (section
, ".reg-xstate") == 0)
8913 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
8914 if (strcmp (section
, ".reg-ppc-vmx") == 0)
8915 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
8916 if (strcmp (section
, ".reg-ppc-vsx") == 0)
8917 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
8918 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
8919 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
8920 if (strcmp (section
, ".reg-s390-timer") == 0)
8921 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
8922 if (strcmp (section
, ".reg-s390-todcmp") == 0)
8923 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
8924 if (strcmp (section
, ".reg-s390-todpreg") == 0)
8925 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
8926 if (strcmp (section
, ".reg-s390-ctrs") == 0)
8927 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
8928 if (strcmp (section
, ".reg-s390-prefix") == 0)
8929 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
8934 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
8939 while (p
< buf
+ size
)
8941 /* FIXME: bad alignment assumption. */
8942 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
8943 Elf_Internal_Note in
;
8945 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
8948 in
.type
= H_GET_32 (abfd
, xnp
->type
);
8950 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
8951 in
.namedata
= xnp
->name
;
8952 if (in
.namesz
> buf
- in
.namedata
+ size
)
8955 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
8956 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
8957 in
.descpos
= offset
+ (in
.descdata
- buf
);
8959 && (in
.descdata
>= buf
+ size
8960 || in
.descsz
> buf
- in
.descdata
+ size
))
8963 switch (bfd_get_format (abfd
))
8969 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
8971 if (! elfcore_grok_netbsd_note (abfd
, &in
))
8974 else if (CONST_STRNEQ (in
.namedata
, "OpenBSD"))
8976 if (! elfcore_grok_openbsd_note (abfd
, &in
))
8979 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
8981 if (! elfcore_grok_nto_note (abfd
, &in
))
8984 else if (CONST_STRNEQ (in
.namedata
, "SPU/"))
8986 if (! elfcore_grok_spu_note (abfd
, &in
))
8991 if (! elfcore_grok_note (abfd
, &in
))
8997 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
8999 if (! elfobj_grok_gnu_note (abfd
, &in
))
9005 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
9012 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
9019 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
9022 buf
= (char *) bfd_malloc (size
);
9026 if (bfd_bread (buf
, size
, abfd
) != size
9027 || !elf_parse_notes (abfd
, buf
, size
, offset
))
9037 /* Providing external access to the ELF program header table. */
9039 /* Return an upper bound on the number of bytes required to store a
9040 copy of ABFD's program header table entries. Return -1 if an error
9041 occurs; bfd_get_error will return an appropriate code. */
9044 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
9046 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9048 bfd_set_error (bfd_error_wrong_format
);
9052 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
9055 /* Copy ABFD's program header table entries to *PHDRS. The entries
9056 will be stored as an array of Elf_Internal_Phdr structures, as
9057 defined in include/elf/internal.h. To find out how large the
9058 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9060 Return the number of program header table entries read, or -1 if an
9061 error occurs; bfd_get_error will return an appropriate code. */
9064 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
9068 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9070 bfd_set_error (bfd_error_wrong_format
);
9074 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
9075 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
9076 num_phdrs
* sizeof (Elf_Internal_Phdr
));
9081 enum elf_reloc_type_class
9082 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
9084 return reloc_class_normal
;
9087 /* For RELA architectures, return the relocation value for a
9088 relocation against a local symbol. */
9091 _bfd_elf_rela_local_sym (bfd
*abfd
,
9092 Elf_Internal_Sym
*sym
,
9094 Elf_Internal_Rela
*rel
)
9096 asection
*sec
= *psec
;
9099 relocation
= (sec
->output_section
->vma
9100 + sec
->output_offset
9102 if ((sec
->flags
& SEC_MERGE
)
9103 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
9104 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
9107 _bfd_merged_section_offset (abfd
, psec
,
9108 elf_section_data (sec
)->sec_info
,
9109 sym
->st_value
+ rel
->r_addend
);
9112 /* If we have changed the section, and our original section is
9113 marked with SEC_EXCLUDE, it means that the original
9114 SEC_MERGE section has been completely subsumed in some
9115 other SEC_MERGE section. In this case, we need to leave
9116 some info around for --emit-relocs. */
9117 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
9118 sec
->kept_section
= *psec
;
9121 rel
->r_addend
-= relocation
;
9122 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
9128 _bfd_elf_rel_local_sym (bfd
*abfd
,
9129 Elf_Internal_Sym
*sym
,
9133 asection
*sec
= *psec
;
9135 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
9136 return sym
->st_value
+ addend
;
9138 return _bfd_merged_section_offset (abfd
, psec
,
9139 elf_section_data (sec
)->sec_info
,
9140 sym
->st_value
+ addend
);
9144 _bfd_elf_section_offset (bfd
*abfd
,
9145 struct bfd_link_info
*info
,
9149 switch (sec
->sec_info_type
)
9151 case ELF_INFO_TYPE_STABS
:
9152 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
9154 case ELF_INFO_TYPE_EH_FRAME
:
9155 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
9161 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
9162 reconstruct an ELF file by reading the segments out of remote memory
9163 based on the ELF file header at EHDR_VMA and the ELF program headers it
9164 points to. If not null, *LOADBASEP is filled in with the difference
9165 between the VMAs from which the segments were read, and the VMAs the
9166 file headers (and hence BFD's idea of each section's VMA) put them at.
9168 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9169 remote memory at target address VMA into the local buffer at MYADDR; it
9170 should return zero on success or an `errno' code on failure. TEMPL must
9171 be a BFD for an ELF target with the word size and byte order found in
9172 the remote memory. */
9175 bfd_elf_bfd_from_remote_memory
9179 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
9181 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
9182 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
9186 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
9187 long symcount ATTRIBUTE_UNUSED
,
9188 asymbol
**syms ATTRIBUTE_UNUSED
,
9193 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9196 const char *relplt_name
;
9197 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
9201 Elf_Internal_Shdr
*hdr
;
9207 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
9210 if (dynsymcount
<= 0)
9213 if (!bed
->plt_sym_val
)
9216 relplt_name
= bed
->relplt_name
;
9217 if (relplt_name
== NULL
)
9218 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
9219 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
9223 hdr
= &elf_section_data (relplt
)->this_hdr
;
9224 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
9225 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
9228 plt
= bfd_get_section_by_name (abfd
, ".plt");
9232 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
9233 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
9236 count
= relplt
->size
/ hdr
->sh_entsize
;
9237 size
= count
* sizeof (asymbol
);
9238 p
= relplt
->relocation
;
9239 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
9241 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
9245 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
9247 size
+= sizeof ("+0x") - 1 + 8;
9252 s
= *ret
= (asymbol
*) bfd_malloc (size
);
9256 names
= (char *) (s
+ count
);
9257 p
= relplt
->relocation
;
9259 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
9264 addr
= bed
->plt_sym_val (i
, plt
, p
);
9265 if (addr
== (bfd_vma
) -1)
9268 *s
= **p
->sym_ptr_ptr
;
9269 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
9270 we are defining a symbol, ensure one of them is set. */
9271 if ((s
->flags
& BSF_LOCAL
) == 0)
9272 s
->flags
|= BSF_GLOBAL
;
9273 s
->flags
|= BSF_SYNTHETIC
;
9275 s
->value
= addr
- plt
->vma
;
9278 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
9279 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
9285 memcpy (names
, "+0x", sizeof ("+0x") - 1);
9286 names
+= sizeof ("+0x") - 1;
9287 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
9288 for (a
= buf
; *a
== '0'; ++a
)
9291 memcpy (names
, a
, len
);
9294 memcpy (names
, "@plt", sizeof ("@plt"));
9295 names
+= sizeof ("@plt");
9302 /* It is only used by x86-64 so far. */
9303 asection _bfd_elf_large_com_section
9304 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
9305 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
9308 _bfd_elf_set_osabi (bfd
* abfd
,
9309 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
9311 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
9313 i_ehdrp
= elf_elfheader (abfd
);
9315 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
9317 /* To make things simpler for the loader on Linux systems we set the
9318 osabi field to ELFOSABI_LINUX if the binary contains symbols of
9319 the STT_GNU_IFUNC type. */
9320 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
9321 && elf_tdata (abfd
)->has_ifunc_symbols
)
9322 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_LINUX
;
9326 /* Return TRUE for ELF symbol types that represent functions.
9327 This is the default version of this function, which is sufficient for
9328 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
9331 _bfd_elf_is_function_type (unsigned int type
)
9333 return (type
== STT_FUNC
9334 || type
== STT_GNU_IFUNC
);