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_object (bfd
*abfd
)
255 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
256 return bfd_elf_allocate_object (abfd
, sizeof (struct elf_obj_tdata
),
261 bfd_elf_mkcorefile (bfd
*abfd
)
263 /* I think this can be done just like an object file. */
264 return abfd
->xvec
->_bfd_set_format
[(int) bfd_object
] (abfd
);
268 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
270 Elf_Internal_Shdr
**i_shdrp
;
271 bfd_byte
*shstrtab
= NULL
;
273 bfd_size_type shstrtabsize
;
275 i_shdrp
= elf_elfsections (abfd
);
277 || shindex
>= elf_numsections (abfd
)
278 || i_shdrp
[shindex
] == 0)
281 shstrtab
= i_shdrp
[shindex
]->contents
;
282 if (shstrtab
== NULL
)
284 /* No cached one, attempt to read, and cache what we read. */
285 offset
= i_shdrp
[shindex
]->sh_offset
;
286 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
288 /* Allocate and clear an extra byte at the end, to prevent crashes
289 in case the string table is not terminated. */
290 if (shstrtabsize
+ 1 <= 1
291 || (shstrtab
= (bfd_byte
*) bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
292 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
294 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
296 if (bfd_get_error () != bfd_error_system_call
)
297 bfd_set_error (bfd_error_file_truncated
);
299 /* Once we've failed to read it, make sure we don't keep
300 trying. Otherwise, we'll keep allocating space for
301 the string table over and over. */
302 i_shdrp
[shindex
]->sh_size
= 0;
305 shstrtab
[shstrtabsize
] = '\0';
306 i_shdrp
[shindex
]->contents
= shstrtab
;
308 return (char *) shstrtab
;
312 bfd_elf_string_from_elf_section (bfd
*abfd
,
313 unsigned int shindex
,
314 unsigned int strindex
)
316 Elf_Internal_Shdr
*hdr
;
321 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
324 hdr
= elf_elfsections (abfd
)[shindex
];
326 if (hdr
->contents
== NULL
327 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
330 if (strindex
>= hdr
->sh_size
)
332 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
333 (*_bfd_error_handler
)
334 (_("%B: invalid string offset %u >= %lu for section `%s'"),
335 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
336 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
338 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
342 return ((char *) hdr
->contents
) + strindex
;
345 /* Read and convert symbols to internal format.
346 SYMCOUNT specifies the number of symbols to read, starting from
347 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
348 are non-NULL, they are used to store the internal symbols, external
349 symbols, and symbol section index extensions, respectively.
350 Returns a pointer to the internal symbol buffer (malloced if necessary)
351 or NULL if there were no symbols or some kind of problem. */
354 bfd_elf_get_elf_syms (bfd
*ibfd
,
355 Elf_Internal_Shdr
*symtab_hdr
,
358 Elf_Internal_Sym
*intsym_buf
,
360 Elf_External_Sym_Shndx
*extshndx_buf
)
362 Elf_Internal_Shdr
*shndx_hdr
;
364 const bfd_byte
*esym
;
365 Elf_External_Sym_Shndx
*alloc_extshndx
;
366 Elf_External_Sym_Shndx
*shndx
;
367 Elf_Internal_Sym
*alloc_intsym
;
368 Elf_Internal_Sym
*isym
;
369 Elf_Internal_Sym
*isymend
;
370 const struct elf_backend_data
*bed
;
375 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
381 /* Normal syms might have section extension entries. */
383 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
384 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
386 /* Read the symbols. */
388 alloc_extshndx
= NULL
;
390 bed
= get_elf_backend_data (ibfd
);
391 extsym_size
= bed
->s
->sizeof_sym
;
392 amt
= symcount
* extsym_size
;
393 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
394 if (extsym_buf
== NULL
)
396 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
397 extsym_buf
= alloc_ext
;
399 if (extsym_buf
== NULL
400 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
401 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
407 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
411 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
412 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
413 if (extshndx_buf
== NULL
)
415 alloc_extshndx
= (Elf_External_Sym_Shndx
*)
416 bfd_malloc2 (symcount
, sizeof (Elf_External_Sym_Shndx
));
417 extshndx_buf
= alloc_extshndx
;
419 if (extshndx_buf
== NULL
420 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
421 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
428 if (intsym_buf
== NULL
)
430 alloc_intsym
= (Elf_Internal_Sym
*)
431 bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
432 intsym_buf
= alloc_intsym
;
433 if (intsym_buf
== NULL
)
437 /* Convert the symbols to internal form. */
438 isymend
= intsym_buf
+ symcount
;
439 for (esym
= (const bfd_byte
*) extsym_buf
, isym
= intsym_buf
,
440 shndx
= extshndx_buf
;
442 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
443 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
445 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
446 (*_bfd_error_handler
) (_("%B symbol number %lu references "
447 "nonexistent SHT_SYMTAB_SHNDX section"),
448 ibfd
, (unsigned long) symoffset
);
449 if (alloc_intsym
!= NULL
)
456 if (alloc_ext
!= NULL
)
458 if (alloc_extshndx
!= NULL
)
459 free (alloc_extshndx
);
464 /* Look up a symbol name. */
466 bfd_elf_sym_name (bfd
*abfd
,
467 Elf_Internal_Shdr
*symtab_hdr
,
468 Elf_Internal_Sym
*isym
,
472 unsigned int iname
= isym
->st_name
;
473 unsigned int shindex
= symtab_hdr
->sh_link
;
475 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
476 /* Check for a bogus st_shndx to avoid crashing. */
477 && isym
->st_shndx
< elf_numsections (abfd
))
479 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
480 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
483 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
486 else if (sym_sec
&& *name
== '\0')
487 name
= bfd_section_name (abfd
, sym_sec
);
492 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
493 sections. The first element is the flags, the rest are section
496 typedef union elf_internal_group
{
497 Elf_Internal_Shdr
*shdr
;
499 } Elf_Internal_Group
;
501 /* Return the name of the group signature symbol. Why isn't the
502 signature just a string? */
505 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
507 Elf_Internal_Shdr
*hdr
;
508 unsigned char esym
[sizeof (Elf64_External_Sym
)];
509 Elf_External_Sym_Shndx eshndx
;
510 Elf_Internal_Sym isym
;
512 /* First we need to ensure the symbol table is available. Make sure
513 that it is a symbol table section. */
514 if (ghdr
->sh_link
>= elf_numsections (abfd
))
516 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
517 if (hdr
->sh_type
!= SHT_SYMTAB
518 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
521 /* Go read the symbol. */
522 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
523 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
524 &isym
, esym
, &eshndx
) == NULL
)
527 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
530 /* Set next_in_group list pointer, and group name for NEWSECT. */
533 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
535 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
537 /* If num_group is zero, read in all SHT_GROUP sections. The count
538 is set to -1 if there are no SHT_GROUP sections. */
541 unsigned int i
, shnum
;
543 /* First count the number of groups. If we have a SHT_GROUP
544 section with just a flag word (ie. sh_size is 4), ignore it. */
545 shnum
= elf_numsections (abfd
);
548 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
549 ( (shdr)->sh_type == SHT_GROUP \
550 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
551 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
552 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
554 for (i
= 0; i
< shnum
; i
++)
556 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
558 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
564 num_group
= (unsigned) -1;
565 elf_tdata (abfd
)->num_group
= num_group
;
569 /* We keep a list of elf section headers for group sections,
570 so we can find them quickly. */
573 elf_tdata (abfd
)->num_group
= num_group
;
574 elf_tdata (abfd
)->group_sect_ptr
= (Elf_Internal_Shdr
**)
575 bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
576 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
580 for (i
= 0; i
< shnum
; i
++)
582 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
584 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
587 Elf_Internal_Group
*dest
;
589 /* Add to list of sections. */
590 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
593 /* Read the raw contents. */
594 BFD_ASSERT (sizeof (*dest
) >= 4);
595 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
596 shdr
->contents
= (unsigned char *)
597 bfd_alloc2 (abfd
, shdr
->sh_size
, sizeof (*dest
) / 4);
598 /* PR binutils/4110: Handle corrupt group headers. */
599 if (shdr
->contents
== NULL
)
602 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
603 bfd_set_error (bfd_error_bad_value
);
607 memset (shdr
->contents
, 0, amt
);
609 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
610 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
614 /* Translate raw contents, a flag word followed by an
615 array of elf section indices all in target byte order,
616 to the flag word followed by an array of elf section
618 src
= shdr
->contents
+ shdr
->sh_size
;
619 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
626 idx
= H_GET_32 (abfd
, src
);
627 if (src
== shdr
->contents
)
630 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
631 shdr
->bfd_section
->flags
632 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
637 ((*_bfd_error_handler
)
638 (_("%B: invalid SHT_GROUP entry"), abfd
));
641 dest
->shdr
= elf_elfsections (abfd
)[idx
];
648 if (num_group
!= (unsigned) -1)
652 for (i
= 0; i
< num_group
; i
++)
654 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
655 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
656 unsigned int n_elt
= shdr
->sh_size
/ 4;
658 /* Look through this group's sections to see if current
659 section is a member. */
661 if ((++idx
)->shdr
== hdr
)
665 /* We are a member of this group. Go looking through
666 other members to see if any others are linked via
668 idx
= (Elf_Internal_Group
*) shdr
->contents
;
669 n_elt
= shdr
->sh_size
/ 4;
671 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
672 && elf_next_in_group (s
) != NULL
)
676 /* Snarf the group name from other member, and
677 insert current section in circular list. */
678 elf_group_name (newsect
) = elf_group_name (s
);
679 elf_next_in_group (newsect
) = elf_next_in_group (s
);
680 elf_next_in_group (s
) = newsect
;
686 gname
= group_signature (abfd
, shdr
);
689 elf_group_name (newsect
) = gname
;
691 /* Start a circular list with one element. */
692 elf_next_in_group (newsect
) = newsect
;
695 /* If the group section has been created, point to the
697 if (shdr
->bfd_section
!= NULL
)
698 elf_next_in_group (shdr
->bfd_section
) = newsect
;
706 if (elf_group_name (newsect
) == NULL
)
708 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
715 _bfd_elf_setup_sections (bfd
*abfd
)
718 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
719 bfd_boolean result
= TRUE
;
722 /* Process SHF_LINK_ORDER. */
723 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
725 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
726 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
728 unsigned int elfsec
= this_hdr
->sh_link
;
729 /* FIXME: The old Intel compiler and old strip/objcopy may
730 not set the sh_link or sh_info fields. Hence we could
731 get the situation where elfsec is 0. */
734 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
735 if (bed
->link_order_error_handler
)
736 bed
->link_order_error_handler
737 (_("%B: warning: sh_link not set for section `%A'"),
742 asection
*linksec
= NULL
;
744 if (elfsec
< elf_numsections (abfd
))
746 this_hdr
= elf_elfsections (abfd
)[elfsec
];
747 linksec
= this_hdr
->bfd_section
;
751 Some strip/objcopy may leave an incorrect value in
752 sh_link. We don't want to proceed. */
755 (*_bfd_error_handler
)
756 (_("%B: sh_link [%d] in section `%A' is incorrect"),
757 s
->owner
, s
, elfsec
);
761 elf_linked_to_section (s
) = linksec
;
766 /* Process section groups. */
767 if (num_group
== (unsigned) -1)
770 for (i
= 0; i
< num_group
; i
++)
772 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
773 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
774 unsigned int n_elt
= shdr
->sh_size
/ 4;
777 if ((++idx
)->shdr
->bfd_section
)
778 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
779 else if (idx
->shdr
->sh_type
== SHT_RELA
780 || idx
->shdr
->sh_type
== SHT_REL
)
781 /* We won't include relocation sections in section groups in
782 output object files. We adjust the group section size here
783 so that relocatable link will work correctly when
784 relocation sections are in section group in input object
786 shdr
->bfd_section
->size
-= 4;
789 /* There are some unknown sections in the group. */
790 (*_bfd_error_handler
)
791 (_("%B: unknown [%d] section `%s' in group [%s]"),
793 (unsigned int) idx
->shdr
->sh_type
,
794 bfd_elf_string_from_elf_section (abfd
,
795 (elf_elfheader (abfd
)
798 shdr
->bfd_section
->name
);
806 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
808 return elf_next_in_group (sec
) != NULL
;
811 /* Make a BFD section from an ELF section. We store a pointer to the
812 BFD section in the bfd_section field of the header. */
815 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
816 Elf_Internal_Shdr
*hdr
,
822 const struct elf_backend_data
*bed
;
824 if (hdr
->bfd_section
!= NULL
)
826 BFD_ASSERT (strcmp (name
,
827 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
831 newsect
= bfd_make_section_anyway (abfd
, name
);
835 hdr
->bfd_section
= newsect
;
836 elf_section_data (newsect
)->this_hdr
= *hdr
;
837 elf_section_data (newsect
)->this_idx
= shindex
;
839 /* Always use the real type/flags. */
840 elf_section_type (newsect
) = hdr
->sh_type
;
841 elf_section_flags (newsect
) = hdr
->sh_flags
;
843 newsect
->filepos
= hdr
->sh_offset
;
845 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
846 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
847 || ! bfd_set_section_alignment (abfd
, newsect
,
848 bfd_log2 (hdr
->sh_addralign
)))
851 flags
= SEC_NO_FLAGS
;
852 if (hdr
->sh_type
!= SHT_NOBITS
)
853 flags
|= SEC_HAS_CONTENTS
;
854 if (hdr
->sh_type
== SHT_GROUP
)
855 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
856 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
859 if (hdr
->sh_type
!= SHT_NOBITS
)
862 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
863 flags
|= SEC_READONLY
;
864 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
866 else if ((flags
& SEC_LOAD
) != 0)
868 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
871 newsect
->entsize
= hdr
->sh_entsize
;
872 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
873 flags
|= SEC_STRINGS
;
875 if (hdr
->sh_flags
& SHF_GROUP
)
876 if (!setup_group (abfd
, hdr
, newsect
))
878 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
879 flags
|= SEC_THREAD_LOCAL
;
880 if ((hdr
->sh_flags
& SHF_EXCLUDE
) != 0)
881 flags
|= SEC_EXCLUDE
;
883 if ((flags
& SEC_ALLOC
) == 0)
885 /* The debugging sections appear to be recognized only by name,
886 not any sort of flag. Their SEC_ALLOC bits are cleared. */
891 } debug_sections
[] =
893 { STRING_COMMA_LEN ("debug") }, /* 'd' */
894 { NULL
, 0 }, /* 'e' */
895 { NULL
, 0 }, /* 'f' */
896 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
897 { NULL
, 0 }, /* 'h' */
898 { NULL
, 0 }, /* 'i' */
899 { NULL
, 0 }, /* 'j' */
900 { NULL
, 0 }, /* 'k' */
901 { STRING_COMMA_LEN ("line") }, /* 'l' */
902 { NULL
, 0 }, /* 'm' */
903 { NULL
, 0 }, /* 'n' */
904 { NULL
, 0 }, /* 'o' */
905 { NULL
, 0 }, /* 'p' */
906 { NULL
, 0 }, /* 'q' */
907 { NULL
, 0 }, /* 'r' */
908 { STRING_COMMA_LEN ("stab") }, /* 's' */
909 { NULL
, 0 }, /* 't' */
910 { NULL
, 0 }, /* 'u' */
911 { NULL
, 0 }, /* 'v' */
912 { NULL
, 0 }, /* 'w' */
913 { NULL
, 0 }, /* 'x' */
914 { NULL
, 0 }, /* 'y' */
915 { STRING_COMMA_LEN ("zdebug") } /* 'z' */
920 int i
= name
[1] - 'd';
922 && i
< (int) ARRAY_SIZE (debug_sections
)
923 && debug_sections
[i
].name
!= NULL
924 && strncmp (&name
[1], debug_sections
[i
].name
,
925 debug_sections
[i
].len
) == 0)
926 flags
|= SEC_DEBUGGING
;
930 /* As a GNU extension, if the name begins with .gnu.linkonce, we
931 only link a single copy of the section. This is used to support
932 g++. g++ will emit each template expansion in its own section.
933 The symbols will be defined as weak, so that multiple definitions
934 are permitted. The GNU linker extension is to actually discard
935 all but one of the sections. */
936 if (CONST_STRNEQ (name
, ".gnu.linkonce")
937 && elf_next_in_group (newsect
) == NULL
)
938 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
940 bed
= get_elf_backend_data (abfd
);
941 if (bed
->elf_backend_section_flags
)
942 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
945 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
948 /* We do not parse the PT_NOTE segments as we are interested even in the
949 separate debug info files which may have the segments offsets corrupted.
950 PT_NOTEs from the core files are currently not parsed using BFD. */
951 if (hdr
->sh_type
== SHT_NOTE
)
955 if (!bfd_malloc_and_get_section (abfd
, newsect
, &contents
))
958 elf_parse_notes (abfd
, (char *) contents
, hdr
->sh_size
, -1);
962 if ((flags
& SEC_ALLOC
) != 0)
964 Elf_Internal_Phdr
*phdr
;
965 unsigned int i
, nload
;
967 /* Some ELF linkers produce binaries with all the program header
968 p_paddr fields zero. If we have such a binary with more than
969 one PT_LOAD header, then leave the section lma equal to vma
970 so that we don't create sections with overlapping lma. */
971 phdr
= elf_tdata (abfd
)->phdr
;
972 for (nload
= 0, i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
973 if (phdr
->p_paddr
!= 0)
975 else if (phdr
->p_type
== PT_LOAD
&& phdr
->p_memsz
!= 0)
977 if (i
>= elf_elfheader (abfd
)->e_phnum
&& nload
> 1)
980 phdr
= elf_tdata (abfd
)->phdr
;
981 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
983 if (phdr
->p_type
== PT_LOAD
984 && ELF_SECTION_IN_SEGMENT (hdr
, phdr
))
986 if ((flags
& SEC_LOAD
) == 0)
987 newsect
->lma
= (phdr
->p_paddr
988 + hdr
->sh_addr
- phdr
->p_vaddr
);
990 /* We used to use the same adjustment for SEC_LOAD
991 sections, but that doesn't work if the segment
992 is packed with code from multiple VMAs.
993 Instead we calculate the section LMA based on
994 the segment LMA. It is assumed that the
995 segment will contain sections with contiguous
996 LMAs, even if the VMAs are not. */
997 newsect
->lma
= (phdr
->p_paddr
998 + hdr
->sh_offset
- phdr
->p_offset
);
1000 /* With contiguous segments, we can't tell from file
1001 offsets whether a section with zero size should
1002 be placed at the end of one segment or the
1003 beginning of the next. Decide based on vaddr. */
1004 if (hdr
->sh_addr
>= phdr
->p_vaddr
1005 && (hdr
->sh_addr
+ hdr
->sh_size
1006 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1015 const char *const bfd_elf_section_type_names
[] = {
1016 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1017 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1018 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1021 /* ELF relocs are against symbols. If we are producing relocatable
1022 output, and the reloc is against an external symbol, and nothing
1023 has given us any additional addend, the resulting reloc will also
1024 be against the same symbol. In such a case, we don't want to
1025 change anything about the way the reloc is handled, since it will
1026 all be done at final link time. Rather than put special case code
1027 into bfd_perform_relocation, all the reloc types use this howto
1028 function. It just short circuits the reloc if producing
1029 relocatable output against an external symbol. */
1031 bfd_reloc_status_type
1032 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1033 arelent
*reloc_entry
,
1035 void *data ATTRIBUTE_UNUSED
,
1036 asection
*input_section
,
1038 char **error_message ATTRIBUTE_UNUSED
)
1040 if (output_bfd
!= NULL
1041 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1042 && (! reloc_entry
->howto
->partial_inplace
1043 || reloc_entry
->addend
== 0))
1045 reloc_entry
->address
+= input_section
->output_offset
;
1046 return bfd_reloc_ok
;
1049 return bfd_reloc_continue
;
1052 /* Copy the program header and other data from one object module to
1056 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1058 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1059 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1062 BFD_ASSERT (!elf_flags_init (obfd
)
1063 || (elf_elfheader (obfd
)->e_flags
1064 == elf_elfheader (ibfd
)->e_flags
));
1066 elf_gp (obfd
) = elf_gp (ibfd
);
1067 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1068 elf_flags_init (obfd
) = TRUE
;
1070 /* Copy object attributes. */
1071 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1076 get_segment_type (unsigned int p_type
)
1081 case PT_NULL
: pt
= "NULL"; break;
1082 case PT_LOAD
: pt
= "LOAD"; break;
1083 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1084 case PT_INTERP
: pt
= "INTERP"; break;
1085 case PT_NOTE
: pt
= "NOTE"; break;
1086 case PT_SHLIB
: pt
= "SHLIB"; break;
1087 case PT_PHDR
: pt
= "PHDR"; break;
1088 case PT_TLS
: pt
= "TLS"; break;
1089 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1090 case PT_GNU_STACK
: pt
= "STACK"; break;
1091 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1092 default: pt
= NULL
; break;
1097 /* Print out the program headers. */
1100 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1102 FILE *f
= (FILE *) farg
;
1103 Elf_Internal_Phdr
*p
;
1105 bfd_byte
*dynbuf
= NULL
;
1107 p
= elf_tdata (abfd
)->phdr
;
1112 fprintf (f
, _("\nProgram Header:\n"));
1113 c
= elf_elfheader (abfd
)->e_phnum
;
1114 for (i
= 0; i
< c
; i
++, p
++)
1116 const char *pt
= get_segment_type (p
->p_type
);
1121 sprintf (buf
, "0x%lx", p
->p_type
);
1124 fprintf (f
, "%8s off 0x", pt
);
1125 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1126 fprintf (f
, " vaddr 0x");
1127 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1128 fprintf (f
, " paddr 0x");
1129 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1130 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1131 fprintf (f
, " filesz 0x");
1132 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1133 fprintf (f
, " memsz 0x");
1134 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1135 fprintf (f
, " flags %c%c%c",
1136 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1137 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1138 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1139 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1140 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1145 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1148 unsigned int elfsec
;
1149 unsigned long shlink
;
1150 bfd_byte
*extdyn
, *extdynend
;
1152 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1154 fprintf (f
, _("\nDynamic Section:\n"));
1156 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1159 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1160 if (elfsec
== SHN_BAD
)
1162 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1164 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1165 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1168 extdynend
= extdyn
+ s
->size
;
1169 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1171 Elf_Internal_Dyn dyn
;
1172 const char *name
= "";
1174 bfd_boolean stringp
;
1175 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1177 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1179 if (dyn
.d_tag
== DT_NULL
)
1186 if (bed
->elf_backend_get_target_dtag
)
1187 name
= (*bed
->elf_backend_get_target_dtag
) (dyn
.d_tag
);
1189 if (!strcmp (name
, ""))
1191 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1196 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1197 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1198 case DT_PLTGOT
: name
= "PLTGOT"; break;
1199 case DT_HASH
: name
= "HASH"; break;
1200 case DT_STRTAB
: name
= "STRTAB"; break;
1201 case DT_SYMTAB
: name
= "SYMTAB"; break;
1202 case DT_RELA
: name
= "RELA"; break;
1203 case DT_RELASZ
: name
= "RELASZ"; break;
1204 case DT_RELAENT
: name
= "RELAENT"; break;
1205 case DT_STRSZ
: name
= "STRSZ"; break;
1206 case DT_SYMENT
: name
= "SYMENT"; break;
1207 case DT_INIT
: name
= "INIT"; break;
1208 case DT_FINI
: name
= "FINI"; break;
1209 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1210 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1211 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1212 case DT_REL
: name
= "REL"; break;
1213 case DT_RELSZ
: name
= "RELSZ"; break;
1214 case DT_RELENT
: name
= "RELENT"; break;
1215 case DT_PLTREL
: name
= "PLTREL"; break;
1216 case DT_DEBUG
: name
= "DEBUG"; break;
1217 case DT_TEXTREL
: name
= "TEXTREL"; break;
1218 case DT_JMPREL
: name
= "JMPREL"; break;
1219 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1220 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1221 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1222 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1223 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1224 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1225 case DT_FLAGS
: name
= "FLAGS"; break;
1226 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1227 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1228 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1229 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1230 case DT_MOVEENT
: name
= "MOVEENT"; break;
1231 case DT_MOVESZ
: name
= "MOVESZ"; break;
1232 case DT_FEATURE
: name
= "FEATURE"; break;
1233 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1234 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1235 case DT_SYMINENT
: name
= "SYMINENT"; break;
1236 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1237 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1238 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1239 case DT_PLTPAD
: name
= "PLTPAD"; break;
1240 case DT_MOVETAB
: name
= "MOVETAB"; break;
1241 case DT_SYMINFO
: name
= "SYMINFO"; break;
1242 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1243 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1244 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1245 case DT_VERSYM
: name
= "VERSYM"; break;
1246 case DT_VERDEF
: name
= "VERDEF"; break;
1247 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1248 case DT_VERNEED
: name
= "VERNEED"; break;
1249 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1250 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1251 case DT_USED
: name
= "USED"; break;
1252 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1253 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1256 fprintf (f
, " %-20s ", name
);
1260 bfd_fprintf_vma (abfd
, f
, dyn
.d_un
.d_val
);
1265 unsigned int tagv
= dyn
.d_un
.d_val
;
1267 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1270 fprintf (f
, "%s", string
);
1279 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1280 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1282 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1286 if (elf_dynverdef (abfd
) != 0)
1288 Elf_Internal_Verdef
*t
;
1290 fprintf (f
, _("\nVersion definitions:\n"));
1291 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1293 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1294 t
->vd_flags
, t
->vd_hash
,
1295 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1296 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1298 Elf_Internal_Verdaux
*a
;
1301 for (a
= t
->vd_auxptr
->vda_nextptr
;
1305 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1311 if (elf_dynverref (abfd
) != 0)
1313 Elf_Internal_Verneed
*t
;
1315 fprintf (f
, _("\nVersion References:\n"));
1316 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1318 Elf_Internal_Vernaux
*a
;
1320 fprintf (f
, _(" required from %s:\n"),
1321 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1322 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1323 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1324 a
->vna_flags
, a
->vna_other
,
1325 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1337 /* Display ELF-specific fields of a symbol. */
1340 bfd_elf_print_symbol (bfd
*abfd
,
1343 bfd_print_symbol_type how
)
1345 FILE *file
= (FILE *) filep
;
1348 case bfd_print_symbol_name
:
1349 fprintf (file
, "%s", symbol
->name
);
1351 case bfd_print_symbol_more
:
1352 fprintf (file
, "elf ");
1353 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1354 fprintf (file
, " %lx", (unsigned long) symbol
->flags
);
1356 case bfd_print_symbol_all
:
1358 const char *section_name
;
1359 const char *name
= NULL
;
1360 const struct elf_backend_data
*bed
;
1361 unsigned char st_other
;
1364 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1366 bed
= get_elf_backend_data (abfd
);
1367 if (bed
->elf_backend_print_symbol_all
)
1368 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1372 name
= symbol
->name
;
1373 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1376 fprintf (file
, " %s\t", section_name
);
1377 /* Print the "other" value for a symbol. For common symbols,
1378 we've already printed the size; now print the alignment.
1379 For other symbols, we have no specified alignment, and
1380 we've printed the address; now print the size. */
1381 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1382 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1384 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1385 bfd_fprintf_vma (abfd
, file
, val
);
1387 /* If we have version information, print it. */
1388 if (elf_tdata (abfd
)->dynversym_section
!= 0
1389 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1390 || elf_tdata (abfd
)->dynverref_section
!= 0))
1392 unsigned int vernum
;
1393 const char *version_string
;
1395 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1398 version_string
= "";
1399 else if (vernum
== 1)
1400 version_string
= "Base";
1401 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1403 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1406 Elf_Internal_Verneed
*t
;
1408 version_string
= "";
1409 for (t
= elf_tdata (abfd
)->verref
;
1413 Elf_Internal_Vernaux
*a
;
1415 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1417 if (a
->vna_other
== vernum
)
1419 version_string
= a
->vna_nodename
;
1426 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1427 fprintf (file
, " %-11s", version_string
);
1432 fprintf (file
, " (%s)", version_string
);
1433 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1438 /* If the st_other field is not zero, print it. */
1439 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1444 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1445 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1446 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1448 /* Some other non-defined flags are also present, so print
1450 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1453 fprintf (file
, " %s", name
);
1459 /* Allocate an ELF string table--force the first byte to be zero. */
1461 struct bfd_strtab_hash
*
1462 _bfd_elf_stringtab_init (void)
1464 struct bfd_strtab_hash
*ret
;
1466 ret
= _bfd_stringtab_init ();
1471 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1472 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1473 if (loc
== (bfd_size_type
) -1)
1475 _bfd_stringtab_free (ret
);
1482 /* ELF .o/exec file reading */
1484 /* Create a new bfd section from an ELF section header. */
1487 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1489 Elf_Internal_Shdr
*hdr
;
1490 Elf_Internal_Ehdr
*ehdr
;
1491 const struct elf_backend_data
*bed
;
1494 if (shindex
>= elf_numsections (abfd
))
1497 hdr
= elf_elfsections (abfd
)[shindex
];
1498 ehdr
= elf_elfheader (abfd
);
1499 name
= bfd_elf_string_from_elf_section (abfd
, ehdr
->e_shstrndx
,
1504 bed
= get_elf_backend_data (abfd
);
1505 switch (hdr
->sh_type
)
1508 /* Inactive section. Throw it away. */
1511 case SHT_PROGBITS
: /* Normal section with contents. */
1512 case SHT_NOBITS
: /* .bss section. */
1513 case SHT_HASH
: /* .hash section. */
1514 case SHT_NOTE
: /* .note section. */
1515 case SHT_INIT_ARRAY
: /* .init_array section. */
1516 case SHT_FINI_ARRAY
: /* .fini_array section. */
1517 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1518 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1519 case SHT_GNU_HASH
: /* .gnu.hash section. */
1520 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1522 case SHT_DYNAMIC
: /* Dynamic linking information. */
1523 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1525 if (hdr
->sh_link
> elf_numsections (abfd
))
1527 /* PR 10478: Accept Solaris binaries with a sh_link
1528 field set to SHN_BEFORE or SHN_AFTER. */
1529 switch (bfd_get_arch (abfd
))
1532 case bfd_arch_sparc
:
1533 if (hdr
->sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
1534 || hdr
->sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
1536 /* Otherwise fall through. */
1541 else if (elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1543 else if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1545 Elf_Internal_Shdr
*dynsymhdr
;
1547 /* The shared libraries distributed with hpux11 have a bogus
1548 sh_link field for the ".dynamic" section. Find the
1549 string table for the ".dynsym" section instead. */
1550 if (elf_dynsymtab (abfd
) != 0)
1552 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1553 hdr
->sh_link
= dynsymhdr
->sh_link
;
1557 unsigned int i
, num_sec
;
1559 num_sec
= elf_numsections (abfd
);
1560 for (i
= 1; i
< num_sec
; i
++)
1562 dynsymhdr
= elf_elfsections (abfd
)[i
];
1563 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1565 hdr
->sh_link
= dynsymhdr
->sh_link
;
1573 case SHT_SYMTAB
: /* A symbol table */
1574 if (elf_onesymtab (abfd
) == shindex
)
1577 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1579 if (hdr
->sh_info
* hdr
->sh_entsize
> hdr
->sh_size
)
1581 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1582 elf_onesymtab (abfd
) = shindex
;
1583 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1584 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1585 abfd
->flags
|= HAS_SYMS
;
1587 /* Sometimes a shared object will map in the symbol table. If
1588 SHF_ALLOC is set, and this is a shared object, then we also
1589 treat this section as a BFD section. We can not base the
1590 decision purely on SHF_ALLOC, because that flag is sometimes
1591 set in a relocatable object file, which would confuse the
1593 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1594 && (abfd
->flags
& DYNAMIC
) != 0
1595 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1599 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1600 can't read symbols without that section loaded as well. It
1601 is most likely specified by the next section header. */
1602 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1604 unsigned int i
, num_sec
;
1606 num_sec
= elf_numsections (abfd
);
1607 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1609 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1610 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1611 && hdr2
->sh_link
== shindex
)
1615 for (i
= 1; i
< shindex
; i
++)
1617 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1618 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1619 && hdr2
->sh_link
== shindex
)
1623 return bfd_section_from_shdr (abfd
, i
);
1627 case SHT_DYNSYM
: /* A dynamic symbol table */
1628 if (elf_dynsymtab (abfd
) == shindex
)
1631 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1633 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1634 elf_dynsymtab (abfd
) = shindex
;
1635 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1636 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1637 abfd
->flags
|= HAS_SYMS
;
1639 /* Besides being a symbol table, we also treat this as a regular
1640 section, so that objcopy can handle it. */
1641 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1643 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1644 if (elf_symtab_shndx (abfd
) == shindex
)
1647 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1648 elf_symtab_shndx (abfd
) = shindex
;
1649 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1650 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1653 case SHT_STRTAB
: /* A string table */
1654 if (hdr
->bfd_section
!= NULL
)
1656 if (ehdr
->e_shstrndx
== shindex
)
1658 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1659 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1662 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1665 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1666 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1669 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1672 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1673 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1674 elf_elfsections (abfd
)[shindex
] = hdr
;
1675 /* We also treat this as a regular section, so that objcopy
1677 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1681 /* If the string table isn't one of the above, then treat it as a
1682 regular section. We need to scan all the headers to be sure,
1683 just in case this strtab section appeared before the above. */
1684 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1686 unsigned int i
, num_sec
;
1688 num_sec
= elf_numsections (abfd
);
1689 for (i
= 1; i
< num_sec
; i
++)
1691 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1692 if (hdr2
->sh_link
== shindex
)
1694 /* Prevent endless recursion on broken objects. */
1697 if (! bfd_section_from_shdr (abfd
, i
))
1699 if (elf_onesymtab (abfd
) == i
)
1701 if (elf_dynsymtab (abfd
) == i
)
1702 goto dynsymtab_strtab
;
1706 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1710 /* *These* do a lot of work -- but build no sections! */
1712 asection
*target_sect
;
1713 Elf_Internal_Shdr
*hdr2
, **p_hdr
;
1714 unsigned int num_sec
= elf_numsections (abfd
);
1715 struct bfd_elf_section_data
*esdt
;
1719 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1720 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1723 /* Check for a bogus link to avoid crashing. */
1724 if (hdr
->sh_link
>= num_sec
)
1726 ((*_bfd_error_handler
)
1727 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1728 abfd
, hdr
->sh_link
, name
, shindex
));
1729 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1733 /* For some incomprehensible reason Oracle distributes
1734 libraries for Solaris in which some of the objects have
1735 bogus sh_link fields. It would be nice if we could just
1736 reject them, but, unfortunately, some people need to use
1737 them. We scan through the section headers; if we find only
1738 one suitable symbol table, we clobber the sh_link to point
1739 to it. I hope this doesn't break anything.
1741 Don't do it on executable nor shared library. */
1742 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0
1743 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1744 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1750 for (scan
= 1; scan
< num_sec
; scan
++)
1752 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1753 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1764 hdr
->sh_link
= found
;
1767 /* Get the symbol table. */
1768 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1769 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1770 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1773 /* If this reloc section does not use the main symbol table we
1774 don't treat it as a reloc section. BFD can't adequately
1775 represent such a section, so at least for now, we don't
1776 try. We just present it as a normal section. We also
1777 can't use it as a reloc section if it points to the null
1778 section, an invalid section, another reloc section, or its
1779 sh_link points to the null section. */
1780 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1781 || hdr
->sh_link
== SHN_UNDEF
1782 || hdr
->sh_info
== SHN_UNDEF
1783 || hdr
->sh_info
>= num_sec
1784 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1785 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1786 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1789 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1791 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1792 if (target_sect
== NULL
)
1795 esdt
= elf_section_data (target_sect
);
1796 if (hdr
->sh_type
== SHT_RELA
)
1797 p_hdr
= &esdt
->rela
.hdr
;
1799 p_hdr
= &esdt
->rel
.hdr
;
1801 BFD_ASSERT (*p_hdr
== NULL
);
1802 amt
= sizeof (*hdr2
);
1803 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
1808 elf_elfsections (abfd
)[shindex
] = hdr2
;
1809 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1810 target_sect
->flags
|= SEC_RELOC
;
1811 target_sect
->relocation
= NULL
;
1812 target_sect
->rel_filepos
= hdr
->sh_offset
;
1813 /* In the section to which the relocations apply, mark whether
1814 its relocations are of the REL or RELA variety. */
1815 if (hdr
->sh_size
!= 0)
1817 if (hdr
->sh_type
== SHT_RELA
)
1818 target_sect
->use_rela_p
= 1;
1820 abfd
->flags
|= HAS_RELOC
;
1824 case SHT_GNU_verdef
:
1825 elf_dynverdef (abfd
) = shindex
;
1826 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1827 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1829 case SHT_GNU_versym
:
1830 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
1832 elf_dynversym (abfd
) = shindex
;
1833 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1834 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1836 case SHT_GNU_verneed
:
1837 elf_dynverref (abfd
) = shindex
;
1838 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1839 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1845 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
1847 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1849 if (hdr
->contents
!= NULL
)
1851 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1852 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
1855 if (idx
->flags
& GRP_COMDAT
)
1856 hdr
->bfd_section
->flags
1857 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1859 /* We try to keep the same section order as it comes in. */
1861 while (--n_elt
!= 0)
1865 if (idx
->shdr
!= NULL
1866 && (s
= idx
->shdr
->bfd_section
) != NULL
1867 && elf_next_in_group (s
) != NULL
)
1869 elf_next_in_group (hdr
->bfd_section
) = s
;
1877 /* Possibly an attributes section. */
1878 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
1879 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
1881 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1883 _bfd_elf_parse_attributes (abfd
, hdr
);
1887 /* Check for any processor-specific section types. */
1888 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
1891 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
1893 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1894 /* FIXME: How to properly handle allocated section reserved
1895 for applications? */
1896 (*_bfd_error_handler
)
1897 (_("%B: don't know how to handle allocated, application "
1898 "specific section `%s' [0x%8x]"),
1899 abfd
, name
, hdr
->sh_type
);
1901 /* Allow sections reserved for applications. */
1902 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1905 else if (hdr
->sh_type
>= SHT_LOPROC
1906 && hdr
->sh_type
<= SHT_HIPROC
)
1907 /* FIXME: We should handle this section. */
1908 (*_bfd_error_handler
)
1909 (_("%B: don't know how to handle processor specific section "
1911 abfd
, name
, hdr
->sh_type
);
1912 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
1914 /* Unrecognised OS-specific sections. */
1915 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
1916 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1917 required to correctly process the section and the file should
1918 be rejected with an error message. */
1919 (*_bfd_error_handler
)
1920 (_("%B: don't know how to handle OS specific section "
1922 abfd
, name
, hdr
->sh_type
);
1924 /* Otherwise it should be processed. */
1925 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1928 /* FIXME: We should handle this section. */
1929 (*_bfd_error_handler
)
1930 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1931 abfd
, name
, hdr
->sh_type
);
1939 /* Return the local symbol specified by ABFD, R_SYMNDX. */
1942 bfd_sym_from_r_symndx (struct sym_cache
*cache
,
1944 unsigned long r_symndx
)
1946 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1948 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
1950 Elf_Internal_Shdr
*symtab_hdr
;
1951 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1952 Elf_External_Sym_Shndx eshndx
;
1954 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1955 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1956 &cache
->sym
[ent
], esym
, &eshndx
) == NULL
)
1959 if (cache
->abfd
!= abfd
)
1961 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1964 cache
->indx
[ent
] = r_symndx
;
1967 return &cache
->sym
[ent
];
1970 /* Given an ELF section number, retrieve the corresponding BFD
1974 bfd_section_from_elf_index (bfd
*abfd
, unsigned int sec_index
)
1976 if (sec_index
>= elf_numsections (abfd
))
1978 return elf_elfsections (abfd
)[sec_index
]->bfd_section
;
1981 static const struct bfd_elf_special_section special_sections_b
[] =
1983 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1984 { NULL
, 0, 0, 0, 0 }
1987 static const struct bfd_elf_special_section special_sections_c
[] =
1989 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
1990 { NULL
, 0, 0, 0, 0 }
1993 static const struct bfd_elf_special_section special_sections_d
[] =
1995 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1996 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1997 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
1998 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
1999 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2000 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2001 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2002 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2003 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2004 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2005 { NULL
, 0, 0, 0, 0 }
2008 static const struct bfd_elf_special_section special_sections_f
[] =
2010 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2011 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2012 { NULL
, 0, 0, 0, 0 }
2015 static const struct bfd_elf_special_section special_sections_g
[] =
2017 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2018 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2019 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2020 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2021 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2022 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2023 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2024 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2025 { NULL
, 0, 0, 0, 0 }
2028 static const struct bfd_elf_special_section special_sections_h
[] =
2030 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2031 { NULL
, 0, 0, 0, 0 }
2034 static const struct bfd_elf_special_section special_sections_i
[] =
2036 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2037 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2038 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2039 { NULL
, 0, 0, 0, 0 }
2042 static const struct bfd_elf_special_section special_sections_l
[] =
2044 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2045 { NULL
, 0, 0, 0, 0 }
2048 static const struct bfd_elf_special_section special_sections_n
[] =
2050 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2051 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2052 { NULL
, 0, 0, 0, 0 }
2055 static const struct bfd_elf_special_section special_sections_p
[] =
2057 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2058 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2059 { NULL
, 0, 0, 0, 0 }
2062 static const struct bfd_elf_special_section special_sections_r
[] =
2064 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2065 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2066 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2067 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2068 { NULL
, 0, 0, 0, 0 }
2071 static const struct bfd_elf_special_section special_sections_s
[] =
2073 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2074 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2075 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2076 /* See struct bfd_elf_special_section declaration for the semantics of
2077 this special case where .prefix_length != strlen (.prefix). */
2078 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2079 { NULL
, 0, 0, 0, 0 }
2082 static const struct bfd_elf_special_section special_sections_t
[] =
2084 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2085 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2086 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2087 { NULL
, 0, 0, 0, 0 }
2090 static const struct bfd_elf_special_section special_sections_z
[] =
2092 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS
, 0 },
2093 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS
, 0 },
2094 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS
, 0 },
2095 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS
, 0 },
2096 { NULL
, 0, 0, 0, 0 }
2099 static const struct bfd_elf_special_section
*special_sections
[] =
2101 special_sections_b
, /* 'b' */
2102 special_sections_c
, /* 'c' */
2103 special_sections_d
, /* 'd' */
2105 special_sections_f
, /* 'f' */
2106 special_sections_g
, /* 'g' */
2107 special_sections_h
, /* 'h' */
2108 special_sections_i
, /* 'i' */
2111 special_sections_l
, /* 'l' */
2113 special_sections_n
, /* 'n' */
2115 special_sections_p
, /* 'p' */
2117 special_sections_r
, /* 'r' */
2118 special_sections_s
, /* 's' */
2119 special_sections_t
, /* 't' */
2125 special_sections_z
/* 'z' */
2128 const struct bfd_elf_special_section
*
2129 _bfd_elf_get_special_section (const char *name
,
2130 const struct bfd_elf_special_section
*spec
,
2136 len
= strlen (name
);
2138 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2141 int prefix_len
= spec
[i
].prefix_length
;
2143 if (len
< prefix_len
)
2145 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2148 suffix_len
= spec
[i
].suffix_length
;
2149 if (suffix_len
<= 0)
2151 if (name
[prefix_len
] != 0)
2153 if (suffix_len
== 0)
2155 if (name
[prefix_len
] != '.'
2156 && (suffix_len
== -2
2157 || (rela
&& spec
[i
].type
== SHT_REL
)))
2163 if (len
< prefix_len
+ suffix_len
)
2165 if (memcmp (name
+ len
- suffix_len
,
2166 spec
[i
].prefix
+ prefix_len
,
2176 const struct bfd_elf_special_section
*
2177 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2180 const struct bfd_elf_special_section
*spec
;
2181 const struct elf_backend_data
*bed
;
2183 /* See if this is one of the special sections. */
2184 if (sec
->name
== NULL
)
2187 bed
= get_elf_backend_data (abfd
);
2188 spec
= bed
->special_sections
;
2191 spec
= _bfd_elf_get_special_section (sec
->name
,
2192 bed
->special_sections
,
2198 if (sec
->name
[0] != '.')
2201 i
= sec
->name
[1] - 'b';
2202 if (i
< 0 || i
> 'z' - 'b')
2205 spec
= special_sections
[i
];
2210 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2214 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2216 struct bfd_elf_section_data
*sdata
;
2217 const struct elf_backend_data
*bed
;
2218 const struct bfd_elf_special_section
*ssect
;
2220 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2223 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
,
2227 sec
->used_by_bfd
= sdata
;
2230 /* Indicate whether or not this section should use RELA relocations. */
2231 bed
= get_elf_backend_data (abfd
);
2232 sec
->use_rela_p
= bed
->default_use_rela_p
;
2234 /* When we read a file, we don't need to set ELF section type and
2235 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2236 anyway. We will set ELF section type and flags for all linker
2237 created sections. If user specifies BFD section flags, we will
2238 set ELF section type and flags based on BFD section flags in
2239 elf_fake_sections. */
2240 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2241 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2243 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2246 elf_section_type (sec
) = ssect
->type
;
2247 elf_section_flags (sec
) = ssect
->attr
;
2251 return _bfd_generic_new_section_hook (abfd
, sec
);
2254 /* Create a new bfd section from an ELF program header.
2256 Since program segments have no names, we generate a synthetic name
2257 of the form segment<NUM>, where NUM is generally the index in the
2258 program header table. For segments that are split (see below) we
2259 generate the names segment<NUM>a and segment<NUM>b.
2261 Note that some program segments may have a file size that is different than
2262 (less than) the memory size. All this means is that at execution the
2263 system must allocate the amount of memory specified by the memory size,
2264 but only initialize it with the first "file size" bytes read from the
2265 file. This would occur for example, with program segments consisting
2266 of combined data+bss.
2268 To handle the above situation, this routine generates TWO bfd sections
2269 for the single program segment. The first has the length specified by
2270 the file size of the segment, and the second has the length specified
2271 by the difference between the two sizes. In effect, the segment is split
2272 into its initialized and uninitialized parts.
2277 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2278 Elf_Internal_Phdr
*hdr
,
2280 const char *type_name
)
2288 split
= ((hdr
->p_memsz
> 0)
2289 && (hdr
->p_filesz
> 0)
2290 && (hdr
->p_memsz
> hdr
->p_filesz
));
2292 if (hdr
->p_filesz
> 0)
2294 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "a" : "");
2295 len
= strlen (namebuf
) + 1;
2296 name
= (char *) bfd_alloc (abfd
, len
);
2299 memcpy (name
, namebuf
, len
);
2300 newsect
= bfd_make_section (abfd
, name
);
2301 if (newsect
== NULL
)
2303 newsect
->vma
= hdr
->p_vaddr
;
2304 newsect
->lma
= hdr
->p_paddr
;
2305 newsect
->size
= hdr
->p_filesz
;
2306 newsect
->filepos
= hdr
->p_offset
;
2307 newsect
->flags
|= SEC_HAS_CONTENTS
;
2308 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2309 if (hdr
->p_type
== PT_LOAD
)
2311 newsect
->flags
|= SEC_ALLOC
;
2312 newsect
->flags
|= SEC_LOAD
;
2313 if (hdr
->p_flags
& PF_X
)
2315 /* FIXME: all we known is that it has execute PERMISSION,
2317 newsect
->flags
|= SEC_CODE
;
2320 if (!(hdr
->p_flags
& PF_W
))
2322 newsect
->flags
|= SEC_READONLY
;
2326 if (hdr
->p_memsz
> hdr
->p_filesz
)
2330 sprintf (namebuf
, "%s%d%s", type_name
, hdr_index
, split
? "b" : "");
2331 len
= strlen (namebuf
) + 1;
2332 name
= (char *) bfd_alloc (abfd
, len
);
2335 memcpy (name
, namebuf
, len
);
2336 newsect
= bfd_make_section (abfd
, name
);
2337 if (newsect
== NULL
)
2339 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2340 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2341 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2342 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2343 align
= newsect
->vma
& -newsect
->vma
;
2344 if (align
== 0 || align
> hdr
->p_align
)
2345 align
= hdr
->p_align
;
2346 newsect
->alignment_power
= bfd_log2 (align
);
2347 if (hdr
->p_type
== PT_LOAD
)
2349 /* Hack for gdb. Segments that have not been modified do
2350 not have their contents written to a core file, on the
2351 assumption that a debugger can find the contents in the
2352 executable. We flag this case by setting the fake
2353 section size to zero. Note that "real" bss sections will
2354 always have their contents dumped to the core file. */
2355 if (bfd_get_format (abfd
) == bfd_core
)
2357 newsect
->flags
|= SEC_ALLOC
;
2358 if (hdr
->p_flags
& PF_X
)
2359 newsect
->flags
|= SEC_CODE
;
2361 if (!(hdr
->p_flags
& PF_W
))
2362 newsect
->flags
|= SEC_READONLY
;
2369 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int hdr_index
)
2371 const struct elf_backend_data
*bed
;
2373 switch (hdr
->p_type
)
2376 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "null");
2379 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "load");
2382 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "dynamic");
2385 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "interp");
2388 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "note"))
2390 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2395 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "shlib");
2398 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "phdr");
2400 case PT_GNU_EH_FRAME
:
2401 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
,
2405 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "stack");
2408 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, hdr_index
, "relro");
2411 /* Check for any processor-specific program segment types. */
2412 bed
= get_elf_backend_data (abfd
);
2413 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, hdr_index
, "proc");
2417 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2421 _bfd_elf_single_rel_hdr (asection
*sec
)
2423 if (elf_section_data (sec
)->rel
.hdr
)
2425 BFD_ASSERT (elf_section_data (sec
)->rela
.hdr
== NULL
);
2426 return elf_section_data (sec
)->rel
.hdr
;
2429 return elf_section_data (sec
)->rela
.hdr
;
2432 /* Allocate and initialize a section-header for a new reloc section,
2433 containing relocations against ASECT. It is stored in RELDATA. If
2434 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2438 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2439 struct bfd_elf_section_reloc_data
*reldata
,
2441 bfd_boolean use_rela_p
)
2443 Elf_Internal_Shdr
*rel_hdr
;
2445 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2448 amt
= sizeof (Elf_Internal_Shdr
);
2449 BFD_ASSERT (reldata
->hdr
== NULL
);
2450 rel_hdr
= bfd_zalloc (abfd
, amt
);
2451 reldata
->hdr
= rel_hdr
;
2453 amt
= sizeof ".rela" + strlen (asect
->name
);
2454 name
= (char *) bfd_alloc (abfd
, amt
);
2457 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2459 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2461 if (rel_hdr
->sh_name
== (unsigned int) -1)
2463 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2464 rel_hdr
->sh_entsize
= (use_rela_p
2465 ? bed
->s
->sizeof_rela
2466 : bed
->s
->sizeof_rel
);
2467 rel_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
2468 rel_hdr
->sh_flags
= 0;
2469 rel_hdr
->sh_addr
= 0;
2470 rel_hdr
->sh_size
= 0;
2471 rel_hdr
->sh_offset
= 0;
2476 /* Return the default section type based on the passed in section flags. */
2479 bfd_elf_get_default_section_type (flagword flags
)
2481 if ((flags
& SEC_ALLOC
) != 0
2482 && (flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2484 return SHT_PROGBITS
;
2487 struct fake_section_arg
2489 struct bfd_link_info
*link_info
;
2493 /* Set up an ELF internal section header for a section. */
2496 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *fsarg
)
2498 struct fake_section_arg
*arg
= (struct fake_section_arg
*)fsarg
;
2499 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2500 struct bfd_elf_section_data
*esd
= elf_section_data (asect
);
2501 Elf_Internal_Shdr
*this_hdr
;
2502 unsigned int sh_type
;
2506 /* We already failed; just get out of the bfd_map_over_sections
2511 this_hdr
= &esd
->this_hdr
;
2513 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2514 asect
->name
, FALSE
);
2515 if (this_hdr
->sh_name
== (unsigned int) -1)
2521 /* Don't clear sh_flags. Assembler may set additional bits. */
2523 if ((asect
->flags
& SEC_ALLOC
) != 0
2524 || asect
->user_set_vma
)
2525 this_hdr
->sh_addr
= asect
->vma
;
2527 this_hdr
->sh_addr
= 0;
2529 this_hdr
->sh_offset
= 0;
2530 this_hdr
->sh_size
= asect
->size
;
2531 this_hdr
->sh_link
= 0;
2532 this_hdr
->sh_addralign
= (bfd_vma
) 1 << asect
->alignment_power
;
2533 /* The sh_entsize and sh_info fields may have been set already by
2534 copy_private_section_data. */
2536 this_hdr
->bfd_section
= asect
;
2537 this_hdr
->contents
= NULL
;
2539 /* If the section type is unspecified, we set it based on
2541 if ((asect
->flags
& SEC_GROUP
) != 0)
2542 sh_type
= SHT_GROUP
;
2544 sh_type
= bfd_elf_get_default_section_type (asect
->flags
);
2546 if (this_hdr
->sh_type
== SHT_NULL
)
2547 this_hdr
->sh_type
= sh_type
;
2548 else if (this_hdr
->sh_type
== SHT_NOBITS
2549 && sh_type
== SHT_PROGBITS
2550 && (asect
->flags
& SEC_ALLOC
) != 0)
2552 /* Warn if we are changing a NOBITS section to PROGBITS, but
2553 allow the link to proceed. This can happen when users link
2554 non-bss input sections to bss output sections, or emit data
2555 to a bss output section via a linker script. */
2556 (*_bfd_error_handler
)
2557 (_("warning: section `%A' type changed to PROGBITS"), asect
);
2558 this_hdr
->sh_type
= sh_type
;
2561 switch (this_hdr
->sh_type
)
2567 case SHT_INIT_ARRAY
:
2568 case SHT_FINI_ARRAY
:
2569 case SHT_PREINIT_ARRAY
:
2576 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2580 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2584 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2588 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2589 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2593 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2594 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2597 case SHT_GNU_versym
:
2598 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2601 case SHT_GNU_verdef
:
2602 this_hdr
->sh_entsize
= 0;
2603 /* objcopy or strip will copy over sh_info, but may not set
2604 cverdefs. The linker will set cverdefs, but sh_info will be
2606 if (this_hdr
->sh_info
== 0)
2607 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2609 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2610 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2613 case SHT_GNU_verneed
:
2614 this_hdr
->sh_entsize
= 0;
2615 /* objcopy or strip will copy over sh_info, but may not set
2616 cverrefs. The linker will set cverrefs, but sh_info will be
2618 if (this_hdr
->sh_info
== 0)
2619 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2621 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2622 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2626 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2630 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2634 if ((asect
->flags
& SEC_ALLOC
) != 0)
2635 this_hdr
->sh_flags
|= SHF_ALLOC
;
2636 if ((asect
->flags
& SEC_READONLY
) == 0)
2637 this_hdr
->sh_flags
|= SHF_WRITE
;
2638 if ((asect
->flags
& SEC_CODE
) != 0)
2639 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2640 if ((asect
->flags
& SEC_MERGE
) != 0)
2642 this_hdr
->sh_flags
|= SHF_MERGE
;
2643 this_hdr
->sh_entsize
= asect
->entsize
;
2644 if ((asect
->flags
& SEC_STRINGS
) != 0)
2645 this_hdr
->sh_flags
|= SHF_STRINGS
;
2647 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2648 this_hdr
->sh_flags
|= SHF_GROUP
;
2649 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2651 this_hdr
->sh_flags
|= SHF_TLS
;
2652 if (asect
->size
== 0
2653 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2655 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2657 this_hdr
->sh_size
= 0;
2660 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2661 if (this_hdr
->sh_size
!= 0)
2662 this_hdr
->sh_type
= SHT_NOBITS
;
2666 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2667 this_hdr
->sh_flags
|= SHF_EXCLUDE
;
2669 /* If the section has relocs, set up a section header for the
2670 SHT_REL[A] section. If two relocation sections are required for
2671 this section, it is up to the processor-specific back-end to
2672 create the other. */
2673 if ((asect
->flags
& SEC_RELOC
) != 0)
2675 /* When doing a relocatable link, create both REL and RELA sections if
2678 /* Do the normal setup if we wouldn't create any sections here. */
2679 && esd
->rel
.count
+ esd
->rela
.count
> 0
2680 && (arg
->link_info
->relocatable
|| arg
->link_info
->emitrelocations
))
2682 if (esd
->rel
.count
&& esd
->rel
.hdr
== NULL
2683 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rel
, asect
, FALSE
))
2688 if (esd
->rela
.count
&& esd
->rela
.hdr
== NULL
2689 && !_bfd_elf_init_reloc_shdr (abfd
, &esd
->rela
, asect
, TRUE
))
2695 else if (!_bfd_elf_init_reloc_shdr (abfd
,
2697 ? &esd
->rela
: &esd
->rel
),
2703 /* Check for processor-specific section types. */
2704 sh_type
= this_hdr
->sh_type
;
2705 if (bed
->elf_backend_fake_sections
2706 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2709 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2711 /* Don't change the header type from NOBITS if we are being
2712 called for objcopy --only-keep-debug. */
2713 this_hdr
->sh_type
= sh_type
;
2717 /* Fill in the contents of a SHT_GROUP section. Called from
2718 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2719 when ELF targets use the generic linker, ld. Called for ld -r
2720 from bfd_elf_final_link. */
2723 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2725 bfd_boolean
*failedptr
= (bfd_boolean
*) failedptrarg
;
2726 asection
*elt
, *first
;
2730 /* Ignore linker created group section. See elfNN_ia64_object_p in
2732 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2736 if (elf_section_data (sec
)->this_hdr
.sh_info
== 0)
2738 unsigned long symindx
= 0;
2740 /* elf_group_id will have been set up by objcopy and the
2742 if (elf_group_id (sec
) != NULL
)
2743 symindx
= elf_group_id (sec
)->udata
.i
;
2747 /* If called from the assembler, swap_out_syms will have set up
2748 elf_section_syms. */
2749 BFD_ASSERT (elf_section_syms (abfd
) != NULL
);
2750 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2752 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2754 else if (elf_section_data (sec
)->this_hdr
.sh_info
== (unsigned int) -2)
2756 /* The ELF backend linker sets sh_info to -2 when the group
2757 signature symbol is global, and thus the index can't be
2758 set until all local symbols are output. */
2759 asection
*igroup
= elf_sec_group (elf_next_in_group (sec
));
2760 struct bfd_elf_section_data
*sec_data
= elf_section_data (igroup
);
2761 unsigned long symndx
= sec_data
->this_hdr
.sh_info
;
2762 unsigned long extsymoff
= 0;
2763 struct elf_link_hash_entry
*h
;
2765 if (!elf_bad_symtab (igroup
->owner
))
2767 Elf_Internal_Shdr
*symtab_hdr
;
2769 symtab_hdr
= &elf_tdata (igroup
->owner
)->symtab_hdr
;
2770 extsymoff
= symtab_hdr
->sh_info
;
2772 h
= elf_sym_hashes (igroup
->owner
)[symndx
- extsymoff
];
2773 while (h
->root
.type
== bfd_link_hash_indirect
2774 || h
->root
.type
== bfd_link_hash_warning
)
2775 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2777 elf_section_data (sec
)->this_hdr
.sh_info
= h
->indx
;
2780 /* The contents won't be allocated for "ld -r" or objcopy. */
2782 if (sec
->contents
== NULL
)
2785 sec
->contents
= (unsigned char *) bfd_alloc (abfd
, sec
->size
);
2787 /* Arrange for the section to be written out. */
2788 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2789 if (sec
->contents
== NULL
)
2796 loc
= sec
->contents
+ sec
->size
;
2798 /* Get the pointer to the first section in the group that gas
2799 squirreled away here. objcopy arranges for this to be set to the
2800 start of the input section group. */
2801 first
= elt
= elf_next_in_group (sec
);
2803 /* First element is a flag word. Rest of section is elf section
2804 indices for all the sections of the group. Write them backwards
2805 just to keep the group in the same order as given in .section
2806 directives, not that it matters. */
2813 s
= s
->output_section
;
2815 && !bfd_is_abs_section (s
))
2817 unsigned int idx
= elf_section_data (s
)->this_idx
;
2820 H_PUT_32 (abfd
, idx
, loc
);
2822 elt
= elf_next_in_group (elt
);
2827 if ((loc
-= 4) != sec
->contents
)
2830 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2833 /* Assign all ELF section numbers. The dummy first section is handled here
2834 too. The link/info pointers for the standard section types are filled
2835 in here too, while we're at it. */
2838 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2840 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2842 unsigned int section_number
, secn
;
2843 Elf_Internal_Shdr
**i_shdrp
;
2844 struct bfd_elf_section_data
*d
;
2845 bfd_boolean need_symtab
;
2849 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2851 /* SHT_GROUP sections are in relocatable files only. */
2852 if (link_info
== NULL
|| link_info
->relocatable
)
2854 /* Put SHT_GROUP sections first. */
2855 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2857 d
= elf_section_data (sec
);
2859 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2861 if (sec
->flags
& SEC_LINKER_CREATED
)
2863 /* Remove the linker created SHT_GROUP sections. */
2864 bfd_section_list_remove (abfd
, sec
);
2865 abfd
->section_count
--;
2868 d
->this_idx
= section_number
++;
2873 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2875 d
= elf_section_data (sec
);
2877 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2878 d
->this_idx
= section_number
++;
2879 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2882 d
->rel
.idx
= section_number
++;
2883 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel
.hdr
->sh_name
);
2890 d
->rela
.idx
= section_number
++;
2891 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rela
.hdr
->sh_name
);
2897 t
->shstrtab_section
= section_number
++;
2898 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2899 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2901 need_symtab
= (bfd_get_symcount (abfd
) > 0
2902 || (link_info
== NULL
2903 && ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
2907 t
->symtab_section
= section_number
++;
2908 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2909 if (section_number
> ((SHN_LORESERVE
- 2) & 0xFFFF))
2911 t
->symtab_shndx_section
= section_number
++;
2912 t
->symtab_shndx_hdr
.sh_name
2913 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2914 ".symtab_shndx", FALSE
);
2915 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2918 t
->strtab_section
= section_number
++;
2919 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2922 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2923 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2925 elf_numsections (abfd
) = section_number
;
2926 elf_elfheader (abfd
)->e_shnum
= section_number
;
2928 /* Set up the list of section header pointers, in agreement with the
2930 i_shdrp
= (Elf_Internal_Shdr
**) bfd_zalloc2 (abfd
, section_number
,
2931 sizeof (Elf_Internal_Shdr
*));
2932 if (i_shdrp
== NULL
)
2935 i_shdrp
[0] = (Elf_Internal_Shdr
*) bfd_zalloc (abfd
,
2936 sizeof (Elf_Internal_Shdr
));
2937 if (i_shdrp
[0] == NULL
)
2939 bfd_release (abfd
, i_shdrp
);
2943 elf_elfsections (abfd
) = i_shdrp
;
2945 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2948 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2949 if (elf_numsections (abfd
) > (SHN_LORESERVE
& 0xFFFF))
2951 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2952 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2954 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2955 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2958 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2963 d
= elf_section_data (sec
);
2965 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2966 if (d
->rel
.idx
!= 0)
2967 i_shdrp
[d
->rel
.idx
] = d
->rel
.hdr
;
2968 if (d
->rela
.idx
!= 0)
2969 i_shdrp
[d
->rela
.idx
] = d
->rela
.hdr
;
2971 /* Fill in the sh_link and sh_info fields while we're at it. */
2973 /* sh_link of a reloc section is the section index of the symbol
2974 table. sh_info is the section index of the section to which
2975 the relocation entries apply. */
2976 if (d
->rel
.idx
!= 0)
2978 d
->rel
.hdr
->sh_link
= t
->symtab_section
;
2979 d
->rel
.hdr
->sh_info
= d
->this_idx
;
2981 if (d
->rela
.idx
!= 0)
2983 d
->rela
.hdr
->sh_link
= t
->symtab_section
;
2984 d
->rela
.hdr
->sh_info
= d
->this_idx
;
2987 /* We need to set up sh_link for SHF_LINK_ORDER. */
2988 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
2990 s
= elf_linked_to_section (sec
);
2993 /* elf_linked_to_section points to the input section. */
2994 if (link_info
!= NULL
)
2996 /* Check discarded linkonce section. */
2997 if (elf_discarded_section (s
))
3000 (*_bfd_error_handler
)
3001 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3002 abfd
, d
->this_hdr
.bfd_section
,
3004 /* Point to the kept section if it has the same
3005 size as the discarded one. */
3006 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3009 bfd_set_error (bfd_error_bad_value
);
3015 s
= s
->output_section
;
3016 BFD_ASSERT (s
!= NULL
);
3020 /* Handle objcopy. */
3021 if (s
->output_section
== NULL
)
3023 (*_bfd_error_handler
)
3024 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3025 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3026 bfd_set_error (bfd_error_bad_value
);
3029 s
= s
->output_section
;
3031 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3036 The Intel C compiler generates SHT_IA_64_UNWIND with
3037 SHF_LINK_ORDER. But it doesn't set the sh_link or
3038 sh_info fields. Hence we could get the situation
3040 const struct elf_backend_data
*bed
3041 = get_elf_backend_data (abfd
);
3042 if (bed
->link_order_error_handler
)
3043 bed
->link_order_error_handler
3044 (_("%B: warning: sh_link not set for section `%A'"),
3049 switch (d
->this_hdr
.sh_type
)
3053 /* A reloc section which we are treating as a normal BFD
3054 section. sh_link is the section index of the symbol
3055 table. sh_info is the section index of the section to
3056 which the relocation entries apply. We assume that an
3057 allocated reloc section uses the dynamic symbol table.
3058 FIXME: How can we be sure? */
3059 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3061 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3063 /* We look up the section the relocs apply to by name. */
3065 if (d
->this_hdr
.sh_type
== SHT_REL
)
3069 s
= bfd_get_section_by_name (abfd
, name
);
3071 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3075 /* We assume that a section named .stab*str is a stabs
3076 string section. We look for a section with the same name
3077 but without the trailing ``str'', and set its sh_link
3078 field to point to this section. */
3079 if (CONST_STRNEQ (sec
->name
, ".stab")
3080 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3085 len
= strlen (sec
->name
);
3086 alc
= (char *) bfd_malloc (len
- 2);
3089 memcpy (alc
, sec
->name
, len
- 3);
3090 alc
[len
- 3] = '\0';
3091 s
= bfd_get_section_by_name (abfd
, alc
);
3095 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3097 /* This is a .stab section. */
3098 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3099 elf_section_data (s
)->this_hdr
.sh_entsize
3100 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3107 case SHT_GNU_verneed
:
3108 case SHT_GNU_verdef
:
3109 /* sh_link is the section header index of the string table
3110 used for the dynamic entries, or the symbol table, or the
3112 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3114 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3117 case SHT_GNU_LIBLIST
:
3118 /* sh_link is the section header index of the prelink library
3119 list used for the dynamic entries, or the symbol table, or
3120 the version strings. */
3121 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3122 ? ".dynstr" : ".gnu.libstr");
3124 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3129 case SHT_GNU_versym
:
3130 /* sh_link is the section header index of the symbol table
3131 this hash table or version table is for. */
3132 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3134 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3138 d
->this_hdr
.sh_link
= t
->symtab_section
;
3142 for (secn
= 1; secn
< section_number
; ++secn
)
3143 if (i_shdrp
[secn
] == NULL
)
3144 i_shdrp
[secn
] = i_shdrp
[0];
3146 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3147 i_shdrp
[secn
]->sh_name
);
3151 /* Map symbol from it's internal number to the external number, moving
3152 all local symbols to be at the head of the list. */
3155 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3157 /* If the backend has a special mapping, use it. */
3158 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3159 if (bed
->elf_backend_sym_is_global
)
3160 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3162 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
| BSF_GNU_UNIQUE
)) != 0
3163 || bfd_is_und_section (bfd_get_section (sym
))
3164 || bfd_is_com_section (bfd_get_section (sym
)));
3167 /* Don't output section symbols for sections that are not going to be
3171 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3173 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3174 && !(sym
->section
->owner
== abfd
3175 || (sym
->section
->output_section
->owner
== abfd
3176 && sym
->section
->output_offset
== 0)));
3180 elf_map_symbols (bfd
*abfd
)
3182 unsigned int symcount
= bfd_get_symcount (abfd
);
3183 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3184 asymbol
**sect_syms
;
3185 unsigned int num_locals
= 0;
3186 unsigned int num_globals
= 0;
3187 unsigned int num_locals2
= 0;
3188 unsigned int num_globals2
= 0;
3195 fprintf (stderr
, "elf_map_symbols\n");
3199 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3201 if (max_index
< asect
->index
)
3202 max_index
= asect
->index
;
3206 sect_syms
= (asymbol
**) bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3207 if (sect_syms
== NULL
)
3209 elf_section_syms (abfd
) = sect_syms
;
3210 elf_num_section_syms (abfd
) = max_index
;
3212 /* Init sect_syms entries for any section symbols we have already
3213 decided to output. */
3214 for (idx
= 0; idx
< symcount
; idx
++)
3216 asymbol
*sym
= syms
[idx
];
3218 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3220 && !ignore_section_sym (abfd
, sym
))
3222 asection
*sec
= sym
->section
;
3224 if (sec
->owner
!= abfd
)
3225 sec
= sec
->output_section
;
3227 sect_syms
[sec
->index
] = syms
[idx
];
3231 /* Classify all of the symbols. */
3232 for (idx
= 0; idx
< symcount
; idx
++)
3234 if (ignore_section_sym (abfd
, syms
[idx
]))
3236 if (!sym_is_global (abfd
, syms
[idx
]))
3242 /* We will be adding a section symbol for each normal BFD section. Most
3243 sections will already have a section symbol in outsymbols, but
3244 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3245 at least in that case. */
3246 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3248 if (sect_syms
[asect
->index
] == NULL
)
3250 if (!sym_is_global (abfd
, asect
->symbol
))
3257 /* Now sort the symbols so the local symbols are first. */
3258 new_syms
= (asymbol
**) bfd_alloc2 (abfd
, num_locals
+ num_globals
,
3259 sizeof (asymbol
*));
3261 if (new_syms
== NULL
)
3264 for (idx
= 0; idx
< symcount
; idx
++)
3266 asymbol
*sym
= syms
[idx
];
3269 if (ignore_section_sym (abfd
, sym
))
3271 if (!sym_is_global (abfd
, sym
))
3274 i
= num_locals
+ num_globals2
++;
3276 sym
->udata
.i
= i
+ 1;
3278 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3280 if (sect_syms
[asect
->index
] == NULL
)
3282 asymbol
*sym
= asect
->symbol
;
3285 sect_syms
[asect
->index
] = sym
;
3286 if (!sym_is_global (abfd
, sym
))
3289 i
= num_locals
+ num_globals2
++;
3291 sym
->udata
.i
= i
+ 1;
3295 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3297 elf_num_locals (abfd
) = num_locals
;
3298 elf_num_globals (abfd
) = num_globals
;
3302 /* Align to the maximum file alignment that could be required for any
3303 ELF data structure. */
3305 static inline file_ptr
3306 align_file_position (file_ptr off
, int align
)
3308 return (off
+ align
- 1) & ~(align
- 1);
3311 /* Assign a file position to a section, optionally aligning to the
3312 required section alignment. */
3315 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3319 if (align
&& i_shdrp
->sh_addralign
> 1)
3320 offset
= BFD_ALIGN (offset
, i_shdrp
->sh_addralign
);
3321 i_shdrp
->sh_offset
= offset
;
3322 if (i_shdrp
->bfd_section
!= NULL
)
3323 i_shdrp
->bfd_section
->filepos
= offset
;
3324 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3325 offset
+= i_shdrp
->sh_size
;
3329 /* Compute the file positions we are going to put the sections at, and
3330 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3331 is not NULL, this is being called by the ELF backend linker. */
3334 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3335 struct bfd_link_info
*link_info
)
3337 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3338 struct fake_section_arg fsargs
;
3340 struct bfd_strtab_hash
*strtab
= NULL
;
3341 Elf_Internal_Shdr
*shstrtab_hdr
;
3342 bfd_boolean need_symtab
;
3344 if (abfd
->output_has_begun
)
3347 /* Do any elf backend specific processing first. */
3348 if (bed
->elf_backend_begin_write_processing
)
3349 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3351 if (! prep_headers (abfd
))
3354 /* Post process the headers if necessary. */
3355 if (bed
->elf_backend_post_process_headers
)
3356 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3358 fsargs
.failed
= FALSE
;
3359 fsargs
.link_info
= link_info
;
3360 bfd_map_over_sections (abfd
, elf_fake_sections
, &fsargs
);
3364 if (!assign_section_numbers (abfd
, link_info
))
3367 /* The backend linker builds symbol table information itself. */
3368 need_symtab
= (link_info
== NULL
3369 && (bfd_get_symcount (abfd
) > 0
3370 || ((abfd
->flags
& (EXEC_P
| DYNAMIC
| HAS_RELOC
))
3374 /* Non-zero if doing a relocatable link. */
3375 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3377 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3382 if (link_info
== NULL
)
3384 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3389 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3390 /* sh_name was set in prep_headers. */
3391 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3392 shstrtab_hdr
->sh_flags
= 0;
3393 shstrtab_hdr
->sh_addr
= 0;
3394 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3395 shstrtab_hdr
->sh_entsize
= 0;
3396 shstrtab_hdr
->sh_link
= 0;
3397 shstrtab_hdr
->sh_info
= 0;
3398 /* sh_offset is set in assign_file_positions_except_relocs. */
3399 shstrtab_hdr
->sh_addralign
= 1;
3401 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3407 Elf_Internal_Shdr
*hdr
;
3409 off
= elf_tdata (abfd
)->next_file_pos
;
3411 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3412 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3414 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3415 if (hdr
->sh_size
!= 0)
3416 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3418 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3419 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3421 elf_tdata (abfd
)->next_file_pos
= off
;
3423 /* Now that we know where the .strtab section goes, write it
3425 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3426 || ! _bfd_stringtab_emit (abfd
, strtab
))
3428 _bfd_stringtab_free (strtab
);
3431 abfd
->output_has_begun
= TRUE
;
3436 /* Make an initial estimate of the size of the program header. If we
3437 get the number wrong here, we'll redo section placement. */
3439 static bfd_size_type
3440 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3444 const struct elf_backend_data
*bed
;
3446 /* Assume we will need exactly two PT_LOAD segments: one for text
3447 and one for data. */
3450 s
= bfd_get_section_by_name (abfd
, ".interp");
3451 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3453 /* If we have a loadable interpreter section, we need a
3454 PT_INTERP segment. In this case, assume we also need a
3455 PT_PHDR segment, although that may not be true for all
3460 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3462 /* We need a PT_DYNAMIC segment. */
3466 if (info
!= NULL
&& info
->relro
)
3468 /* We need a PT_GNU_RELRO segment. */
3472 if (elf_tdata (abfd
)->eh_frame_hdr
)
3474 /* We need a PT_GNU_EH_FRAME segment. */
3478 if (elf_tdata (abfd
)->stack_flags
)
3480 /* We need a PT_GNU_STACK segment. */
3484 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3486 if ((s
->flags
& SEC_LOAD
) != 0
3487 && CONST_STRNEQ (s
->name
, ".note"))
3489 /* We need a PT_NOTE segment. */
3491 /* Try to create just one PT_NOTE segment
3492 for all adjacent loadable .note* sections.
3493 gABI requires that within a PT_NOTE segment
3494 (and also inside of each SHT_NOTE section)
3495 each note is padded to a multiple of 4 size,
3496 so we check whether the sections are correctly
3498 if (s
->alignment_power
== 2)
3499 while (s
->next
!= NULL
3500 && s
->next
->alignment_power
== 2
3501 && (s
->next
->flags
& SEC_LOAD
) != 0
3502 && CONST_STRNEQ (s
->next
->name
, ".note"))
3507 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3509 if (s
->flags
& SEC_THREAD_LOCAL
)
3511 /* We need a PT_TLS segment. */
3517 /* Let the backend count up any program headers it might need. */
3518 bed
= get_elf_backend_data (abfd
);
3519 if (bed
->elf_backend_additional_program_headers
)
3523 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3529 return segs
* bed
->s
->sizeof_phdr
;
3532 /* Find the segment that contains the output_section of section. */
3535 _bfd_elf_find_segment_containing_section (bfd
* abfd
, asection
* section
)
3537 struct elf_segment_map
*m
;
3538 Elf_Internal_Phdr
*p
;
3540 for (m
= elf_tdata (abfd
)->segment_map
,
3541 p
= elf_tdata (abfd
)->phdr
;
3547 for (i
= m
->count
- 1; i
>= 0; i
--)
3548 if (m
->sections
[i
] == section
)
3555 /* Create a mapping from a set of sections to a program segment. */
3557 static struct elf_segment_map
*
3558 make_mapping (bfd
*abfd
,
3559 asection
**sections
,
3564 struct elf_segment_map
*m
;
3569 amt
= sizeof (struct elf_segment_map
);
3570 amt
+= (to
- from
- 1) * sizeof (asection
*);
3571 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3575 m
->p_type
= PT_LOAD
;
3576 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3577 m
->sections
[i
- from
] = *hdrpp
;
3578 m
->count
= to
- from
;
3580 if (from
== 0 && phdr
)
3582 /* Include the headers in the first PT_LOAD segment. */
3583 m
->includes_filehdr
= 1;
3584 m
->includes_phdrs
= 1;
3590 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3593 struct elf_segment_map
*
3594 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3596 struct elf_segment_map
*m
;
3598 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
,
3599 sizeof (struct elf_segment_map
));
3603 m
->p_type
= PT_DYNAMIC
;
3605 m
->sections
[0] = dynsec
;
3610 /* Possibly add or remove segments from the segment map. */
3613 elf_modify_segment_map (bfd
*abfd
,
3614 struct bfd_link_info
*info
,
3615 bfd_boolean remove_empty_load
)
3617 struct elf_segment_map
**m
;
3618 const struct elf_backend_data
*bed
;
3620 /* The placement algorithm assumes that non allocated sections are
3621 not in PT_LOAD segments. We ensure this here by removing such
3622 sections from the segment map. We also remove excluded
3623 sections. Finally, any PT_LOAD segment without sections is
3625 m
= &elf_tdata (abfd
)->segment_map
;
3628 unsigned int i
, new_count
;
3630 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3632 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3633 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3634 || (*m
)->p_type
!= PT_LOAD
))
3636 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3640 (*m
)->count
= new_count
;
3642 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3648 bed
= get_elf_backend_data (abfd
);
3649 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3651 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3658 /* Set up a mapping from BFD sections to program segments. */
3661 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3664 struct elf_segment_map
*m
;
3665 asection
**sections
= NULL
;
3666 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3667 bfd_boolean no_user_phdrs
;
3669 no_user_phdrs
= elf_tdata (abfd
)->segment_map
== NULL
;
3670 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3674 struct elf_segment_map
*mfirst
;
3675 struct elf_segment_map
**pm
;
3678 unsigned int phdr_index
;
3679 bfd_vma maxpagesize
;
3681 bfd_boolean phdr_in_segment
= TRUE
;
3682 bfd_boolean writable
;
3684 asection
*first_tls
= NULL
;
3685 asection
*dynsec
, *eh_frame_hdr
;
3687 bfd_vma addr_mask
, wrap_to
= 0;
3689 /* Select the allocated sections, and sort them. */
3691 sections
= (asection
**) bfd_malloc2 (bfd_count_sections (abfd
),
3692 sizeof (asection
*));
3693 if (sections
== NULL
)
3696 /* Calculate top address, avoiding undefined behaviour of shift
3697 left operator when shift count is equal to size of type
3699 addr_mask
= ((bfd_vma
) 1 << (bfd_arch_bits_per_address (abfd
) - 1)) - 1;
3700 addr_mask
= (addr_mask
<< 1) + 1;
3703 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3705 if ((s
->flags
& SEC_ALLOC
) != 0)
3709 /* A wrapping section potentially clashes with header. */
3710 if (((s
->lma
+ s
->size
) & addr_mask
) < (s
->lma
& addr_mask
))
3711 wrap_to
= (s
->lma
+ s
->size
) & addr_mask
;
3714 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3717 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3719 /* Build the mapping. */
3724 /* If we have a .interp section, then create a PT_PHDR segment for
3725 the program headers and a PT_INTERP segment for the .interp
3727 s
= bfd_get_section_by_name (abfd
, ".interp");
3728 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3730 amt
= sizeof (struct elf_segment_map
);
3731 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3735 m
->p_type
= PT_PHDR
;
3736 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3737 m
->p_flags
= PF_R
| PF_X
;
3738 m
->p_flags_valid
= 1;
3739 m
->includes_phdrs
= 1;
3744 amt
= sizeof (struct elf_segment_map
);
3745 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3749 m
->p_type
= PT_INTERP
;
3757 /* Look through the sections. We put sections in the same program
3758 segment when the start of the second section can be placed within
3759 a few bytes of the end of the first section. */
3763 maxpagesize
= bed
->maxpagesize
;
3765 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3767 && (dynsec
->flags
& SEC_LOAD
) == 0)
3770 /* Deal with -Ttext or something similar such that the first section
3771 is not adjacent to the program headers. This is an
3772 approximation, since at this point we don't know exactly how many
3773 program headers we will need. */
3776 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3778 if (phdr_size
== (bfd_size_type
) -1)
3779 phdr_size
= get_program_header_size (abfd
, info
);
3780 if ((abfd
->flags
& D_PAGED
) == 0
3781 || (sections
[0]->lma
& addr_mask
) < phdr_size
3782 || ((sections
[0]->lma
& addr_mask
) % maxpagesize
3783 < phdr_size
% maxpagesize
)
3784 || (sections
[0]->lma
& addr_mask
& -maxpagesize
) < wrap_to
)
3785 phdr_in_segment
= FALSE
;
3788 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3791 bfd_boolean new_segment
;
3795 /* See if this section and the last one will fit in the same
3798 if (last_hdr
== NULL
)
3800 /* If we don't have a segment yet, then we don't need a new
3801 one (we build the last one after this loop). */
3802 new_segment
= FALSE
;
3804 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3806 /* If this section has a different relation between the
3807 virtual address and the load address, then we need a new
3811 else if (hdr
->lma
< last_hdr
->lma
+ last_size
3812 || last_hdr
->lma
+ last_size
< last_hdr
->lma
)
3814 /* If this section has a load address that makes it overlap
3815 the previous section, then we need a new segment. */
3818 /* In the next test we have to be careful when last_hdr->lma is close
3819 to the end of the address space. If the aligned address wraps
3820 around to the start of the address space, then there are no more
3821 pages left in memory and it is OK to assume that the current
3822 section can be included in the current segment. */
3823 else if ((BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
3825 && (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
) + maxpagesize
3828 /* If putting this section in this segment would force us to
3829 skip a page in the segment, then we need a new segment. */
3832 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3833 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3835 /* We don't want to put a loadable section after a
3836 nonloadable section in the same segment.
3837 Consider .tbss sections as loadable for this purpose. */
3840 else if ((abfd
->flags
& D_PAGED
) == 0)
3842 /* If the file is not demand paged, which means that we
3843 don't require the sections to be correctly aligned in the
3844 file, then there is no other reason for a new segment. */
3845 new_segment
= FALSE
;
3848 && (hdr
->flags
& SEC_READONLY
) == 0
3849 && (((last_hdr
->lma
+ last_size
- 1) & -maxpagesize
)
3850 != (hdr
->lma
& -maxpagesize
)))
3852 /* We don't want to put a writable section in a read only
3853 segment, unless they are on the same page in memory
3854 anyhow. We already know that the last section does not
3855 bring us past the current section on the page, so the
3856 only case in which the new section is not on the same
3857 page as the previous section is when the previous section
3858 ends precisely on a page boundary. */
3863 /* Otherwise, we can use the same segment. */
3864 new_segment
= FALSE
;
3867 /* Allow interested parties a chance to override our decision. */
3868 if (last_hdr
!= NULL
3870 && info
->callbacks
->override_segment_assignment
!= NULL
)
3872 = info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
,
3878 if ((hdr
->flags
& SEC_READONLY
) == 0)
3881 /* .tbss sections effectively have zero size. */
3882 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
3883 != SEC_THREAD_LOCAL
)
3884 last_size
= hdr
->size
;
3890 /* We need a new program segment. We must create a new program
3891 header holding all the sections from phdr_index until hdr. */
3893 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3900 if ((hdr
->flags
& SEC_READONLY
) == 0)
3906 /* .tbss sections effectively have zero size. */
3907 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3908 last_size
= hdr
->size
;
3912 phdr_in_segment
= FALSE
;
3915 /* Create a final PT_LOAD program segment. */
3916 if (last_hdr
!= NULL
)
3918 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3926 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3929 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3936 /* For each batch of consecutive loadable .note sections,
3937 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3938 because if we link together nonloadable .note sections and
3939 loadable .note sections, we will generate two .note sections
3940 in the output file. FIXME: Using names for section types is
3942 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3944 if ((s
->flags
& SEC_LOAD
) != 0
3945 && CONST_STRNEQ (s
->name
, ".note"))
3950 amt
= sizeof (struct elf_segment_map
);
3951 if (s
->alignment_power
== 2)
3952 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
3954 if (s2
->next
->alignment_power
== 2
3955 && (s2
->next
->flags
& SEC_LOAD
) != 0
3956 && CONST_STRNEQ (s2
->next
->name
, ".note")
3957 && align_power (s2
->lma
+ s2
->size
, 2)
3963 amt
+= (count
- 1) * sizeof (asection
*);
3964 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3968 m
->p_type
= PT_NOTE
;
3972 m
->sections
[m
->count
- count
--] = s
;
3973 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3976 m
->sections
[m
->count
- 1] = s
;
3977 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3981 if (s
->flags
& SEC_THREAD_LOCAL
)
3989 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3992 amt
= sizeof (struct elf_segment_map
);
3993 amt
+= (tls_count
- 1) * sizeof (asection
*);
3994 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
3999 m
->count
= tls_count
;
4000 /* Mandated PF_R. */
4002 m
->p_flags_valid
= 1;
4003 for (i
= 0; i
< (unsigned int) tls_count
; ++i
)
4005 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
4006 m
->sections
[i
] = first_tls
;
4007 first_tls
= first_tls
->next
;
4014 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4016 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
4017 if (eh_frame_hdr
!= NULL
4018 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
4020 amt
= sizeof (struct elf_segment_map
);
4021 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4025 m
->p_type
= PT_GNU_EH_FRAME
;
4027 m
->sections
[0] = eh_frame_hdr
->output_section
;
4033 if (elf_tdata (abfd
)->stack_flags
)
4035 amt
= sizeof (struct elf_segment_map
);
4036 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4040 m
->p_type
= PT_GNU_STACK
;
4041 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
4042 m
->p_flags_valid
= 1;
4048 if (info
!= NULL
&& info
->relro
)
4050 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
4052 if (m
->p_type
== PT_LOAD
)
4054 asection
*last
= m
->sections
[m
->count
- 1];
4055 bfd_vma vaddr
= m
->sections
[0]->vma
;
4056 bfd_vma filesz
= last
->vma
- vaddr
+ last
->size
;
4058 if (vaddr
< info
->relro_end
4059 && vaddr
>= info
->relro_start
4060 && (vaddr
+ filesz
) >= info
->relro_end
)
4065 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4068 amt
= sizeof (struct elf_segment_map
);
4069 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, amt
);
4073 m
->p_type
= PT_GNU_RELRO
;
4075 m
->p_flags_valid
= 1;
4083 elf_tdata (abfd
)->segment_map
= mfirst
;
4086 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
4089 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4091 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
4096 if (sections
!= NULL
)
4101 /* Sort sections by address. */
4104 elf_sort_sections (const void *arg1
, const void *arg2
)
4106 const asection
*sec1
= *(const asection
**) arg1
;
4107 const asection
*sec2
= *(const asection
**) arg2
;
4108 bfd_size_type size1
, size2
;
4110 /* Sort by LMA first, since this is the address used to
4111 place the section into a segment. */
4112 if (sec1
->lma
< sec2
->lma
)
4114 else if (sec1
->lma
> sec2
->lma
)
4117 /* Then sort by VMA. Normally the LMA and the VMA will be
4118 the same, and this will do nothing. */
4119 if (sec1
->vma
< sec2
->vma
)
4121 else if (sec1
->vma
> sec2
->vma
)
4124 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4126 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4132 /* If the indicies are the same, do not return 0
4133 here, but continue to try the next comparison. */
4134 if (sec1
->target_index
- sec2
->target_index
!= 0)
4135 return sec1
->target_index
- sec2
->target_index
;
4140 else if (TOEND (sec2
))
4145 /* Sort by size, to put zero sized sections
4146 before others at the same address. */
4148 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4149 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4156 return sec1
->target_index
- sec2
->target_index
;
4159 /* Ian Lance Taylor writes:
4161 We shouldn't be using % with a negative signed number. That's just
4162 not good. We have to make sure either that the number is not
4163 negative, or that the number has an unsigned type. When the types
4164 are all the same size they wind up as unsigned. When file_ptr is a
4165 larger signed type, the arithmetic winds up as signed long long,
4168 What we're trying to say here is something like ``increase OFF by
4169 the least amount that will cause it to be equal to the VMA modulo
4171 /* In other words, something like:
4173 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4174 off_offset = off % bed->maxpagesize;
4175 if (vma_offset < off_offset)
4176 adjustment = vma_offset + bed->maxpagesize - off_offset;
4178 adjustment = vma_offset - off_offset;
4180 which can can be collapsed into the expression below. */
4183 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4185 return ((vma
- off
) % maxpagesize
);
4189 print_segment_map (const struct elf_segment_map
*m
)
4192 const char *pt
= get_segment_type (m
->p_type
);
4197 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4198 sprintf (buf
, "LOPROC+%7.7x",
4199 (unsigned int) (m
->p_type
- PT_LOPROC
));
4200 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4201 sprintf (buf
, "LOOS+%7.7x",
4202 (unsigned int) (m
->p_type
- PT_LOOS
));
4204 snprintf (buf
, sizeof (buf
), "%8.8x",
4205 (unsigned int) m
->p_type
);
4208 fprintf (stderr
, "%s:", pt
);
4209 for (j
= 0; j
< m
->count
; j
++)
4210 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4215 write_zeros (bfd
*abfd
, file_ptr pos
, bfd_size_type len
)
4220 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
4222 buf
= bfd_zmalloc (len
);
4225 ret
= bfd_bwrite (buf
, len
, abfd
) == len
;
4230 /* Assign file positions to the sections based on the mapping from
4231 sections to segments. This function also sets up some fields in
4235 assign_file_positions_for_load_sections (bfd
*abfd
,
4236 struct bfd_link_info
*link_info
)
4238 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4239 struct elf_segment_map
*m
;
4240 Elf_Internal_Phdr
*phdrs
;
4241 Elf_Internal_Phdr
*p
;
4243 bfd_size_type maxpagesize
;
4246 bfd_vma header_pad
= 0;
4248 if (link_info
== NULL
4249 && !_bfd_elf_map_sections_to_segments (abfd
, link_info
))
4253 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4257 header_pad
= m
->header_size
;
4260 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4261 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4262 elf_elfheader (abfd
)->e_phnum
= alloc
;
4264 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4265 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4267 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4268 >= alloc
* bed
->s
->sizeof_phdr
);
4272 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4276 /* We're writing the size in elf_tdata (abfd)->program_header_size,
4277 see assign_file_positions_except_relocs, so make sure we have
4278 that amount allocated, with trailing space cleared.
4279 The variable alloc contains the computed need, while elf_tdata
4280 (abfd)->program_header_size contains the size used for the
4282 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4283 where the layout is forced to according to a larger size in the
4284 last iterations for the testcase ld-elf/header. */
4285 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
% bed
->s
->sizeof_phdr
4287 phdrs
= (Elf_Internal_Phdr
*)
4289 (elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
),
4290 sizeof (Elf_Internal_Phdr
));
4291 elf_tdata (abfd
)->phdr
= phdrs
;
4296 if ((abfd
->flags
& D_PAGED
) != 0)
4297 maxpagesize
= bed
->maxpagesize
;
4299 off
= bed
->s
->sizeof_ehdr
;
4300 off
+= alloc
* bed
->s
->sizeof_phdr
;
4301 if (header_pad
< (bfd_vma
) off
)
4307 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4309 m
= m
->next
, p
++, j
++)
4313 bfd_boolean no_contents
;
4315 /* If elf_segment_map is not from map_sections_to_segments, the
4316 sections may not be correctly ordered. NOTE: sorting should
4317 not be done to the PT_NOTE section of a corefile, which may
4318 contain several pseudo-sections artificially created by bfd.
4319 Sorting these pseudo-sections breaks things badly. */
4321 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4322 && m
->p_type
== PT_NOTE
))
4323 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4326 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4327 number of sections with contents contributing to both p_filesz
4328 and p_memsz, followed by a number of sections with no contents
4329 that just contribute to p_memsz. In this loop, OFF tracks next
4330 available file offset for PT_LOAD and PT_NOTE segments. */
4331 p
->p_type
= m
->p_type
;
4332 p
->p_flags
= m
->p_flags
;
4337 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4339 if (m
->p_paddr_valid
)
4340 p
->p_paddr
= m
->p_paddr
;
4341 else if (m
->count
== 0)
4344 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4346 if (p
->p_type
== PT_LOAD
4347 && (abfd
->flags
& D_PAGED
) != 0)
4349 /* p_align in demand paged PT_LOAD segments effectively stores
4350 the maximum page size. When copying an executable with
4351 objcopy, we set m->p_align from the input file. Use this
4352 value for maxpagesize rather than bed->maxpagesize, which
4353 may be different. Note that we use maxpagesize for PT_TLS
4354 segment alignment later in this function, so we are relying
4355 on at least one PT_LOAD segment appearing before a PT_TLS
4357 if (m
->p_align_valid
)
4358 maxpagesize
= m
->p_align
;
4360 p
->p_align
= maxpagesize
;
4362 else if (m
->p_align_valid
)
4363 p
->p_align
= m
->p_align
;
4364 else if (m
->count
== 0)
4365 p
->p_align
= 1 << bed
->s
->log_file_align
;
4369 no_contents
= FALSE
;
4371 if (p
->p_type
== PT_LOAD
4374 bfd_size_type align
;
4375 unsigned int align_power
= 0;
4377 if (m
->p_align_valid
)
4381 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4383 unsigned int secalign
;
4385 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4386 if (secalign
> align_power
)
4387 align_power
= secalign
;
4389 align
= (bfd_size_type
) 1 << align_power
;
4390 if (align
< maxpagesize
)
4391 align
= maxpagesize
;
4394 for (i
= 0; i
< m
->count
; i
++)
4395 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4396 /* If we aren't making room for this section, then
4397 it must be SHT_NOBITS regardless of what we've
4398 set via struct bfd_elf_special_section. */
4399 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4401 /* Find out whether this segment contains any loadable
4404 for (i
= 0; i
< m
->count
; i
++)
4405 if (elf_section_type (m
->sections
[i
]) != SHT_NOBITS
)
4407 no_contents
= FALSE
;
4411 off_adjust
= vma_page_aligned_bias (p
->p_vaddr
, off
, align
);
4415 /* We shouldn't need to align the segment on disk since
4416 the segment doesn't need file space, but the gABI
4417 arguably requires the alignment and glibc ld.so
4418 checks it. So to comply with the alignment
4419 requirement but not waste file space, we adjust
4420 p_offset for just this segment. (OFF_ADJUST is
4421 subtracted from OFF later.) This may put p_offset
4422 past the end of file, but that shouldn't matter. */
4427 /* Make sure the .dynamic section is the first section in the
4428 PT_DYNAMIC segment. */
4429 else if (p
->p_type
== PT_DYNAMIC
4431 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4434 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4436 bfd_set_error (bfd_error_bad_value
);
4439 /* Set the note section type to SHT_NOTE. */
4440 else if (p
->p_type
== PT_NOTE
)
4441 for (i
= 0; i
< m
->count
; i
++)
4442 elf_section_type (m
->sections
[i
]) = SHT_NOTE
;
4448 if (m
->includes_filehdr
)
4450 if (!m
->p_flags_valid
)
4452 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4453 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4456 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4458 if (p
->p_vaddr
< (bfd_vma
) off
)
4460 (*_bfd_error_handler
)
4461 (_("%B: Not enough room for program headers, try linking with -N"),
4463 bfd_set_error (bfd_error_bad_value
);
4468 if (!m
->p_paddr_valid
)
4473 if (m
->includes_phdrs
)
4475 if (!m
->p_flags_valid
)
4478 if (!m
->includes_filehdr
)
4480 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4484 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4485 p
->p_vaddr
-= off
- p
->p_offset
;
4486 if (!m
->p_paddr_valid
)
4487 p
->p_paddr
-= off
- p
->p_offset
;
4491 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4492 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4495 p
->p_filesz
+= header_pad
;
4496 p
->p_memsz
+= header_pad
;
4500 if (p
->p_type
== PT_LOAD
4501 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4503 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4509 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4511 p
->p_filesz
+= adjust
;
4512 p
->p_memsz
+= adjust
;
4516 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4517 maps. Set filepos for sections in PT_LOAD segments, and in
4518 core files, for sections in PT_NOTE segments.
4519 assign_file_positions_for_non_load_sections will set filepos
4520 for other sections and update p_filesz for other segments. */
4521 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4524 bfd_size_type align
;
4525 Elf_Internal_Shdr
*this_hdr
;
4528 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4529 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4531 if ((p
->p_type
== PT_LOAD
4532 || p
->p_type
== PT_TLS
)
4533 && (this_hdr
->sh_type
!= SHT_NOBITS
4534 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4535 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4536 || p
->p_type
== PT_TLS
))))
4538 bfd_vma p_start
= p
->p_paddr
;
4539 bfd_vma p_end
= p_start
+ p
->p_memsz
;
4540 bfd_vma s_start
= sec
->lma
;
4541 bfd_vma adjust
= s_start
- p_end
;
4545 || p_end
< p_start
))
4547 (*_bfd_error_handler
)
4548 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd
, sec
,
4549 (unsigned long) s_start
, (unsigned long) p_end
);
4553 p
->p_memsz
+= adjust
;
4555 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4557 if (p
->p_filesz
+ adjust
< p
->p_memsz
)
4559 /* We have a PROGBITS section following NOBITS ones.
4560 Allocate file space for the NOBITS section(s) and
4562 adjust
= p
->p_memsz
- p
->p_filesz
;
4563 if (!write_zeros (abfd
, off
, adjust
))
4567 p
->p_filesz
+= adjust
;
4571 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4573 /* The section at i == 0 is the one that actually contains
4577 this_hdr
->sh_offset
= sec
->filepos
= off
;
4578 off
+= this_hdr
->sh_size
;
4579 p
->p_filesz
= this_hdr
->sh_size
;
4585 /* The rest are fake sections that shouldn't be written. */
4594 if (p
->p_type
== PT_LOAD
)
4596 this_hdr
->sh_offset
= sec
->filepos
= off
;
4597 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4598 off
+= this_hdr
->sh_size
;
4601 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4603 p
->p_filesz
+= this_hdr
->sh_size
;
4604 /* A load section without SHF_ALLOC is something like
4605 a note section in a PT_NOTE segment. These take
4606 file space but are not loaded into memory. */
4607 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4608 p
->p_memsz
+= this_hdr
->sh_size
;
4610 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4612 if (p
->p_type
== PT_TLS
)
4613 p
->p_memsz
+= this_hdr
->sh_size
;
4615 /* .tbss is special. It doesn't contribute to p_memsz of
4617 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4618 p
->p_memsz
+= this_hdr
->sh_size
;
4621 if (align
> p
->p_align
4622 && !m
->p_align_valid
4623 && (p
->p_type
!= PT_LOAD
4624 || (abfd
->flags
& D_PAGED
) == 0))
4628 if (!m
->p_flags_valid
)
4631 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4633 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4639 /* Check that all sections are in a PT_LOAD segment.
4640 Don't check funky gdb generated core files. */
4641 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4643 bfd_boolean check_vma
= TRUE
;
4645 for (i
= 1; i
< m
->count
; i
++)
4646 if (m
->sections
[i
]->vma
== m
->sections
[i
- 1]->vma
4647 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
])
4648 ->this_hdr
), p
) != 0
4649 && ELF_SECTION_SIZE (&(elf_section_data (m
->sections
[i
- 1])
4650 ->this_hdr
), p
) != 0)
4652 /* Looks like we have overlays packed into the segment. */
4657 for (i
= 0; i
< m
->count
; i
++)
4659 Elf_Internal_Shdr
*this_hdr
;
4662 sec
= m
->sections
[i
];
4663 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4664 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr
, p
, check_vma
, 0))
4666 (*_bfd_error_handler
)
4667 (_("%B: section `%A' can't be allocated in segment %d"),
4669 print_segment_map (m
);
4675 elf_tdata (abfd
)->next_file_pos
= off
;
4679 /* Assign file positions for the other sections. */
4682 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4683 struct bfd_link_info
*link_info
)
4685 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4686 Elf_Internal_Shdr
**i_shdrpp
;
4687 Elf_Internal_Shdr
**hdrpp
;
4688 Elf_Internal_Phdr
*phdrs
;
4689 Elf_Internal_Phdr
*p
;
4690 struct elf_segment_map
*m
;
4691 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4692 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4694 unsigned int num_sec
;
4698 i_shdrpp
= elf_elfsections (abfd
);
4699 num_sec
= elf_numsections (abfd
);
4700 off
= elf_tdata (abfd
)->next_file_pos
;
4701 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4703 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4704 Elf_Internal_Shdr
*hdr
;
4707 if (hdr
->bfd_section
!= NULL
4708 && (hdr
->bfd_section
->filepos
!= 0
4709 || (hdr
->sh_type
== SHT_NOBITS
4710 && hdr
->contents
== NULL
)))
4711 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4712 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4714 (*_bfd_error_handler
)
4715 (_("%B: warning: allocated section `%s' not in segment"),
4717 (hdr
->bfd_section
== NULL
4719 : hdr
->bfd_section
->name
));
4720 /* We don't need to page align empty sections. */
4721 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4722 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4725 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4727 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4730 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4731 && hdr
->bfd_section
== NULL
)
4732 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4733 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4734 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4735 hdr
->sh_offset
= -1;
4737 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4740 /* Now that we have set the section file positions, we can set up
4741 the file positions for the non PT_LOAD segments. */
4745 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4747 phdrs
= elf_tdata (abfd
)->phdr
;
4748 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4753 if (p
->p_type
!= PT_LOAD
)
4756 if (m
->includes_filehdr
)
4758 filehdr_vaddr
= p
->p_vaddr
;
4759 filehdr_paddr
= p
->p_paddr
;
4761 if (m
->includes_phdrs
)
4763 phdrs_vaddr
= p
->p_vaddr
;
4764 phdrs_paddr
= p
->p_paddr
;
4765 if (m
->includes_filehdr
)
4767 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4768 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4773 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4777 if (p
->p_type
== PT_GNU_RELRO
)
4779 const Elf_Internal_Phdr
*lp
;
4781 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4783 if (link_info
!= NULL
)
4785 /* During linking the range of the RELRO segment is passed
4787 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4789 if (lp
->p_type
== PT_LOAD
4790 && lp
->p_vaddr
>= link_info
->relro_start
4791 && lp
->p_vaddr
< link_info
->relro_end
4792 && lp
->p_vaddr
+ lp
->p_filesz
>= link_info
->relro_end
)
4798 /* Otherwise we are copying an executable or shared
4799 library, but we need to use the same linker logic. */
4800 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4802 if (lp
->p_type
== PT_LOAD
4803 && lp
->p_paddr
== p
->p_paddr
)
4808 if (lp
< phdrs
+ count
)
4810 p
->p_vaddr
= lp
->p_vaddr
;
4811 p
->p_paddr
= lp
->p_paddr
;
4812 p
->p_offset
= lp
->p_offset
;
4813 if (link_info
!= NULL
)
4814 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4815 else if (m
->p_size_valid
)
4816 p
->p_filesz
= m
->p_size
;
4819 p
->p_memsz
= p
->p_filesz
;
4821 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4825 memset (p
, 0, sizeof *p
);
4826 p
->p_type
= PT_NULL
;
4829 else if (m
->count
!= 0)
4831 if (p
->p_type
!= PT_LOAD
4832 && (p
->p_type
!= PT_NOTE
4833 || bfd_get_format (abfd
) != bfd_core
))
4835 Elf_Internal_Shdr
*hdr
;
4838 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4840 sect
= m
->sections
[m
->count
- 1];
4841 hdr
= &elf_section_data (sect
)->this_hdr
;
4842 p
->p_filesz
= sect
->filepos
- m
->sections
[0]->filepos
;
4843 if (hdr
->sh_type
!= SHT_NOBITS
)
4844 p
->p_filesz
+= hdr
->sh_size
;
4845 p
->p_offset
= m
->sections
[0]->filepos
;
4848 else if (m
->includes_filehdr
)
4850 p
->p_vaddr
= filehdr_vaddr
;
4851 if (! m
->p_paddr_valid
)
4852 p
->p_paddr
= filehdr_paddr
;
4854 else if (m
->includes_phdrs
)
4856 p
->p_vaddr
= phdrs_vaddr
;
4857 if (! m
->p_paddr_valid
)
4858 p
->p_paddr
= phdrs_paddr
;
4862 elf_tdata (abfd
)->next_file_pos
= off
;
4867 /* Work out the file positions of all the sections. This is called by
4868 _bfd_elf_compute_section_file_positions. All the section sizes and
4869 VMAs must be known before this is called.
4871 Reloc sections come in two flavours: Those processed specially as
4872 "side-channel" data attached to a section to which they apply, and
4873 those that bfd doesn't process as relocations. The latter sort are
4874 stored in a normal bfd section by bfd_section_from_shdr. We don't
4875 consider the former sort here, unless they form part of the loadable
4876 image. Reloc sections not assigned here will be handled later by
4877 assign_file_positions_for_relocs.
4879 We also don't set the positions of the .symtab and .strtab here. */
4882 assign_file_positions_except_relocs (bfd
*abfd
,
4883 struct bfd_link_info
*link_info
)
4885 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4886 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4888 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4890 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4891 && bfd_get_format (abfd
) != bfd_core
)
4893 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4894 unsigned int num_sec
= elf_numsections (abfd
);
4895 Elf_Internal_Shdr
**hdrpp
;
4898 /* Start after the ELF header. */
4899 off
= i_ehdrp
->e_ehsize
;
4901 /* We are not creating an executable, which means that we are
4902 not creating a program header, and that the actual order of
4903 the sections in the file is unimportant. */
4904 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4906 Elf_Internal_Shdr
*hdr
;
4909 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4910 && hdr
->bfd_section
== NULL
)
4911 || i
== tdata
->symtab_section
4912 || i
== tdata
->symtab_shndx_section
4913 || i
== tdata
->strtab_section
)
4915 hdr
->sh_offset
= -1;
4918 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4925 /* Assign file positions for the loaded sections based on the
4926 assignment of sections to segments. */
4927 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4930 /* And for non-load sections. */
4931 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4934 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4936 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4940 /* Write out the program headers. */
4941 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4942 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4943 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4946 off
= tdata
->next_file_pos
;
4949 /* Place the section headers. */
4950 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4951 i_ehdrp
->e_shoff
= off
;
4952 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4954 tdata
->next_file_pos
= off
;
4960 prep_headers (bfd
*abfd
)
4962 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form. */
4963 struct elf_strtab_hash
*shstrtab
;
4964 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4966 i_ehdrp
= elf_elfheader (abfd
);
4968 shstrtab
= _bfd_elf_strtab_init ();
4969 if (shstrtab
== NULL
)
4972 elf_shstrtab (abfd
) = shstrtab
;
4974 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4975 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4976 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4977 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4979 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4980 i_ehdrp
->e_ident
[EI_DATA
] =
4981 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4982 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4984 if ((abfd
->flags
& DYNAMIC
) != 0)
4985 i_ehdrp
->e_type
= ET_DYN
;
4986 else if ((abfd
->flags
& EXEC_P
) != 0)
4987 i_ehdrp
->e_type
= ET_EXEC
;
4988 else if (bfd_get_format (abfd
) == bfd_core
)
4989 i_ehdrp
->e_type
= ET_CORE
;
4991 i_ehdrp
->e_type
= ET_REL
;
4993 switch (bfd_get_arch (abfd
))
4995 case bfd_arch_unknown
:
4996 i_ehdrp
->e_machine
= EM_NONE
;
4999 /* There used to be a long list of cases here, each one setting
5000 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5001 in the corresponding bfd definition. To avoid duplication,
5002 the switch was removed. Machines that need special handling
5003 can generally do it in elf_backend_final_write_processing(),
5004 unless they need the information earlier than the final write.
5005 Such need can generally be supplied by replacing the tests for
5006 e_machine with the conditions used to determine it. */
5008 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
5011 i_ehdrp
->e_version
= bed
->s
->ev_current
;
5012 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
5014 /* No program header, for now. */
5015 i_ehdrp
->e_phoff
= 0;
5016 i_ehdrp
->e_phentsize
= 0;
5017 i_ehdrp
->e_phnum
= 0;
5019 /* Each bfd section is section header entry. */
5020 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
5021 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
5023 /* If we're building an executable, we'll need a program header table. */
5024 if (abfd
->flags
& EXEC_P
)
5025 /* It all happens later. */
5029 i_ehdrp
->e_phentsize
= 0;
5030 i_ehdrp
->e_phoff
= 0;
5033 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
5034 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
5035 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
5036 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
5037 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
5038 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
5039 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5040 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5041 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
5047 /* Assign file positions for all the reloc sections which are not part
5048 of the loadable file image. */
5051 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
5054 unsigned int i
, num_sec
;
5055 Elf_Internal_Shdr
**shdrpp
;
5057 off
= elf_tdata (abfd
)->next_file_pos
;
5059 num_sec
= elf_numsections (abfd
);
5060 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
5062 Elf_Internal_Shdr
*shdrp
;
5065 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
5066 && shdrp
->sh_offset
== -1)
5067 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
5070 elf_tdata (abfd
)->next_file_pos
= off
;
5074 _bfd_elf_write_object_contents (bfd
*abfd
)
5076 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5077 Elf_Internal_Shdr
**i_shdrp
;
5079 unsigned int count
, num_sec
;
5081 if (! abfd
->output_has_begun
5082 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
5085 i_shdrp
= elf_elfsections (abfd
);
5088 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
5092 _bfd_elf_assign_file_positions_for_relocs (abfd
);
5094 /* After writing the headers, we need to write the sections too... */
5095 num_sec
= elf_numsections (abfd
);
5096 for (count
= 1; count
< num_sec
; count
++)
5098 if (bed
->elf_backend_section_processing
)
5099 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
5100 if (i_shdrp
[count
]->contents
)
5102 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
5104 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
5105 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
5110 /* Write out the section header names. */
5111 if (elf_shstrtab (abfd
) != NULL
5112 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
5113 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
5116 if (bed
->elf_backend_final_write_processing
)
5117 (*bed
->elf_backend_final_write_processing
) (abfd
,
5118 elf_tdata (abfd
)->linker
);
5120 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
5123 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5124 if (elf_tdata (abfd
)->after_write_object_contents
)
5125 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
5131 _bfd_elf_write_corefile_contents (bfd
*abfd
)
5133 /* Hopefully this can be done just like an object file. */
5134 return _bfd_elf_write_object_contents (abfd
);
5137 /* Given a section, search the header to find them. */
5140 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
5142 const struct elf_backend_data
*bed
;
5143 unsigned int sec_index
;
5145 if (elf_section_data (asect
) != NULL
5146 && elf_section_data (asect
)->this_idx
!= 0)
5147 return elf_section_data (asect
)->this_idx
;
5149 if (bfd_is_abs_section (asect
))
5150 sec_index
= SHN_ABS
;
5151 else if (bfd_is_com_section (asect
))
5152 sec_index
= SHN_COMMON
;
5153 else if (bfd_is_und_section (asect
))
5154 sec_index
= SHN_UNDEF
;
5156 sec_index
= SHN_BAD
;
5158 bed
= get_elf_backend_data (abfd
);
5159 if (bed
->elf_backend_section_from_bfd_section
)
5161 int retval
= sec_index
;
5163 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5167 if (sec_index
== SHN_BAD
)
5168 bfd_set_error (bfd_error_nonrepresentable_section
);
5173 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5177 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5179 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5181 flagword flags
= asym_ptr
->flags
;
5183 /* When gas creates relocations against local labels, it creates its
5184 own symbol for the section, but does put the symbol into the
5185 symbol chain, so udata is 0. When the linker is generating
5186 relocatable output, this section symbol may be for one of the
5187 input sections rather than the output section. */
5188 if (asym_ptr
->udata
.i
== 0
5189 && (flags
& BSF_SECTION_SYM
)
5190 && asym_ptr
->section
)
5195 sec
= asym_ptr
->section
;
5196 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5197 sec
= sec
->output_section
;
5198 if (sec
->owner
== abfd
5199 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5200 && elf_section_syms (abfd
)[indx
] != NULL
)
5201 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5204 idx
= asym_ptr
->udata
.i
;
5208 /* This case can occur when using --strip-symbol on a symbol
5209 which is used in a relocation entry. */
5210 (*_bfd_error_handler
)
5211 (_("%B: symbol `%s' required but not present"),
5212 abfd
, bfd_asymbol_name (asym_ptr
));
5213 bfd_set_error (bfd_error_no_symbols
);
5220 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5221 (long) asym_ptr
, asym_ptr
->name
, idx
, (long) flags
);
5229 /* Rewrite program header information. */
5232 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5234 Elf_Internal_Ehdr
*iehdr
;
5235 struct elf_segment_map
*map
;
5236 struct elf_segment_map
*map_first
;
5237 struct elf_segment_map
**pointer_to_map
;
5238 Elf_Internal_Phdr
*segment
;
5241 unsigned int num_segments
;
5242 bfd_boolean phdr_included
= FALSE
;
5243 bfd_boolean p_paddr_valid
;
5244 bfd_vma maxpagesize
;
5245 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5246 unsigned int phdr_adjust_num
= 0;
5247 const struct elf_backend_data
*bed
;
5249 bed
= get_elf_backend_data (ibfd
);
5250 iehdr
= elf_elfheader (ibfd
);
5253 pointer_to_map
= &map_first
;
5255 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5256 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5258 /* Returns the end address of the segment + 1. */
5259 #define SEGMENT_END(segment, start) \
5260 (start + (segment->p_memsz > segment->p_filesz \
5261 ? segment->p_memsz : segment->p_filesz))
5263 #define SECTION_SIZE(section, segment) \
5264 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5265 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5266 ? section->size : 0)
5268 /* Returns TRUE if the given section is contained within
5269 the given segment. VMA addresses are compared. */
5270 #define IS_CONTAINED_BY_VMA(section, segment) \
5271 (section->vma >= segment->p_vaddr \
5272 && (section->vma + SECTION_SIZE (section, segment) \
5273 <= (SEGMENT_END (segment, segment->p_vaddr))))
5275 /* Returns TRUE if the given section is contained within
5276 the given segment. LMA addresses are compared. */
5277 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5278 (section->lma >= base \
5279 && (section->lma + SECTION_SIZE (section, segment) \
5280 <= SEGMENT_END (segment, base)))
5282 /* Handle PT_NOTE segment. */
5283 #define IS_NOTE(p, s) \
5284 (p->p_type == PT_NOTE \
5285 && elf_section_type (s) == SHT_NOTE \
5286 && (bfd_vma) s->filepos >= p->p_offset \
5287 && ((bfd_vma) s->filepos + s->size \
5288 <= p->p_offset + p->p_filesz))
5290 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5292 #define IS_COREFILE_NOTE(p, s) \
5294 && bfd_get_format (ibfd) == bfd_core \
5298 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5299 linker, which generates a PT_INTERP section with p_vaddr and
5300 p_memsz set to 0. */
5301 #define IS_SOLARIS_PT_INTERP(p, s) \
5303 && p->p_paddr == 0 \
5304 && p->p_memsz == 0 \
5305 && p->p_filesz > 0 \
5306 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5308 && (bfd_vma) s->filepos >= p->p_offset \
5309 && ((bfd_vma) s->filepos + s->size \
5310 <= p->p_offset + p->p_filesz))
5312 /* Decide if the given section should be included in the given segment.
5313 A section will be included if:
5314 1. It is within the address space of the segment -- we use the LMA
5315 if that is set for the segment and the VMA otherwise,
5316 2. It is an allocated section or a NOTE section in a PT_NOTE
5318 3. There is an output section associated with it,
5319 4. The section has not already been allocated to a previous segment.
5320 5. PT_GNU_STACK segments do not include any sections.
5321 6. PT_TLS segment includes only SHF_TLS sections.
5322 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5323 8. PT_DYNAMIC should not contain empty sections at the beginning
5324 (with the possible exception of .dynamic). */
5325 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5326 ((((segment->p_paddr \
5327 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5328 : IS_CONTAINED_BY_VMA (section, segment)) \
5329 && (section->flags & SEC_ALLOC) != 0) \
5330 || IS_NOTE (segment, section)) \
5331 && segment->p_type != PT_GNU_STACK \
5332 && (segment->p_type != PT_TLS \
5333 || (section->flags & SEC_THREAD_LOCAL)) \
5334 && (segment->p_type == PT_LOAD \
5335 || segment->p_type == PT_TLS \
5336 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5337 && (segment->p_type != PT_DYNAMIC \
5338 || SECTION_SIZE (section, segment) > 0 \
5339 || (segment->p_paddr \
5340 ? segment->p_paddr != section->lma \
5341 : segment->p_vaddr != section->vma) \
5342 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5344 && !section->segment_mark)
5346 /* If the output section of a section in the input segment is NULL,
5347 it is removed from the corresponding output segment. */
5348 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5349 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5350 && section->output_section != NULL)
5352 /* Returns TRUE iff seg1 starts after the end of seg2. */
5353 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5354 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5356 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5357 their VMA address ranges and their LMA address ranges overlap.
5358 It is possible to have overlapping VMA ranges without overlapping LMA
5359 ranges. RedBoot images for example can have both .data and .bss mapped
5360 to the same VMA range, but with the .data section mapped to a different
5362 #define SEGMENT_OVERLAPS(seg1, seg2) \
5363 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5364 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5365 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5366 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5368 /* Initialise the segment mark field. */
5369 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5370 section
->segment_mark
= FALSE
;
5372 /* The Solaris linker creates program headers in which all the
5373 p_paddr fields are zero. When we try to objcopy or strip such a
5374 file, we get confused. Check for this case, and if we find it
5375 don't set the p_paddr_valid fields. */
5376 p_paddr_valid
= FALSE
;
5377 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5380 if (segment
->p_paddr
!= 0)
5382 p_paddr_valid
= TRUE
;
5386 /* Scan through the segments specified in the program header
5387 of the input BFD. For this first scan we look for overlaps
5388 in the loadable segments. These can be created by weird
5389 parameters to objcopy. Also, fix some solaris weirdness. */
5390 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5395 Elf_Internal_Phdr
*segment2
;
5397 if (segment
->p_type
== PT_INTERP
)
5398 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5399 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5401 /* Mininal change so that the normal section to segment
5402 assignment code will work. */
5403 segment
->p_vaddr
= section
->vma
;
5407 if (segment
->p_type
!= PT_LOAD
)
5409 /* Remove PT_GNU_RELRO segment. */
5410 if (segment
->p_type
== PT_GNU_RELRO
)
5411 segment
->p_type
= PT_NULL
;
5415 /* Determine if this segment overlaps any previous segments. */
5416 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5418 bfd_signed_vma extra_length
;
5420 if (segment2
->p_type
!= PT_LOAD
5421 || !SEGMENT_OVERLAPS (segment
, segment2
))
5424 /* Merge the two segments together. */
5425 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5427 /* Extend SEGMENT2 to include SEGMENT and then delete
5429 extra_length
= (SEGMENT_END (segment
, segment
->p_vaddr
)
5430 - SEGMENT_END (segment2
, segment2
->p_vaddr
));
5432 if (extra_length
> 0)
5434 segment2
->p_memsz
+= extra_length
;
5435 segment2
->p_filesz
+= extra_length
;
5438 segment
->p_type
= PT_NULL
;
5440 /* Since we have deleted P we must restart the outer loop. */
5442 segment
= elf_tdata (ibfd
)->phdr
;
5447 /* Extend SEGMENT to include SEGMENT2 and then delete
5449 extra_length
= (SEGMENT_END (segment2
, segment2
->p_vaddr
)
5450 - SEGMENT_END (segment
, segment
->p_vaddr
));
5452 if (extra_length
> 0)
5454 segment
->p_memsz
+= extra_length
;
5455 segment
->p_filesz
+= extra_length
;
5458 segment2
->p_type
= PT_NULL
;
5463 /* The second scan attempts to assign sections to segments. */
5464 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5468 unsigned int section_count
;
5469 asection
**sections
;
5470 asection
*output_section
;
5472 bfd_vma matching_lma
;
5473 bfd_vma suggested_lma
;
5476 asection
*first_section
;
5477 bfd_boolean first_matching_lma
;
5478 bfd_boolean first_suggested_lma
;
5480 if (segment
->p_type
== PT_NULL
)
5483 first_section
= NULL
;
5484 /* Compute how many sections might be placed into this segment. */
5485 for (section
= ibfd
->sections
, section_count
= 0;
5487 section
= section
->next
)
5489 /* Find the first section in the input segment, which may be
5490 removed from the corresponding output segment. */
5491 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5493 if (first_section
== NULL
)
5494 first_section
= section
;
5495 if (section
->output_section
!= NULL
)
5500 /* Allocate a segment map big enough to contain
5501 all of the sections we have selected. */
5502 amt
= sizeof (struct elf_segment_map
);
5503 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5504 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
5508 /* Initialise the fields of the segment map. Default to
5509 using the physical address of the segment in the input BFD. */
5511 map
->p_type
= segment
->p_type
;
5512 map
->p_flags
= segment
->p_flags
;
5513 map
->p_flags_valid
= 1;
5515 /* If the first section in the input segment is removed, there is
5516 no need to preserve segment physical address in the corresponding
5518 if (!first_section
|| first_section
->output_section
!= NULL
)
5520 map
->p_paddr
= segment
->p_paddr
;
5521 map
->p_paddr_valid
= p_paddr_valid
;
5524 /* Determine if this segment contains the ELF file header
5525 and if it contains the program headers themselves. */
5526 map
->includes_filehdr
= (segment
->p_offset
== 0
5527 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5528 map
->includes_phdrs
= 0;
5530 if (!phdr_included
|| segment
->p_type
!= PT_LOAD
)
5532 map
->includes_phdrs
=
5533 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5534 && (segment
->p_offset
+ segment
->p_filesz
5535 >= ((bfd_vma
) iehdr
->e_phoff
5536 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5538 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5539 phdr_included
= TRUE
;
5542 if (section_count
== 0)
5544 /* Special segments, such as the PT_PHDR segment, may contain
5545 no sections, but ordinary, loadable segments should contain
5546 something. They are allowed by the ELF spec however, so only
5547 a warning is produced. */
5548 if (segment
->p_type
== PT_LOAD
)
5549 (*_bfd_error_handler
) (_("%B: warning: Empty loadable segment"
5550 " detected, is this intentional ?\n"),
5554 *pointer_to_map
= map
;
5555 pointer_to_map
= &map
->next
;
5560 /* Now scan the sections in the input BFD again and attempt
5561 to add their corresponding output sections to the segment map.
5562 The problem here is how to handle an output section which has
5563 been moved (ie had its LMA changed). There are four possibilities:
5565 1. None of the sections have been moved.
5566 In this case we can continue to use the segment LMA from the
5569 2. All of the sections have been moved by the same amount.
5570 In this case we can change the segment's LMA to match the LMA
5571 of the first section.
5573 3. Some of the sections have been moved, others have not.
5574 In this case those sections which have not been moved can be
5575 placed in the current segment which will have to have its size,
5576 and possibly its LMA changed, and a new segment or segments will
5577 have to be created to contain the other sections.
5579 4. The sections have been moved, but not by the same amount.
5580 In this case we can change the segment's LMA to match the LMA
5581 of the first section and we will have to create a new segment
5582 or segments to contain the other sections.
5584 In order to save time, we allocate an array to hold the section
5585 pointers that we are interested in. As these sections get assigned
5586 to a segment, they are removed from this array. */
5588 sections
= (asection
**) bfd_malloc2 (section_count
, sizeof (asection
*));
5589 if (sections
== NULL
)
5592 /* Step One: Scan for segment vs section LMA conflicts.
5593 Also add the sections to the section array allocated above.
5594 Also add the sections to the current segment. In the common
5595 case, where the sections have not been moved, this means that
5596 we have completely filled the segment, and there is nothing
5601 first_matching_lma
= TRUE
;
5602 first_suggested_lma
= TRUE
;
5604 for (section
= ibfd
->sections
;
5606 section
= section
->next
)
5607 if (section
== first_section
)
5610 for (j
= 0; section
!= NULL
; section
= section
->next
)
5612 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5614 output_section
= section
->output_section
;
5616 sections
[j
++] = section
;
5618 /* The Solaris native linker always sets p_paddr to 0.
5619 We try to catch that case here, and set it to the
5620 correct value. Note - some backends require that
5621 p_paddr be left as zero. */
5623 && segment
->p_vaddr
!= 0
5624 && !bed
->want_p_paddr_set_to_zero
5626 && output_section
->lma
!= 0
5627 && output_section
->vma
== (segment
->p_vaddr
5628 + (map
->includes_filehdr
5631 + (map
->includes_phdrs
5633 * iehdr
->e_phentsize
)
5635 map
->p_paddr
= segment
->p_vaddr
;
5637 /* Match up the physical address of the segment with the
5638 LMA address of the output section. */
5639 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5640 || IS_COREFILE_NOTE (segment
, section
)
5641 || (bed
->want_p_paddr_set_to_zero
5642 && IS_CONTAINED_BY_VMA (output_section
, segment
)))
5644 if (first_matching_lma
|| output_section
->lma
< matching_lma
)
5646 matching_lma
= output_section
->lma
;
5647 first_matching_lma
= FALSE
;
5650 /* We assume that if the section fits within the segment
5651 then it does not overlap any other section within that
5653 map
->sections
[isec
++] = output_section
;
5655 else if (first_suggested_lma
)
5657 suggested_lma
= output_section
->lma
;
5658 first_suggested_lma
= FALSE
;
5661 if (j
== section_count
)
5666 BFD_ASSERT (j
== section_count
);
5668 /* Step Two: Adjust the physical address of the current segment,
5670 if (isec
== section_count
)
5672 /* All of the sections fitted within the segment as currently
5673 specified. This is the default case. Add the segment to
5674 the list of built segments and carry on to process the next
5675 program header in the input BFD. */
5676 map
->count
= section_count
;
5677 *pointer_to_map
= map
;
5678 pointer_to_map
= &map
->next
;
5681 && !bed
->want_p_paddr_set_to_zero
5682 && matching_lma
!= map
->p_paddr
5683 && !map
->includes_filehdr
5684 && !map
->includes_phdrs
)
5685 /* There is some padding before the first section in the
5686 segment. So, we must account for that in the output
5688 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5695 if (!first_matching_lma
)
5697 /* At least one section fits inside the current segment.
5698 Keep it, but modify its physical address to match the
5699 LMA of the first section that fitted. */
5700 map
->p_paddr
= matching_lma
;
5704 /* None of the sections fitted inside the current segment.
5705 Change the current segment's physical address to match
5706 the LMA of the first section. */
5707 map
->p_paddr
= suggested_lma
;
5710 /* Offset the segment physical address from the lma
5711 to allow for space taken up by elf headers. */
5712 if (map
->includes_filehdr
)
5714 if (map
->p_paddr
>= iehdr
->e_ehsize
)
5715 map
->p_paddr
-= iehdr
->e_ehsize
;
5718 map
->includes_filehdr
= FALSE
;
5719 map
->includes_phdrs
= FALSE
;
5723 if (map
->includes_phdrs
)
5725 if (map
->p_paddr
>= iehdr
->e_phnum
* iehdr
->e_phentsize
)
5727 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5729 /* iehdr->e_phnum is just an estimate of the number
5730 of program headers that we will need. Make a note
5731 here of the number we used and the segment we chose
5732 to hold these headers, so that we can adjust the
5733 offset when we know the correct value. */
5734 phdr_adjust_num
= iehdr
->e_phnum
;
5735 phdr_adjust_seg
= map
;
5738 map
->includes_phdrs
= FALSE
;
5742 /* Step Three: Loop over the sections again, this time assigning
5743 those that fit to the current segment and removing them from the
5744 sections array; but making sure not to leave large gaps. Once all
5745 possible sections have been assigned to the current segment it is
5746 added to the list of built segments and if sections still remain
5747 to be assigned, a new segment is constructed before repeating
5754 first_suggested_lma
= TRUE
;
5756 /* Fill the current segment with sections that fit. */
5757 for (j
= 0; j
< section_count
; j
++)
5759 section
= sections
[j
];
5761 if (section
== NULL
)
5764 output_section
= section
->output_section
;
5766 BFD_ASSERT (output_section
!= NULL
);
5768 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5769 || IS_COREFILE_NOTE (segment
, section
))
5771 if (map
->count
== 0)
5773 /* If the first section in a segment does not start at
5774 the beginning of the segment, then something is
5776 if (output_section
->lma
5778 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5779 + (map
->includes_phdrs
5780 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5788 prev_sec
= map
->sections
[map
->count
- 1];
5790 /* If the gap between the end of the previous section
5791 and the start of this section is more than
5792 maxpagesize then we need to start a new segment. */
5793 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5795 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5796 || (prev_sec
->lma
+ prev_sec
->size
5797 > output_section
->lma
))
5799 if (first_suggested_lma
)
5801 suggested_lma
= output_section
->lma
;
5802 first_suggested_lma
= FALSE
;
5809 map
->sections
[map
->count
++] = output_section
;
5812 section
->segment_mark
= TRUE
;
5814 else if (first_suggested_lma
)
5816 suggested_lma
= output_section
->lma
;
5817 first_suggested_lma
= FALSE
;
5821 BFD_ASSERT (map
->count
> 0);
5823 /* Add the current segment to the list of built segments. */
5824 *pointer_to_map
= map
;
5825 pointer_to_map
= &map
->next
;
5827 if (isec
< section_count
)
5829 /* We still have not allocated all of the sections to
5830 segments. Create a new segment here, initialise it
5831 and carry on looping. */
5832 amt
= sizeof (struct elf_segment_map
);
5833 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5834 map
= (struct elf_segment_map
*) bfd_alloc (obfd
, amt
);
5841 /* Initialise the fields of the segment map. Set the physical
5842 physical address to the LMA of the first section that has
5843 not yet been assigned. */
5845 map
->p_type
= segment
->p_type
;
5846 map
->p_flags
= segment
->p_flags
;
5847 map
->p_flags_valid
= 1;
5848 map
->p_paddr
= suggested_lma
;
5849 map
->p_paddr_valid
= p_paddr_valid
;
5850 map
->includes_filehdr
= 0;
5851 map
->includes_phdrs
= 0;
5854 while (isec
< section_count
);
5859 elf_tdata (obfd
)->segment_map
= map_first
;
5861 /* If we had to estimate the number of program headers that were
5862 going to be needed, then check our estimate now and adjust
5863 the offset if necessary. */
5864 if (phdr_adjust_seg
!= NULL
)
5868 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5871 if (count
> phdr_adjust_num
)
5872 phdr_adjust_seg
->p_paddr
5873 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5878 #undef IS_CONTAINED_BY_VMA
5879 #undef IS_CONTAINED_BY_LMA
5881 #undef IS_COREFILE_NOTE
5882 #undef IS_SOLARIS_PT_INTERP
5883 #undef IS_SECTION_IN_INPUT_SEGMENT
5884 #undef INCLUDE_SECTION_IN_SEGMENT
5885 #undef SEGMENT_AFTER_SEGMENT
5886 #undef SEGMENT_OVERLAPS
5890 /* Copy ELF program header information. */
5893 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5895 Elf_Internal_Ehdr
*iehdr
;
5896 struct elf_segment_map
*map
;
5897 struct elf_segment_map
*map_first
;
5898 struct elf_segment_map
**pointer_to_map
;
5899 Elf_Internal_Phdr
*segment
;
5901 unsigned int num_segments
;
5902 bfd_boolean phdr_included
= FALSE
;
5903 bfd_boolean p_paddr_valid
;
5905 iehdr
= elf_elfheader (ibfd
);
5908 pointer_to_map
= &map_first
;
5910 /* If all the segment p_paddr fields are zero, don't set
5911 map->p_paddr_valid. */
5912 p_paddr_valid
= FALSE
;
5913 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5914 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5917 if (segment
->p_paddr
!= 0)
5919 p_paddr_valid
= TRUE
;
5923 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5928 unsigned int section_count
;
5930 Elf_Internal_Shdr
*this_hdr
;
5931 asection
*first_section
= NULL
;
5932 asection
*lowest_section
;
5934 /* Compute how many sections are in this segment. */
5935 for (section
= ibfd
->sections
, section_count
= 0;
5937 section
= section
->next
)
5939 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5940 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
5942 if (first_section
== NULL
)
5943 first_section
= section
;
5948 /* Allocate a segment map big enough to contain
5949 all of the sections we have selected. */
5950 amt
= sizeof (struct elf_segment_map
);
5951 if (section_count
!= 0)
5952 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5953 map
= (struct elf_segment_map
*) bfd_zalloc (obfd
, amt
);
5957 /* Initialize the fields of the output segment map with the
5960 map
->p_type
= segment
->p_type
;
5961 map
->p_flags
= segment
->p_flags
;
5962 map
->p_flags_valid
= 1;
5963 map
->p_paddr
= segment
->p_paddr
;
5964 map
->p_paddr_valid
= p_paddr_valid
;
5965 map
->p_align
= segment
->p_align
;
5966 map
->p_align_valid
= 1;
5967 map
->p_vaddr_offset
= 0;
5969 if (map
->p_type
== PT_GNU_RELRO
)
5971 /* The PT_GNU_RELRO segment may contain the first a few
5972 bytes in the .got.plt section even if the whole .got.plt
5973 section isn't in the PT_GNU_RELRO segment. We won't
5974 change the size of the PT_GNU_RELRO segment. */
5975 map
->p_size
= segment
->p_memsz
;
5976 map
->p_size_valid
= 1;
5979 /* Determine if this segment contains the ELF file header
5980 and if it contains the program headers themselves. */
5981 map
->includes_filehdr
= (segment
->p_offset
== 0
5982 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5984 map
->includes_phdrs
= 0;
5985 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5987 map
->includes_phdrs
=
5988 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5989 && (segment
->p_offset
+ segment
->p_filesz
5990 >= ((bfd_vma
) iehdr
->e_phoff
5991 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5993 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5994 phdr_included
= TRUE
;
5997 lowest_section
= first_section
;
5998 if (section_count
!= 0)
6000 unsigned int isec
= 0;
6002 for (section
= first_section
;
6004 section
= section
->next
)
6006 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6007 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6009 map
->sections
[isec
++] = section
->output_section
;
6010 if (section
->lma
< lowest_section
->lma
)
6011 lowest_section
= section
;
6012 if ((section
->flags
& SEC_ALLOC
) != 0)
6016 /* Section lmas are set up from PT_LOAD header
6017 p_paddr in _bfd_elf_make_section_from_shdr.
6018 If this header has a p_paddr that disagrees
6019 with the section lma, flag the p_paddr as
6021 if ((section
->flags
& SEC_LOAD
) != 0)
6022 seg_off
= this_hdr
->sh_offset
- segment
->p_offset
;
6024 seg_off
= this_hdr
->sh_addr
- segment
->p_vaddr
;
6025 if (section
->lma
- segment
->p_paddr
!= seg_off
)
6026 map
->p_paddr_valid
= FALSE
;
6028 if (isec
== section_count
)
6034 if (map
->includes_filehdr
&& lowest_section
!= NULL
)
6035 /* We need to keep the space used by the headers fixed. */
6036 map
->header_size
= lowest_section
->vma
- segment
->p_vaddr
;
6038 if (!map
->includes_phdrs
6039 && !map
->includes_filehdr
6040 && map
->p_paddr_valid
)
6041 /* There is some other padding before the first section. */
6042 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
6043 - segment
->p_paddr
);
6045 map
->count
= section_count
;
6046 *pointer_to_map
= map
;
6047 pointer_to_map
= &map
->next
;
6050 elf_tdata (obfd
)->segment_map
= map_first
;
6054 /* Copy private BFD data. This copies or rewrites ELF program header
6058 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
6060 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6061 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6064 if (elf_tdata (ibfd
)->phdr
== NULL
)
6067 if (ibfd
->xvec
== obfd
->xvec
)
6069 /* Check to see if any sections in the input BFD
6070 covered by ELF program header have changed. */
6071 Elf_Internal_Phdr
*segment
;
6072 asection
*section
, *osec
;
6073 unsigned int i
, num_segments
;
6074 Elf_Internal_Shdr
*this_hdr
;
6075 const struct elf_backend_data
*bed
;
6077 bed
= get_elf_backend_data (ibfd
);
6079 /* Regenerate the segment map if p_paddr is set to 0. */
6080 if (bed
->want_p_paddr_set_to_zero
)
6083 /* Initialize the segment mark field. */
6084 for (section
= obfd
->sections
; section
!= NULL
;
6085 section
= section
->next
)
6086 section
->segment_mark
= FALSE
;
6088 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
6089 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
6093 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6094 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6095 which severly confuses things, so always regenerate the segment
6096 map in this case. */
6097 if (segment
->p_paddr
== 0
6098 && segment
->p_memsz
== 0
6099 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
6102 for (section
= ibfd
->sections
;
6103 section
!= NULL
; section
= section
->next
)
6105 /* We mark the output section so that we know it comes
6106 from the input BFD. */
6107 osec
= section
->output_section
;
6109 osec
->segment_mark
= TRUE
;
6111 /* Check if this section is covered by the segment. */
6112 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6113 if (ELF_SECTION_IN_SEGMENT (this_hdr
, segment
))
6115 /* FIXME: Check if its output section is changed or
6116 removed. What else do we need to check? */
6118 || section
->flags
!= osec
->flags
6119 || section
->lma
!= osec
->lma
6120 || section
->vma
!= osec
->vma
6121 || section
->size
!= osec
->size
6122 || section
->rawsize
!= osec
->rawsize
6123 || section
->alignment_power
!= osec
->alignment_power
)
6129 /* Check to see if any output section do not come from the
6131 for (section
= obfd
->sections
; section
!= NULL
;
6132 section
= section
->next
)
6134 if (section
->segment_mark
== FALSE
)
6137 section
->segment_mark
= FALSE
;
6140 return copy_elf_program_header (ibfd
, obfd
);
6144 return rewrite_elf_program_header (ibfd
, obfd
);
6147 /* Initialize private output section information from input section. */
6150 _bfd_elf_init_private_section_data (bfd
*ibfd
,
6154 struct bfd_link_info
*link_info
)
6157 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6158 bfd_boolean final_link
= link_info
!= NULL
&& !link_info
->relocatable
;
6160 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6161 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6164 /* For objcopy and relocatable link, don't copy the output ELF
6165 section type from input if the output BFD section flags have been
6166 set to something different. For a final link allow some flags
6167 that the linker clears to differ. */
6168 if (elf_section_type (osec
) == SHT_NULL
6169 && (osec
->flags
== isec
->flags
6171 && ((osec
->flags
^ isec
->flags
)
6172 & ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
)) == 0)))
6173 elf_section_type (osec
) = elf_section_type (isec
);
6175 /* FIXME: Is this correct for all OS/PROC specific flags? */
6176 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6177 & (SHF_MASKOS
| SHF_MASKPROC
));
6179 /* Set things up for objcopy and relocatable link. The output
6180 SHT_GROUP section will have its elf_next_in_group pointing back
6181 to the input group members. Ignore linker created group section.
6182 See elfNN_ia64_object_p in elfxx-ia64.c. */
6185 if (elf_sec_group (isec
) == NULL
6186 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
6188 if (elf_section_flags (isec
) & SHF_GROUP
)
6189 elf_section_flags (osec
) |= SHF_GROUP
;
6190 elf_next_in_group (osec
) = elf_next_in_group (isec
);
6191 elf_section_data (osec
)->group
= elf_section_data (isec
)->group
;
6195 ihdr
= &elf_section_data (isec
)->this_hdr
;
6197 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6198 don't use the output section of the linked-to section since it
6199 may be NULL at this point. */
6200 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
6202 ohdr
= &elf_section_data (osec
)->this_hdr
;
6203 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
6204 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6207 osec
->use_rela_p
= isec
->use_rela_p
;
6212 /* Copy private section information. This copies over the entsize
6213 field, and sometimes the info field. */
6216 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6221 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6223 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6224 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6227 ihdr
= &elf_section_data (isec
)->this_hdr
;
6228 ohdr
= &elf_section_data (osec
)->this_hdr
;
6230 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6232 if (ihdr
->sh_type
== SHT_SYMTAB
6233 || ihdr
->sh_type
== SHT_DYNSYM
6234 || ihdr
->sh_type
== SHT_GNU_verneed
6235 || ihdr
->sh_type
== SHT_GNU_verdef
)
6236 ohdr
->sh_info
= ihdr
->sh_info
;
6238 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6242 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6243 necessary if we are removing either the SHT_GROUP section or any of
6244 the group member sections. DISCARDED is the value that a section's
6245 output_section has if the section will be discarded, NULL when this
6246 function is called from objcopy, bfd_abs_section_ptr when called
6250 _bfd_elf_fixup_group_sections (bfd
*ibfd
, asection
*discarded
)
6254 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6255 if (elf_section_type (isec
) == SHT_GROUP
)
6257 asection
*first
= elf_next_in_group (isec
);
6258 asection
*s
= first
;
6259 bfd_size_type removed
= 0;
6263 /* If this member section is being output but the
6264 SHT_GROUP section is not, then clear the group info
6265 set up by _bfd_elf_copy_private_section_data. */
6266 if (s
->output_section
!= discarded
6267 && isec
->output_section
== discarded
)
6269 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6270 elf_group_name (s
->output_section
) = NULL
;
6272 /* Conversely, if the member section is not being output
6273 but the SHT_GROUP section is, then adjust its size. */
6274 else if (s
->output_section
== discarded
6275 && isec
->output_section
!= discarded
)
6277 s
= elf_next_in_group (s
);
6283 if (discarded
!= NULL
)
6285 /* If we've been called for ld -r, then we need to
6286 adjust the input section size. This function may
6287 be called multiple times, so save the original
6289 if (isec
->rawsize
== 0)
6290 isec
->rawsize
= isec
->size
;
6291 isec
->size
= isec
->rawsize
- removed
;
6295 /* Adjust the output section size when called from
6297 isec
->output_section
->size
-= removed
;
6305 /* Copy private header information. */
6308 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6310 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6311 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6314 /* Copy over private BFD data if it has not already been copied.
6315 This must be done here, rather than in the copy_private_bfd_data
6316 entry point, because the latter is called after the section
6317 contents have been set, which means that the program headers have
6318 already been worked out. */
6319 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6321 if (! copy_private_bfd_data (ibfd
, obfd
))
6325 return _bfd_elf_fixup_group_sections (ibfd
, NULL
);
6328 /* Copy private symbol information. If this symbol is in a section
6329 which we did not map into a BFD section, try to map the section
6330 index correctly. We use special macro definitions for the mapped
6331 section indices; these definitions are interpreted by the
6332 swap_out_syms function. */
6334 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6335 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6336 #define MAP_STRTAB (SHN_HIOS + 3)
6337 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6338 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6341 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6346 elf_symbol_type
*isym
, *osym
;
6348 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6349 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6352 isym
= elf_symbol_from (ibfd
, isymarg
);
6353 osym
= elf_symbol_from (obfd
, osymarg
);
6356 && isym
->internal_elf_sym
.st_shndx
!= 0
6358 && bfd_is_abs_section (isym
->symbol
.section
))
6362 shndx
= isym
->internal_elf_sym
.st_shndx
;
6363 if (shndx
== elf_onesymtab (ibfd
))
6364 shndx
= MAP_ONESYMTAB
;
6365 else if (shndx
== elf_dynsymtab (ibfd
))
6366 shndx
= MAP_DYNSYMTAB
;
6367 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
6369 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
6370 shndx
= MAP_SHSTRTAB
;
6371 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
6372 shndx
= MAP_SYM_SHNDX
;
6373 osym
->internal_elf_sym
.st_shndx
= shndx
;
6379 /* Swap out the symbols. */
6382 swap_out_syms (bfd
*abfd
,
6383 struct bfd_strtab_hash
**sttp
,
6386 const struct elf_backend_data
*bed
;
6389 struct bfd_strtab_hash
*stt
;
6390 Elf_Internal_Shdr
*symtab_hdr
;
6391 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6392 Elf_Internal_Shdr
*symstrtab_hdr
;
6393 bfd_byte
*outbound_syms
;
6394 bfd_byte
*outbound_shndx
;
6397 bfd_boolean name_local_sections
;
6399 if (!elf_map_symbols (abfd
))
6402 /* Dump out the symtabs. */
6403 stt
= _bfd_elf_stringtab_init ();
6407 bed
= get_elf_backend_data (abfd
);
6408 symcount
= bfd_get_symcount (abfd
);
6409 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6410 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6411 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6412 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6413 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6414 symtab_hdr
->sh_addralign
= (bfd_vma
) 1 << bed
->s
->log_file_align
;
6416 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6417 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6419 outbound_syms
= (bfd_byte
*) bfd_alloc2 (abfd
, 1 + symcount
,
6420 bed
->s
->sizeof_sym
);
6421 if (outbound_syms
== NULL
)
6423 _bfd_stringtab_free (stt
);
6426 symtab_hdr
->contents
= outbound_syms
;
6428 outbound_shndx
= NULL
;
6429 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6430 if (symtab_shndx_hdr
->sh_name
!= 0)
6432 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6433 outbound_shndx
= (bfd_byte
*)
6434 bfd_zalloc2 (abfd
, 1 + symcount
, sizeof (Elf_External_Sym_Shndx
));
6435 if (outbound_shndx
== NULL
)
6437 _bfd_stringtab_free (stt
);
6441 symtab_shndx_hdr
->contents
= outbound_shndx
;
6442 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6443 symtab_shndx_hdr
->sh_size
= amt
;
6444 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6445 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6448 /* Now generate the data (for "contents"). */
6450 /* Fill in zeroth symbol and swap it out. */
6451 Elf_Internal_Sym sym
;
6457 sym
.st_shndx
= SHN_UNDEF
;
6458 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6459 outbound_syms
+= bed
->s
->sizeof_sym
;
6460 if (outbound_shndx
!= NULL
)
6461 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6465 = (bed
->elf_backend_name_local_section_symbols
6466 && bed
->elf_backend_name_local_section_symbols (abfd
));
6468 syms
= bfd_get_outsymbols (abfd
);
6469 for (idx
= 0; idx
< symcount
; idx
++)
6471 Elf_Internal_Sym sym
;
6472 bfd_vma value
= syms
[idx
]->value
;
6473 elf_symbol_type
*type_ptr
;
6474 flagword flags
= syms
[idx
]->flags
;
6477 if (!name_local_sections
6478 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6480 /* Local section symbols have no name. */
6485 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6488 if (sym
.st_name
== (unsigned long) -1)
6490 _bfd_stringtab_free (stt
);
6495 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6497 if ((flags
& BSF_SECTION_SYM
) == 0
6498 && bfd_is_com_section (syms
[idx
]->section
))
6500 /* ELF common symbols put the alignment into the `value' field,
6501 and the size into the `size' field. This is backwards from
6502 how BFD handles it, so reverse it here. */
6503 sym
.st_size
= value
;
6504 if (type_ptr
== NULL
6505 || type_ptr
->internal_elf_sym
.st_value
== 0)
6506 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6508 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6509 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6510 (abfd
, syms
[idx
]->section
);
6514 asection
*sec
= syms
[idx
]->section
;
6517 if (sec
->output_section
)
6519 value
+= sec
->output_offset
;
6520 sec
= sec
->output_section
;
6523 /* Don't add in the section vma for relocatable output. */
6524 if (! relocatable_p
)
6526 sym
.st_value
= value
;
6527 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6529 if (bfd_is_abs_section (sec
)
6531 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6533 /* This symbol is in a real ELF section which we did
6534 not create as a BFD section. Undo the mapping done
6535 by copy_private_symbol_data. */
6536 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6540 shndx
= elf_onesymtab (abfd
);
6543 shndx
= elf_dynsymtab (abfd
);
6546 shndx
= elf_tdata (abfd
)->strtab_section
;
6549 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6552 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6560 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6562 if (shndx
== SHN_BAD
)
6566 /* Writing this would be a hell of a lot easier if
6567 we had some decent documentation on bfd, and
6568 knew what to expect of the library, and what to
6569 demand of applications. For example, it
6570 appears that `objcopy' might not set the
6571 section of a symbol to be a section that is
6572 actually in the output file. */
6573 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6576 _bfd_error_handler (_("\
6577 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6578 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6580 bfd_set_error (bfd_error_invalid_operation
);
6581 _bfd_stringtab_free (stt
);
6585 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6586 BFD_ASSERT (shndx
!= SHN_BAD
);
6590 sym
.st_shndx
= shndx
;
6593 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6595 else if ((flags
& BSF_GNU_INDIRECT_FUNCTION
) != 0)
6596 type
= STT_GNU_IFUNC
;
6597 else if ((flags
& BSF_FUNCTION
) != 0)
6599 else if ((flags
& BSF_OBJECT
) != 0)
6601 else if ((flags
& BSF_RELC
) != 0)
6603 else if ((flags
& BSF_SRELC
) != 0)
6608 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6611 /* Processor-specific types. */
6612 if (type_ptr
!= NULL
6613 && bed
->elf_backend_get_symbol_type
)
6614 type
= ((*bed
->elf_backend_get_symbol_type
)
6615 (&type_ptr
->internal_elf_sym
, type
));
6617 if (flags
& BSF_SECTION_SYM
)
6619 if (flags
& BSF_GLOBAL
)
6620 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6622 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6624 else if (bfd_is_com_section (syms
[idx
]->section
))
6626 #ifdef USE_STT_COMMON
6627 if (type
== STT_OBJECT
)
6628 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_COMMON
);
6631 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
6633 else if (bfd_is_und_section (syms
[idx
]->section
))
6634 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6638 else if (flags
& BSF_FILE
)
6639 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6642 int bind
= STB_LOCAL
;
6644 if (flags
& BSF_LOCAL
)
6646 else if (flags
& BSF_GNU_UNIQUE
)
6647 bind
= STB_GNU_UNIQUE
;
6648 else if (flags
& BSF_WEAK
)
6650 else if (flags
& BSF_GLOBAL
)
6653 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6656 if (type_ptr
!= NULL
)
6657 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6661 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6662 outbound_syms
+= bed
->s
->sizeof_sym
;
6663 if (outbound_shndx
!= NULL
)
6664 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6668 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6669 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6671 symstrtab_hdr
->sh_flags
= 0;
6672 symstrtab_hdr
->sh_addr
= 0;
6673 symstrtab_hdr
->sh_entsize
= 0;
6674 symstrtab_hdr
->sh_link
= 0;
6675 symstrtab_hdr
->sh_info
= 0;
6676 symstrtab_hdr
->sh_addralign
= 1;
6681 /* Return the number of bytes required to hold the symtab vector.
6683 Note that we base it on the count plus 1, since we will null terminate
6684 the vector allocated based on this size. However, the ELF symbol table
6685 always has a dummy entry as symbol #0, so it ends up even. */
6688 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6692 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6694 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6695 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6697 symtab_size
-= sizeof (asymbol
*);
6703 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6707 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6709 if (elf_dynsymtab (abfd
) == 0)
6711 bfd_set_error (bfd_error_invalid_operation
);
6715 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6716 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6718 symtab_size
-= sizeof (asymbol
*);
6724 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6727 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6730 /* Canonicalize the relocs. */
6733 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6740 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6742 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6745 tblptr
= section
->relocation
;
6746 for (i
= 0; i
< section
->reloc_count
; i
++)
6747 *relptr
++ = tblptr
++;
6751 return section
->reloc_count
;
6755 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6757 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6758 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6761 bfd_get_symcount (abfd
) = symcount
;
6766 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6767 asymbol
**allocation
)
6769 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6770 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6773 bfd_get_dynamic_symcount (abfd
) = symcount
;
6777 /* Return the size required for the dynamic reloc entries. Any loadable
6778 section that was actually installed in the BFD, and has type SHT_REL
6779 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6780 dynamic reloc section. */
6783 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6788 if (elf_dynsymtab (abfd
) == 0)
6790 bfd_set_error (bfd_error_invalid_operation
);
6794 ret
= sizeof (arelent
*);
6795 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6796 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6797 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6798 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6799 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6800 * sizeof (arelent
*));
6805 /* Canonicalize the dynamic relocation entries. Note that we return the
6806 dynamic relocations as a single block, although they are actually
6807 associated with particular sections; the interface, which was
6808 designed for SunOS style shared libraries, expects that there is only
6809 one set of dynamic relocs. Any loadable section that was actually
6810 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6811 dynamic symbol table, is considered to be a dynamic reloc section. */
6814 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6818 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6822 if (elf_dynsymtab (abfd
) == 0)
6824 bfd_set_error (bfd_error_invalid_operation
);
6828 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6830 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6832 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6833 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6834 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6839 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6841 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6843 for (i
= 0; i
< count
; i
++)
6854 /* Read in the version information. */
6857 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6859 bfd_byte
*contents
= NULL
;
6860 unsigned int freeidx
= 0;
6862 if (elf_dynverref (abfd
) != 0)
6864 Elf_Internal_Shdr
*hdr
;
6865 Elf_External_Verneed
*everneed
;
6866 Elf_Internal_Verneed
*iverneed
;
6868 bfd_byte
*contents_end
;
6870 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6872 elf_tdata (abfd
)->verref
= (Elf_Internal_Verneed
*)
6873 bfd_zalloc2 (abfd
, hdr
->sh_info
, sizeof (Elf_Internal_Verneed
));
6874 if (elf_tdata (abfd
)->verref
== NULL
)
6877 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6879 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
6880 if (contents
== NULL
)
6882 error_return_verref
:
6883 elf_tdata (abfd
)->verref
= NULL
;
6884 elf_tdata (abfd
)->cverrefs
= 0;
6887 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6888 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6889 goto error_return_verref
;
6891 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6892 goto error_return_verref
;
6894 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6895 == sizeof (Elf_External_Vernaux
));
6896 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6897 everneed
= (Elf_External_Verneed
*) contents
;
6898 iverneed
= elf_tdata (abfd
)->verref
;
6899 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6901 Elf_External_Vernaux
*evernaux
;
6902 Elf_Internal_Vernaux
*ivernaux
;
6905 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6907 iverneed
->vn_bfd
= abfd
;
6909 iverneed
->vn_filename
=
6910 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6912 if (iverneed
->vn_filename
== NULL
)
6913 goto error_return_verref
;
6915 if (iverneed
->vn_cnt
== 0)
6916 iverneed
->vn_auxptr
= NULL
;
6919 iverneed
->vn_auxptr
= (struct elf_internal_vernaux
*)
6920 bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6921 sizeof (Elf_Internal_Vernaux
));
6922 if (iverneed
->vn_auxptr
== NULL
)
6923 goto error_return_verref
;
6926 if (iverneed
->vn_aux
6927 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6928 goto error_return_verref
;
6930 evernaux
= ((Elf_External_Vernaux
*)
6931 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6932 ivernaux
= iverneed
->vn_auxptr
;
6933 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6935 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6937 ivernaux
->vna_nodename
=
6938 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6939 ivernaux
->vna_name
);
6940 if (ivernaux
->vna_nodename
== NULL
)
6941 goto error_return_verref
;
6943 if (j
+ 1 < iverneed
->vn_cnt
)
6944 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6946 ivernaux
->vna_nextptr
= NULL
;
6948 if (ivernaux
->vna_next
6949 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6950 goto error_return_verref
;
6952 evernaux
= ((Elf_External_Vernaux
*)
6953 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6955 if (ivernaux
->vna_other
> freeidx
)
6956 freeidx
= ivernaux
->vna_other
;
6959 if (i
+ 1 < hdr
->sh_info
)
6960 iverneed
->vn_nextref
= iverneed
+ 1;
6962 iverneed
->vn_nextref
= NULL
;
6964 if (iverneed
->vn_next
6965 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6966 goto error_return_verref
;
6968 everneed
= ((Elf_External_Verneed
*)
6969 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6976 if (elf_dynverdef (abfd
) != 0)
6978 Elf_Internal_Shdr
*hdr
;
6979 Elf_External_Verdef
*everdef
;
6980 Elf_Internal_Verdef
*iverdef
;
6981 Elf_Internal_Verdef
*iverdefarr
;
6982 Elf_Internal_Verdef iverdefmem
;
6984 unsigned int maxidx
;
6985 bfd_byte
*contents_end_def
, *contents_end_aux
;
6987 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6989 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
6990 if (contents
== NULL
)
6992 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6993 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6996 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6999 BFD_ASSERT (sizeof (Elf_External_Verdef
)
7000 >= sizeof (Elf_External_Verdaux
));
7001 contents_end_def
= contents
+ hdr
->sh_size
7002 - sizeof (Elf_External_Verdef
);
7003 contents_end_aux
= contents
+ hdr
->sh_size
7004 - sizeof (Elf_External_Verdaux
);
7006 /* We know the number of entries in the section but not the maximum
7007 index. Therefore we have to run through all entries and find
7009 everdef
= (Elf_External_Verdef
*) contents
;
7011 for (i
= 0; i
< hdr
->sh_info
; ++i
)
7013 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7015 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
7016 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
7018 if (iverdefmem
.vd_next
7019 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
7022 everdef
= ((Elf_External_Verdef
*)
7023 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
7026 if (default_imported_symver
)
7028 if (freeidx
> maxidx
)
7033 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7034 bfd_zalloc2 (abfd
, maxidx
, sizeof (Elf_Internal_Verdef
));
7035 if (elf_tdata (abfd
)->verdef
== NULL
)
7038 elf_tdata (abfd
)->cverdefs
= maxidx
;
7040 everdef
= (Elf_External_Verdef
*) contents
;
7041 iverdefarr
= elf_tdata (abfd
)->verdef
;
7042 for (i
= 0; i
< hdr
->sh_info
; i
++)
7044 Elf_External_Verdaux
*everdaux
;
7045 Elf_Internal_Verdaux
*iverdaux
;
7048 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
7050 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
7052 error_return_verdef
:
7053 elf_tdata (abfd
)->verdef
= NULL
;
7054 elf_tdata (abfd
)->cverdefs
= 0;
7058 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
7059 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
7061 iverdef
->vd_bfd
= abfd
;
7063 if (iverdef
->vd_cnt
== 0)
7064 iverdef
->vd_auxptr
= NULL
;
7067 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
7068 bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
7069 sizeof (Elf_Internal_Verdaux
));
7070 if (iverdef
->vd_auxptr
== NULL
)
7071 goto error_return_verdef
;
7075 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
7076 goto error_return_verdef
;
7078 everdaux
= ((Elf_External_Verdaux
*)
7079 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
7080 iverdaux
= iverdef
->vd_auxptr
;
7081 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
7083 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
7085 iverdaux
->vda_nodename
=
7086 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
7087 iverdaux
->vda_name
);
7088 if (iverdaux
->vda_nodename
== NULL
)
7089 goto error_return_verdef
;
7091 if (j
+ 1 < iverdef
->vd_cnt
)
7092 iverdaux
->vda_nextptr
= iverdaux
+ 1;
7094 iverdaux
->vda_nextptr
= NULL
;
7096 if (iverdaux
->vda_next
7097 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
7098 goto error_return_verdef
;
7100 everdaux
= ((Elf_External_Verdaux
*)
7101 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
7104 if (iverdef
->vd_cnt
)
7105 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
7107 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
7108 iverdef
->vd_nextdef
= iverdef
+ 1;
7110 iverdef
->vd_nextdef
= NULL
;
7112 everdef
= ((Elf_External_Verdef
*)
7113 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
7119 else if (default_imported_symver
)
7126 elf_tdata (abfd
)->verdef
= (Elf_Internal_Verdef
*)
7127 bfd_zalloc2 (abfd
, freeidx
, sizeof (Elf_Internal_Verdef
));
7128 if (elf_tdata (abfd
)->verdef
== NULL
)
7131 elf_tdata (abfd
)->cverdefs
= freeidx
;
7134 /* Create a default version based on the soname. */
7135 if (default_imported_symver
)
7137 Elf_Internal_Verdef
*iverdef
;
7138 Elf_Internal_Verdaux
*iverdaux
;
7140 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
7142 iverdef
->vd_version
= VER_DEF_CURRENT
;
7143 iverdef
->vd_flags
= 0;
7144 iverdef
->vd_ndx
= freeidx
;
7145 iverdef
->vd_cnt
= 1;
7147 iverdef
->vd_bfd
= abfd
;
7149 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
7150 if (iverdef
->vd_nodename
== NULL
)
7151 goto error_return_verdef
;
7152 iverdef
->vd_nextdef
= NULL
;
7153 iverdef
->vd_auxptr
= (struct elf_internal_verdaux
*)
7154 bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
7155 if (iverdef
->vd_auxptr
== NULL
)
7156 goto error_return_verdef
;
7158 iverdaux
= iverdef
->vd_auxptr
;
7159 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
7160 iverdaux
->vda_nextptr
= NULL
;
7166 if (contents
!= NULL
)
7172 _bfd_elf_make_empty_symbol (bfd
*abfd
)
7174 elf_symbol_type
*newsym
;
7175 bfd_size_type amt
= sizeof (elf_symbol_type
);
7177 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
7182 newsym
->symbol
.the_bfd
= abfd
;
7183 return &newsym
->symbol
;
7188 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
7192 bfd_symbol_info (symbol
, ret
);
7195 /* Return whether a symbol name implies a local symbol. Most targets
7196 use this function for the is_local_label_name entry point, but some
7200 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
7203 /* Normal local symbols start with ``.L''. */
7204 if (name
[0] == '.' && name
[1] == 'L')
7207 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7208 DWARF debugging symbols starting with ``..''. */
7209 if (name
[0] == '.' && name
[1] == '.')
7212 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7213 emitting DWARF debugging output. I suspect this is actually a
7214 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7215 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7216 underscore to be emitted on some ELF targets). For ease of use,
7217 we treat such symbols as local. */
7218 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
7225 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
7226 asymbol
*symbol ATTRIBUTE_UNUSED
)
7233 _bfd_elf_set_arch_mach (bfd
*abfd
,
7234 enum bfd_architecture arch
,
7235 unsigned long machine
)
7237 /* If this isn't the right architecture for this backend, and this
7238 isn't the generic backend, fail. */
7239 if (arch
!= get_elf_backend_data (abfd
)->arch
7240 && arch
!= bfd_arch_unknown
7241 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
7244 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
7247 /* Find the function to a particular section and offset,
7248 for error reporting. */
7251 elf_find_function (bfd
*abfd
,
7255 const char **filename_ptr
,
7256 const char **functionname_ptr
)
7258 const char *filename
;
7259 asymbol
*func
, *file
;
7262 /* ??? Given multiple file symbols, it is impossible to reliably
7263 choose the right file name for global symbols. File symbols are
7264 local symbols, and thus all file symbols must sort before any
7265 global symbols. The ELF spec may be interpreted to say that a
7266 file symbol must sort before other local symbols, but currently
7267 ld -r doesn't do this. So, for ld -r output, it is possible to
7268 make a better choice of file name for local symbols by ignoring
7269 file symbols appearing after a given local symbol. */
7270 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
7271 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7277 state
= nothing_seen
;
7279 for (p
= symbols
; *p
!= NULL
; p
++)
7284 q
= (elf_symbol_type
*) *p
;
7286 type
= ELF_ST_TYPE (q
->internal_elf_sym
.st_info
);
7291 if (state
== symbol_seen
)
7292 state
= file_after_symbol_seen
;
7295 if (!bed
->is_function_type (type
))
7298 if (bfd_get_section (&q
->symbol
) == section
7299 && q
->symbol
.value
>= low_func
7300 && q
->symbol
.value
<= offset
)
7302 func
= (asymbol
*) q
;
7303 low_func
= q
->symbol
.value
;
7306 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
7307 || state
!= file_after_symbol_seen
))
7308 filename
= bfd_asymbol_name (file
);
7312 if (state
== nothing_seen
)
7313 state
= symbol_seen
;
7320 *filename_ptr
= filename
;
7321 if (functionname_ptr
)
7322 *functionname_ptr
= bfd_asymbol_name (func
);
7327 /* Find the nearest line to a particular section and offset,
7328 for error reporting. */
7331 _bfd_elf_find_nearest_line (bfd
*abfd
,
7335 const char **filename_ptr
,
7336 const char **functionname_ptr
,
7337 unsigned int *line_ptr
)
7341 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7342 filename_ptr
, functionname_ptr
,
7345 if (!*functionname_ptr
)
7346 elf_find_function (abfd
, section
, symbols
, offset
,
7347 *filename_ptr
? NULL
: filename_ptr
,
7353 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7354 filename_ptr
, functionname_ptr
,
7356 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7358 if (!*functionname_ptr
)
7359 elf_find_function (abfd
, section
, symbols
, offset
,
7360 *filename_ptr
? NULL
: filename_ptr
,
7366 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7367 &found
, filename_ptr
,
7368 functionname_ptr
, line_ptr
,
7369 &elf_tdata (abfd
)->line_info
))
7371 if (found
&& (*functionname_ptr
|| *line_ptr
))
7374 if (symbols
== NULL
)
7377 if (! elf_find_function (abfd
, section
, symbols
, offset
,
7378 filename_ptr
, functionname_ptr
))
7385 /* Find the line for a symbol. */
7388 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7389 const char **filename_ptr
, unsigned int *line_ptr
)
7391 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
7392 filename_ptr
, line_ptr
, 0,
7393 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7396 /* After a call to bfd_find_nearest_line, successive calls to
7397 bfd_find_inliner_info can be used to get source information about
7398 each level of function inlining that terminated at the address
7399 passed to bfd_find_nearest_line. Currently this is only supported
7400 for DWARF2 with appropriate DWARF3 extensions. */
7403 _bfd_elf_find_inliner_info (bfd
*abfd
,
7404 const char **filename_ptr
,
7405 const char **functionname_ptr
,
7406 unsigned int *line_ptr
)
7409 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7410 functionname_ptr
, line_ptr
,
7411 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7416 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7418 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7419 int ret
= bed
->s
->sizeof_ehdr
;
7421 if (!info
->relocatable
)
7423 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7425 if (phdr_size
== (bfd_size_type
) -1)
7427 struct elf_segment_map
*m
;
7430 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7431 phdr_size
+= bed
->s
->sizeof_phdr
;
7434 phdr_size
= get_program_header_size (abfd
, info
);
7437 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7445 _bfd_elf_set_section_contents (bfd
*abfd
,
7447 const void *location
,
7449 bfd_size_type count
)
7451 Elf_Internal_Shdr
*hdr
;
7454 if (! abfd
->output_has_begun
7455 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7458 hdr
= &elf_section_data (section
)->this_hdr
;
7459 pos
= hdr
->sh_offset
+ offset
;
7460 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7461 || bfd_bwrite (location
, count
, abfd
) != count
)
7468 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7469 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7470 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7475 /* Try to convert a non-ELF reloc into an ELF one. */
7478 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7480 /* Check whether we really have an ELF howto. */
7482 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7484 bfd_reloc_code_real_type code
;
7485 reloc_howto_type
*howto
;
7487 /* Alien reloc: Try to determine its type to replace it with an
7488 equivalent ELF reloc. */
7490 if (areloc
->howto
->pc_relative
)
7492 switch (areloc
->howto
->bitsize
)
7495 code
= BFD_RELOC_8_PCREL
;
7498 code
= BFD_RELOC_12_PCREL
;
7501 code
= BFD_RELOC_16_PCREL
;
7504 code
= BFD_RELOC_24_PCREL
;
7507 code
= BFD_RELOC_32_PCREL
;
7510 code
= BFD_RELOC_64_PCREL
;
7516 howto
= bfd_reloc_type_lookup (abfd
, code
);
7518 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7520 if (howto
->pcrel_offset
)
7521 areloc
->addend
+= areloc
->address
;
7523 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7528 switch (areloc
->howto
->bitsize
)
7534 code
= BFD_RELOC_14
;
7537 code
= BFD_RELOC_16
;
7540 code
= BFD_RELOC_26
;
7543 code
= BFD_RELOC_32
;
7546 code
= BFD_RELOC_64
;
7552 howto
= bfd_reloc_type_lookup (abfd
, code
);
7556 areloc
->howto
= howto
;
7564 (*_bfd_error_handler
)
7565 (_("%B: unsupported relocation type %s"),
7566 abfd
, areloc
->howto
->name
);
7567 bfd_set_error (bfd_error_bad_value
);
7572 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7574 if (bfd_get_format (abfd
) == bfd_object
)
7576 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7577 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7578 _bfd_dwarf2_cleanup_debug_info (abfd
);
7581 return _bfd_generic_close_and_cleanup (abfd
);
7584 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7585 in the relocation's offset. Thus we cannot allow any sort of sanity
7586 range-checking to interfere. There is nothing else to do in processing
7589 bfd_reloc_status_type
7590 _bfd_elf_rel_vtable_reloc_fn
7591 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7592 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7593 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7594 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7596 return bfd_reloc_ok
;
7599 /* Elf core file support. Much of this only works on native
7600 toolchains, since we rely on knowing the
7601 machine-dependent procfs structure in order to pick
7602 out details about the corefile. */
7604 #ifdef HAVE_SYS_PROCFS_H
7605 /* Needed for new procfs interface on sparc-solaris. */
7606 # define _STRUCTURED_PROC 1
7607 # include <sys/procfs.h>
7610 /* Return a PID that identifies a "thread" for threaded cores, or the
7611 PID of the main process for non-threaded cores. */
7614 elfcore_make_pid (bfd
*abfd
)
7618 pid
= elf_tdata (abfd
)->core_lwpid
;
7620 pid
= elf_tdata (abfd
)->core_pid
;
7625 /* If there isn't a section called NAME, make one, using
7626 data from SECT. Note, this function will generate a
7627 reference to NAME, so you shouldn't deallocate or
7631 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7635 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7638 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7642 sect2
->size
= sect
->size
;
7643 sect2
->filepos
= sect
->filepos
;
7644 sect2
->alignment_power
= sect
->alignment_power
;
7648 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7649 actually creates up to two pseudosections:
7650 - For the single-threaded case, a section named NAME, unless
7651 such a section already exists.
7652 - For the multi-threaded case, a section named "NAME/PID", where
7653 PID is elfcore_make_pid (abfd).
7654 Both pseudosections have identical contents. */
7656 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7662 char *threaded_name
;
7666 /* Build the section name. */
7668 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7669 len
= strlen (buf
) + 1;
7670 threaded_name
= (char *) bfd_alloc (abfd
, len
);
7671 if (threaded_name
== NULL
)
7673 memcpy (threaded_name
, buf
, len
);
7675 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7680 sect
->filepos
= filepos
;
7681 sect
->alignment_power
= 2;
7683 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7686 /* prstatus_t exists on:
7688 linux 2.[01] + glibc
7692 #if defined (HAVE_PRSTATUS_T)
7695 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7700 if (note
->descsz
== sizeof (prstatus_t
))
7704 size
= sizeof (prstat
.pr_reg
);
7705 offset
= offsetof (prstatus_t
, pr_reg
);
7706 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7708 /* Do not overwrite the core signal if it
7709 has already been set by another thread. */
7710 if (elf_tdata (abfd
)->core_signal
== 0)
7711 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7712 if (elf_tdata (abfd
)->core_pid
== 0)
7713 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7715 /* pr_who exists on:
7718 pr_who doesn't exist on:
7721 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7722 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7724 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_pid
;
7727 #if defined (HAVE_PRSTATUS32_T)
7728 else if (note
->descsz
== sizeof (prstatus32_t
))
7730 /* 64-bit host, 32-bit corefile */
7731 prstatus32_t prstat
;
7733 size
= sizeof (prstat
.pr_reg
);
7734 offset
= offsetof (prstatus32_t
, pr_reg
);
7735 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7737 /* Do not overwrite the core signal if it
7738 has already been set by another thread. */
7739 if (elf_tdata (abfd
)->core_signal
== 0)
7740 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7741 if (elf_tdata (abfd
)->core_pid
== 0)
7742 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7744 /* pr_who exists on:
7747 pr_who doesn't exist on:
7750 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7751 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7753 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_pid
;
7756 #endif /* HAVE_PRSTATUS32_T */
7759 /* Fail - we don't know how to handle any other
7760 note size (ie. data object type). */
7764 /* Make a ".reg/999" section and a ".reg" section. */
7765 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7766 size
, note
->descpos
+ offset
);
7768 #endif /* defined (HAVE_PRSTATUS_T) */
7770 /* Create a pseudosection containing the exact contents of NOTE. */
7772 elfcore_make_note_pseudosection (bfd
*abfd
,
7774 Elf_Internal_Note
*note
)
7776 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7777 note
->descsz
, note
->descpos
);
7780 /* There isn't a consistent prfpregset_t across platforms,
7781 but it doesn't matter, because we don't have to pick this
7782 data structure apart. */
7785 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7787 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7790 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7791 type of NT_PRXFPREG. Just include the whole note's contents
7795 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7797 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7800 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
7801 with a note type of NT_X86_XSTATE. Just include the whole note's
7802 contents literally. */
7805 elfcore_grok_xstatereg (bfd
*abfd
, Elf_Internal_Note
*note
)
7807 return elfcore_make_note_pseudosection (abfd
, ".reg-xstate", note
);
7811 elfcore_grok_ppc_vmx (bfd
*abfd
, Elf_Internal_Note
*note
)
7813 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vmx", note
);
7817 elfcore_grok_ppc_vsx (bfd
*abfd
, Elf_Internal_Note
*note
)
7819 return elfcore_make_note_pseudosection (abfd
, ".reg-ppc-vsx", note
);
7823 elfcore_grok_s390_high_gprs (bfd
*abfd
, Elf_Internal_Note
*note
)
7825 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-high-gprs", note
);
7829 elfcore_grok_s390_timer (bfd
*abfd
, Elf_Internal_Note
*note
)
7831 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-timer", note
);
7835 elfcore_grok_s390_todcmp (bfd
*abfd
, Elf_Internal_Note
*note
)
7837 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todcmp", note
);
7841 elfcore_grok_s390_todpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7843 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-todpreg", note
);
7847 elfcore_grok_s390_ctrs (bfd
*abfd
, Elf_Internal_Note
*note
)
7849 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-ctrs", note
);
7853 elfcore_grok_s390_prefix (bfd
*abfd
, Elf_Internal_Note
*note
)
7855 return elfcore_make_note_pseudosection (abfd
, ".reg-s390-prefix", note
);
7858 #if defined (HAVE_PRPSINFO_T)
7859 typedef prpsinfo_t elfcore_psinfo_t
;
7860 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7861 typedef prpsinfo32_t elfcore_psinfo32_t
;
7865 #if defined (HAVE_PSINFO_T)
7866 typedef psinfo_t elfcore_psinfo_t
;
7867 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7868 typedef psinfo32_t elfcore_psinfo32_t
;
7872 /* return a malloc'ed copy of a string at START which is at
7873 most MAX bytes long, possibly without a terminating '\0'.
7874 the copy will always have a terminating '\0'. */
7877 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7880 char *end
= (char *) memchr (start
, '\0', max
);
7888 dups
= (char *) bfd_alloc (abfd
, len
+ 1);
7892 memcpy (dups
, start
, len
);
7898 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7900 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7902 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7904 elfcore_psinfo_t psinfo
;
7906 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7908 elf_tdata (abfd
)->core_program
7909 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7910 sizeof (psinfo
.pr_fname
));
7912 elf_tdata (abfd
)->core_command
7913 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7914 sizeof (psinfo
.pr_psargs
));
7916 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7917 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7919 /* 64-bit host, 32-bit corefile */
7920 elfcore_psinfo32_t psinfo
;
7922 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7924 elf_tdata (abfd
)->core_program
7925 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7926 sizeof (psinfo
.pr_fname
));
7928 elf_tdata (abfd
)->core_command
7929 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7930 sizeof (psinfo
.pr_psargs
));
7936 /* Fail - we don't know how to handle any other
7937 note size (ie. data object type). */
7941 /* Note that for some reason, a spurious space is tacked
7942 onto the end of the args in some (at least one anyway)
7943 implementations, so strip it off if it exists. */
7946 char *command
= elf_tdata (abfd
)->core_command
;
7947 int n
= strlen (command
);
7949 if (0 < n
&& command
[n
- 1] == ' ')
7950 command
[n
- 1] = '\0';
7955 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7957 #if defined (HAVE_PSTATUS_T)
7959 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7961 if (note
->descsz
== sizeof (pstatus_t
)
7962 #if defined (HAVE_PXSTATUS_T)
7963 || note
->descsz
== sizeof (pxstatus_t
)
7969 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7971 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7973 #if defined (HAVE_PSTATUS32_T)
7974 else if (note
->descsz
== sizeof (pstatus32_t
))
7976 /* 64-bit host, 32-bit corefile */
7979 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7981 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7984 /* Could grab some more details from the "representative"
7985 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7986 NT_LWPSTATUS note, presumably. */
7990 #endif /* defined (HAVE_PSTATUS_T) */
7992 #if defined (HAVE_LWPSTATUS_T)
7994 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7996 lwpstatus_t lwpstat
;
8002 if (note
->descsz
!= sizeof (lwpstat
)
8003 #if defined (HAVE_LWPXSTATUS_T)
8004 && note
->descsz
!= sizeof (lwpxstatus_t
)
8009 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
8011 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
8012 /* Do not overwrite the core signal if it has already been set by
8014 if (elf_tdata (abfd
)->core_signal
== 0)
8015 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
8017 /* Make a ".reg/999" section. */
8019 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
8020 len
= strlen (buf
) + 1;
8021 name
= bfd_alloc (abfd
, len
);
8024 memcpy (name
, buf
, len
);
8026 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8030 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8031 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
8032 sect
->filepos
= note
->descpos
8033 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
8036 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8037 sect
->size
= sizeof (lwpstat
.pr_reg
);
8038 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
8041 sect
->alignment_power
= 2;
8043 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8046 /* Make a ".reg2/999" section */
8048 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
8049 len
= strlen (buf
) + 1;
8050 name
= bfd_alloc (abfd
, len
);
8053 memcpy (name
, buf
, len
);
8055 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8059 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8060 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
8061 sect
->filepos
= note
->descpos
8062 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
8065 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8066 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
8067 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
8070 sect
->alignment_power
= 2;
8072 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
8074 #endif /* defined (HAVE_LWPSTATUS_T) */
8077 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
8084 int is_active_thread
;
8087 if (note
->descsz
< 728)
8090 if (! CONST_STRNEQ (note
->namedata
, "win32"))
8093 type
= bfd_get_32 (abfd
, note
->descdata
);
8097 case 1 /* NOTE_INFO_PROCESS */:
8098 /* FIXME: need to add ->core_command. */
8099 /* process_info.pid */
8100 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8101 /* process_info.signal */
8102 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
8105 case 2 /* NOTE_INFO_THREAD */:
8106 /* Make a ".reg/999" section. */
8107 /* thread_info.tid */
8108 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
8110 len
= strlen (buf
) + 1;
8111 name
= (char *) bfd_alloc (abfd
, len
);
8115 memcpy (name
, buf
, len
);
8117 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8121 /* sizeof (thread_info.thread_context) */
8123 /* offsetof (thread_info.thread_context) */
8124 sect
->filepos
= note
->descpos
+ 12;
8125 sect
->alignment_power
= 2;
8127 /* thread_info.is_active_thread */
8128 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
8130 if (is_active_thread
)
8131 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
8135 case 3 /* NOTE_INFO_MODULE */:
8136 /* Make a ".module/xxxxxxxx" section. */
8137 /* module_info.base_address */
8138 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
8139 sprintf (buf
, ".module/%08lx", (unsigned long) base_addr
);
8141 len
= strlen (buf
) + 1;
8142 name
= (char *) bfd_alloc (abfd
, len
);
8146 memcpy (name
, buf
, len
);
8148 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8153 sect
->size
= note
->descsz
;
8154 sect
->filepos
= note
->descpos
;
8155 sect
->alignment_power
= 2;
8166 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8168 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8176 if (bed
->elf_backend_grok_prstatus
)
8177 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
8179 #if defined (HAVE_PRSTATUS_T)
8180 return elfcore_grok_prstatus (abfd
, note
);
8185 #if defined (HAVE_PSTATUS_T)
8187 return elfcore_grok_pstatus (abfd
, note
);
8190 #if defined (HAVE_LWPSTATUS_T)
8192 return elfcore_grok_lwpstatus (abfd
, note
);
8195 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
8196 return elfcore_grok_prfpreg (abfd
, note
);
8198 case NT_WIN32PSTATUS
:
8199 return elfcore_grok_win32pstatus (abfd
, note
);
8201 case NT_PRXFPREG
: /* Linux SSE extension */
8202 if (note
->namesz
== 6
8203 && strcmp (note
->namedata
, "LINUX") == 0)
8204 return elfcore_grok_prxfpreg (abfd
, note
);
8208 case NT_X86_XSTATE
: /* Linux XSAVE extension */
8209 if (note
->namesz
== 6
8210 && strcmp (note
->namedata
, "LINUX") == 0)
8211 return elfcore_grok_xstatereg (abfd
, note
);
8216 if (note
->namesz
== 6
8217 && strcmp (note
->namedata
, "LINUX") == 0)
8218 return elfcore_grok_ppc_vmx (abfd
, note
);
8223 if (note
->namesz
== 6
8224 && strcmp (note
->namedata
, "LINUX") == 0)
8225 return elfcore_grok_ppc_vsx (abfd
, note
);
8229 case NT_S390_HIGH_GPRS
:
8230 if (note
->namesz
== 6
8231 && strcmp (note
->namedata
, "LINUX") == 0)
8232 return elfcore_grok_s390_high_gprs (abfd
, note
);
8237 if (note
->namesz
== 6
8238 && strcmp (note
->namedata
, "LINUX") == 0)
8239 return elfcore_grok_s390_timer (abfd
, note
);
8243 case NT_S390_TODCMP
:
8244 if (note
->namesz
== 6
8245 && strcmp (note
->namedata
, "LINUX") == 0)
8246 return elfcore_grok_s390_todcmp (abfd
, note
);
8250 case NT_S390_TODPREG
:
8251 if (note
->namesz
== 6
8252 && strcmp (note
->namedata
, "LINUX") == 0)
8253 return elfcore_grok_s390_todpreg (abfd
, note
);
8258 if (note
->namesz
== 6
8259 && strcmp (note
->namedata
, "LINUX") == 0)
8260 return elfcore_grok_s390_ctrs (abfd
, note
);
8264 case NT_S390_PREFIX
:
8265 if (note
->namesz
== 6
8266 && strcmp (note
->namedata
, "LINUX") == 0)
8267 return elfcore_grok_s390_prefix (abfd
, note
);
8273 if (bed
->elf_backend_grok_psinfo
)
8274 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
8276 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8277 return elfcore_grok_psinfo (abfd
, note
);
8284 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
8289 sect
->size
= note
->descsz
;
8290 sect
->filepos
= note
->descpos
;
8291 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8299 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
8301 elf_tdata (abfd
)->build_id_size
= note
->descsz
;
8302 elf_tdata (abfd
)->build_id
= (bfd_byte
*) bfd_alloc (abfd
, note
->descsz
);
8303 if (elf_tdata (abfd
)->build_id
== NULL
)
8306 memcpy (elf_tdata (abfd
)->build_id
, note
->descdata
, note
->descsz
);
8312 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8319 case NT_GNU_BUILD_ID
:
8320 return elfobj_grok_gnu_build_id (abfd
, note
);
8325 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
8329 cp
= strchr (note
->namedata
, '@');
8332 *lwpidp
= atoi(cp
+ 1);
8339 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8341 /* Signal number at offset 0x08. */
8342 elf_tdata (abfd
)->core_signal
8343 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8345 /* Process ID at offset 0x50. */
8346 elf_tdata (abfd
)->core_pid
8347 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
8349 /* Command name at 0x7c (max 32 bytes, including nul). */
8350 elf_tdata (abfd
)->core_command
8351 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
8353 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
8358 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8362 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
8363 elf_tdata (abfd
)->core_lwpid
= lwp
;
8365 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
8367 /* NetBSD-specific core "procinfo". Note that we expect to
8368 find this note before any of the others, which is fine,
8369 since the kernel writes this note out first when it
8370 creates a core file. */
8372 return elfcore_grok_netbsd_procinfo (abfd
, note
);
8375 /* As of Jan 2002 there are no other machine-independent notes
8376 defined for NetBSD core files. If the note type is less
8377 than the start of the machine-dependent note types, we don't
8380 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
8384 switch (bfd_get_arch (abfd
))
8386 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8387 PT_GETFPREGS == mach+2. */
8389 case bfd_arch_alpha
:
8390 case bfd_arch_sparc
:
8393 case NT_NETBSDCORE_FIRSTMACH
+0:
8394 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8396 case NT_NETBSDCORE_FIRSTMACH
+2:
8397 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8403 /* On all other arch's, PT_GETREGS == mach+1 and
8404 PT_GETFPREGS == mach+3. */
8409 case NT_NETBSDCORE_FIRSTMACH
+1:
8410 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8412 case NT_NETBSDCORE_FIRSTMACH
+3:
8413 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8423 elfcore_grok_openbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8425 /* Signal number at offset 0x08. */
8426 elf_tdata (abfd
)->core_signal
8427 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8429 /* Process ID at offset 0x20. */
8430 elf_tdata (abfd
)->core_pid
8431 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x20);
8433 /* Command name at 0x48 (max 32 bytes, including nul). */
8434 elf_tdata (abfd
)->core_command
8435 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x48, 31);
8441 elfcore_grok_openbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8443 if (note
->type
== NT_OPENBSD_PROCINFO
)
8444 return elfcore_grok_openbsd_procinfo (abfd
, note
);
8446 if (note
->type
== NT_OPENBSD_REGS
)
8447 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8449 if (note
->type
== NT_OPENBSD_FPREGS
)
8450 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8452 if (note
->type
== NT_OPENBSD_XFPREGS
)
8453 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
8455 if (note
->type
== NT_OPENBSD_AUXV
)
8457 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
8462 sect
->size
= note
->descsz
;
8463 sect
->filepos
= note
->descpos
;
8464 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8469 if (note
->type
== NT_OPENBSD_WCOOKIE
)
8471 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".wcookie",
8476 sect
->size
= note
->descsz
;
8477 sect
->filepos
= note
->descpos
;
8478 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
8487 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
8489 void *ddata
= note
->descdata
;
8496 /* nto_procfs_status 'pid' field is at offset 0. */
8497 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
8499 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8500 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
8502 /* nto_procfs_status 'flags' field is at offset 8. */
8503 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
8505 /* nto_procfs_status 'what' field is at offset 14. */
8506 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
8508 elf_tdata (abfd
)->core_signal
= sig
;
8509 elf_tdata (abfd
)->core_lwpid
= *tid
;
8512 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8513 do not come from signals so we make sure we set the current
8514 thread just in case. */
8515 if (flags
& 0x00000080)
8516 elf_tdata (abfd
)->core_lwpid
= *tid
;
8518 /* Make a ".qnx_core_status/%d" section. */
8519 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
8521 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
8526 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8530 sect
->size
= note
->descsz
;
8531 sect
->filepos
= note
->descpos
;
8532 sect
->alignment_power
= 2;
8534 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
8538 elfcore_grok_nto_regs (bfd
*abfd
,
8539 Elf_Internal_Note
*note
,
8547 /* Make a "(base)/%d" section. */
8548 sprintf (buf
, "%s/%ld", base
, tid
);
8550 name
= (char *) bfd_alloc (abfd
, strlen (buf
) + 1);
8555 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8559 sect
->size
= note
->descsz
;
8560 sect
->filepos
= note
->descpos
;
8561 sect
->alignment_power
= 2;
8563 /* This is the current thread. */
8564 if (elf_tdata (abfd
)->core_lwpid
== tid
)
8565 return elfcore_maybe_make_sect (abfd
, base
, sect
);
8570 #define BFD_QNT_CORE_INFO 7
8571 #define BFD_QNT_CORE_STATUS 8
8572 #define BFD_QNT_CORE_GREG 9
8573 #define BFD_QNT_CORE_FPREG 10
8576 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8578 /* Every GREG section has a STATUS section before it. Store the
8579 tid from the previous call to pass down to the next gregs
8581 static long tid
= 1;
8585 case BFD_QNT_CORE_INFO
:
8586 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
8587 case BFD_QNT_CORE_STATUS
:
8588 return elfcore_grok_nto_status (abfd
, note
, &tid
);
8589 case BFD_QNT_CORE_GREG
:
8590 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
8591 case BFD_QNT_CORE_FPREG
:
8592 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
8599 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8605 /* Use note name as section name. */
8607 name
= (char *) bfd_alloc (abfd
, len
);
8610 memcpy (name
, note
->namedata
, len
);
8611 name
[len
- 1] = '\0';
8613 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8617 sect
->size
= note
->descsz
;
8618 sect
->filepos
= note
->descpos
;
8619 sect
->alignment_power
= 1;
8624 /* Function: elfcore_write_note
8627 buffer to hold note, and current size of buffer
8631 size of data for note
8633 Writes note to end of buffer. ELF64 notes are written exactly as
8634 for ELF32, despite the current (as of 2006) ELF gabi specifying
8635 that they ought to have 8-byte namesz and descsz field, and have
8636 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8639 Pointer to realloc'd buffer, *BUFSIZ updated. */
8642 elfcore_write_note (bfd
*abfd
,
8650 Elf_External_Note
*xnp
;
8657 namesz
= strlen (name
) + 1;
8659 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8661 buf
= (char *) realloc (buf
, *bufsiz
+ newspace
);
8664 dest
= buf
+ *bufsiz
;
8665 *bufsiz
+= newspace
;
8666 xnp
= (Elf_External_Note
*) dest
;
8667 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8668 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8669 H_PUT_32 (abfd
, type
, xnp
->type
);
8673 memcpy (dest
, name
, namesz
);
8681 memcpy (dest
, input
, size
);
8691 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8693 elfcore_write_prpsinfo (bfd
*abfd
,
8699 const char *note_name
= "CORE";
8700 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8702 if (bed
->elf_backend_write_core_note
!= NULL
)
8705 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8706 NT_PRPSINFO
, fname
, psargs
);
8711 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8712 if (bed
->s
->elfclass
== ELFCLASS32
)
8714 #if defined (HAVE_PSINFO32_T)
8716 int note_type
= NT_PSINFO
;
8719 int note_type
= NT_PRPSINFO
;
8722 memset (&data
, 0, sizeof (data
));
8723 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8724 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8725 return elfcore_write_note (abfd
, buf
, bufsiz
,
8726 note_name
, note_type
, &data
, sizeof (data
));
8731 #if defined (HAVE_PSINFO_T)
8733 int note_type
= NT_PSINFO
;
8736 int note_type
= NT_PRPSINFO
;
8739 memset (&data
, 0, sizeof (data
));
8740 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8741 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8742 return elfcore_write_note (abfd
, buf
, bufsiz
,
8743 note_name
, note_type
, &data
, sizeof (data
));
8746 #endif /* PSINFO_T or PRPSINFO_T */
8748 #if defined (HAVE_PRSTATUS_T)
8750 elfcore_write_prstatus (bfd
*abfd
,
8757 const char *note_name
= "CORE";
8758 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8760 if (bed
->elf_backend_write_core_note
!= NULL
)
8763 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8765 pid
, cursig
, gregs
);
8770 #if defined (HAVE_PRSTATUS32_T)
8771 if (bed
->s
->elfclass
== ELFCLASS32
)
8773 prstatus32_t prstat
;
8775 memset (&prstat
, 0, sizeof (prstat
));
8776 prstat
.pr_pid
= pid
;
8777 prstat
.pr_cursig
= cursig
;
8778 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8779 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8780 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8787 memset (&prstat
, 0, sizeof (prstat
));
8788 prstat
.pr_pid
= pid
;
8789 prstat
.pr_cursig
= cursig
;
8790 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8791 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8792 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8795 #endif /* HAVE_PRSTATUS_T */
8797 #if defined (HAVE_LWPSTATUS_T)
8799 elfcore_write_lwpstatus (bfd
*abfd
,
8806 lwpstatus_t lwpstat
;
8807 const char *note_name
= "CORE";
8809 memset (&lwpstat
, 0, sizeof (lwpstat
));
8810 lwpstat
.pr_lwpid
= pid
>> 16;
8811 lwpstat
.pr_cursig
= cursig
;
8812 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8813 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8814 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8816 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8817 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8819 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8820 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8823 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8824 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8826 #endif /* HAVE_LWPSTATUS_T */
8828 #if defined (HAVE_PSTATUS_T)
8830 elfcore_write_pstatus (bfd
*abfd
,
8834 int cursig ATTRIBUTE_UNUSED
,
8835 const void *gregs ATTRIBUTE_UNUSED
)
8837 const char *note_name
= "CORE";
8838 #if defined (HAVE_PSTATUS32_T)
8839 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8841 if (bed
->s
->elfclass
== ELFCLASS32
)
8845 memset (&pstat
, 0, sizeof (pstat
));
8846 pstat
.pr_pid
= pid
& 0xffff;
8847 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8848 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8856 memset (&pstat
, 0, sizeof (pstat
));
8857 pstat
.pr_pid
= pid
& 0xffff;
8858 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8859 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8863 #endif /* HAVE_PSTATUS_T */
8866 elfcore_write_prfpreg (bfd
*abfd
,
8872 const char *note_name
= "CORE";
8873 return elfcore_write_note (abfd
, buf
, bufsiz
,
8874 note_name
, NT_FPREGSET
, fpregs
, size
);
8878 elfcore_write_prxfpreg (bfd
*abfd
,
8881 const void *xfpregs
,
8884 char *note_name
= "LINUX";
8885 return elfcore_write_note (abfd
, buf
, bufsiz
,
8886 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8890 elfcore_write_xstatereg (bfd
*abfd
, char *buf
, int *bufsiz
,
8891 const void *xfpregs
, int size
)
8893 char *note_name
= "LINUX";
8894 return elfcore_write_note (abfd
, buf
, bufsiz
,
8895 note_name
, NT_X86_XSTATE
, xfpregs
, size
);
8899 elfcore_write_ppc_vmx (bfd
*abfd
,
8902 const void *ppc_vmx
,
8905 char *note_name
= "LINUX";
8906 return elfcore_write_note (abfd
, buf
, bufsiz
,
8907 note_name
, NT_PPC_VMX
, ppc_vmx
, size
);
8911 elfcore_write_ppc_vsx (bfd
*abfd
,
8914 const void *ppc_vsx
,
8917 char *note_name
= "LINUX";
8918 return elfcore_write_note (abfd
, buf
, bufsiz
,
8919 note_name
, NT_PPC_VSX
, ppc_vsx
, size
);
8923 elfcore_write_s390_high_gprs (bfd
*abfd
,
8926 const void *s390_high_gprs
,
8929 char *note_name
= "LINUX";
8930 return elfcore_write_note (abfd
, buf
, bufsiz
,
8931 note_name
, NT_S390_HIGH_GPRS
,
8932 s390_high_gprs
, size
);
8936 elfcore_write_s390_timer (bfd
*abfd
,
8939 const void *s390_timer
,
8942 char *note_name
= "LINUX";
8943 return elfcore_write_note (abfd
, buf
, bufsiz
,
8944 note_name
, NT_S390_TIMER
, s390_timer
, size
);
8948 elfcore_write_s390_todcmp (bfd
*abfd
,
8951 const void *s390_todcmp
,
8954 char *note_name
= "LINUX";
8955 return elfcore_write_note (abfd
, buf
, bufsiz
,
8956 note_name
, NT_S390_TODCMP
, s390_todcmp
, size
);
8960 elfcore_write_s390_todpreg (bfd
*abfd
,
8963 const void *s390_todpreg
,
8966 char *note_name
= "LINUX";
8967 return elfcore_write_note (abfd
, buf
, bufsiz
,
8968 note_name
, NT_S390_TODPREG
, s390_todpreg
, size
);
8972 elfcore_write_s390_ctrs (bfd
*abfd
,
8975 const void *s390_ctrs
,
8978 char *note_name
= "LINUX";
8979 return elfcore_write_note (abfd
, buf
, bufsiz
,
8980 note_name
, NT_S390_CTRS
, s390_ctrs
, size
);
8984 elfcore_write_s390_prefix (bfd
*abfd
,
8987 const void *s390_prefix
,
8990 char *note_name
= "LINUX";
8991 return elfcore_write_note (abfd
, buf
, bufsiz
,
8992 note_name
, NT_S390_PREFIX
, s390_prefix
, size
);
8996 elfcore_write_register_note (bfd
*abfd
,
8999 const char *section
,
9003 if (strcmp (section
, ".reg2") == 0)
9004 return elfcore_write_prfpreg (abfd
, buf
, bufsiz
, data
, size
);
9005 if (strcmp (section
, ".reg-xfp") == 0)
9006 return elfcore_write_prxfpreg (abfd
, buf
, bufsiz
, data
, size
);
9007 if (strcmp (section
, ".reg-xstate") == 0)
9008 return elfcore_write_xstatereg (abfd
, buf
, bufsiz
, data
, size
);
9009 if (strcmp (section
, ".reg-ppc-vmx") == 0)
9010 return elfcore_write_ppc_vmx (abfd
, buf
, bufsiz
, data
, size
);
9011 if (strcmp (section
, ".reg-ppc-vsx") == 0)
9012 return elfcore_write_ppc_vsx (abfd
, buf
, bufsiz
, data
, size
);
9013 if (strcmp (section
, ".reg-s390-high-gprs") == 0)
9014 return elfcore_write_s390_high_gprs (abfd
, buf
, bufsiz
, data
, size
);
9015 if (strcmp (section
, ".reg-s390-timer") == 0)
9016 return elfcore_write_s390_timer (abfd
, buf
, bufsiz
, data
, size
);
9017 if (strcmp (section
, ".reg-s390-todcmp") == 0)
9018 return elfcore_write_s390_todcmp (abfd
, buf
, bufsiz
, data
, size
);
9019 if (strcmp (section
, ".reg-s390-todpreg") == 0)
9020 return elfcore_write_s390_todpreg (abfd
, buf
, bufsiz
, data
, size
);
9021 if (strcmp (section
, ".reg-s390-ctrs") == 0)
9022 return elfcore_write_s390_ctrs (abfd
, buf
, bufsiz
, data
, size
);
9023 if (strcmp (section
, ".reg-s390-prefix") == 0)
9024 return elfcore_write_s390_prefix (abfd
, buf
, bufsiz
, data
, size
);
9029 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
9034 while (p
< buf
+ size
)
9036 /* FIXME: bad alignment assumption. */
9037 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
9038 Elf_Internal_Note in
;
9040 if (offsetof (Elf_External_Note
, name
) > buf
- p
+ size
)
9043 in
.type
= H_GET_32 (abfd
, xnp
->type
);
9045 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
9046 in
.namedata
= xnp
->name
;
9047 if (in
.namesz
> buf
- in
.namedata
+ size
)
9050 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
9051 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
9052 in
.descpos
= offset
+ (in
.descdata
- buf
);
9054 && (in
.descdata
>= buf
+ size
9055 || in
.descsz
> buf
- in
.descdata
+ size
))
9058 switch (bfd_get_format (abfd
))
9064 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
9066 if (! elfcore_grok_netbsd_note (abfd
, &in
))
9069 else if (CONST_STRNEQ (in
.namedata
, "OpenBSD"))
9071 if (! elfcore_grok_openbsd_note (abfd
, &in
))
9074 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
9076 if (! elfcore_grok_nto_note (abfd
, &in
))
9079 else if (CONST_STRNEQ (in
.namedata
, "SPU/"))
9081 if (! elfcore_grok_spu_note (abfd
, &in
))
9086 if (! elfcore_grok_note (abfd
, &in
))
9092 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
9094 if (! elfobj_grok_gnu_note (abfd
, &in
))
9100 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
9107 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
9114 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
9117 buf
= (char *) bfd_malloc (size
);
9121 if (bfd_bread (buf
, size
, abfd
) != size
9122 || !elf_parse_notes (abfd
, buf
, size
, offset
))
9132 /* Providing external access to the ELF program header table. */
9134 /* Return an upper bound on the number of bytes required to store a
9135 copy of ABFD's program header table entries. Return -1 if an error
9136 occurs; bfd_get_error will return an appropriate code. */
9139 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
9141 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9143 bfd_set_error (bfd_error_wrong_format
);
9147 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
9150 /* Copy ABFD's program header table entries to *PHDRS. The entries
9151 will be stored as an array of Elf_Internal_Phdr structures, as
9152 defined in include/elf/internal.h. To find out how large the
9153 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9155 Return the number of program header table entries read, or -1 if an
9156 error occurs; bfd_get_error will return an appropriate code. */
9159 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
9163 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9165 bfd_set_error (bfd_error_wrong_format
);
9169 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
9170 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
9171 num_phdrs
* sizeof (Elf_Internal_Phdr
));
9176 enum elf_reloc_type_class
9177 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
9179 return reloc_class_normal
;
9182 /* For RELA architectures, return the relocation value for a
9183 relocation against a local symbol. */
9186 _bfd_elf_rela_local_sym (bfd
*abfd
,
9187 Elf_Internal_Sym
*sym
,
9189 Elf_Internal_Rela
*rel
)
9191 asection
*sec
= *psec
;
9194 relocation
= (sec
->output_section
->vma
9195 + sec
->output_offset
9197 if ((sec
->flags
& SEC_MERGE
)
9198 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
9199 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
9202 _bfd_merged_section_offset (abfd
, psec
,
9203 elf_section_data (sec
)->sec_info
,
9204 sym
->st_value
+ rel
->r_addend
);
9207 /* If we have changed the section, and our original section is
9208 marked with SEC_EXCLUDE, it means that the original
9209 SEC_MERGE section has been completely subsumed in some
9210 other SEC_MERGE section. In this case, we need to leave
9211 some info around for --emit-relocs. */
9212 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
9213 sec
->kept_section
= *psec
;
9216 rel
->r_addend
-= relocation
;
9217 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
9223 _bfd_elf_rel_local_sym (bfd
*abfd
,
9224 Elf_Internal_Sym
*sym
,
9228 asection
*sec
= *psec
;
9230 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
9231 return sym
->st_value
+ addend
;
9233 return _bfd_merged_section_offset (abfd
, psec
,
9234 elf_section_data (sec
)->sec_info
,
9235 sym
->st_value
+ addend
);
9239 _bfd_elf_section_offset (bfd
*abfd
,
9240 struct bfd_link_info
*info
,
9244 switch (sec
->sec_info_type
)
9246 case ELF_INFO_TYPE_STABS
:
9247 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
9249 case ELF_INFO_TYPE_EH_FRAME
:
9250 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
9256 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
9257 reconstruct an ELF file by reading the segments out of remote memory
9258 based on the ELF file header at EHDR_VMA and the ELF program headers it
9259 points to. If not null, *LOADBASEP is filled in with the difference
9260 between the VMAs from which the segments were read, and the VMAs the
9261 file headers (and hence BFD's idea of each section's VMA) put them at.
9263 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9264 remote memory at target address VMA into the local buffer at MYADDR; it
9265 should return zero on success or an `errno' code on failure. TEMPL must
9266 be a BFD for an ELF target with the word size and byte order found in
9267 the remote memory. */
9270 bfd_elf_bfd_from_remote_memory
9274 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
9276 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
9277 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
9281 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
9282 long symcount ATTRIBUTE_UNUSED
,
9283 asymbol
**syms ATTRIBUTE_UNUSED
,
9288 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
9291 const char *relplt_name
;
9292 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
9296 Elf_Internal_Shdr
*hdr
;
9302 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
9305 if (dynsymcount
<= 0)
9308 if (!bed
->plt_sym_val
)
9311 relplt_name
= bed
->relplt_name
;
9312 if (relplt_name
== NULL
)
9313 relplt_name
= bed
->rela_plts_and_copies_p
? ".rela.plt" : ".rel.plt";
9314 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
9318 hdr
= &elf_section_data (relplt
)->this_hdr
;
9319 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
9320 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
9323 plt
= bfd_get_section_by_name (abfd
, ".plt");
9327 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
9328 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
9331 count
= relplt
->size
/ hdr
->sh_entsize
;
9332 size
= count
* sizeof (asymbol
);
9333 p
= relplt
->relocation
;
9334 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
9336 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
9340 size
+= sizeof ("+0x") - 1 + 8 + 8 * (bed
->s
->elfclass
== ELFCLASS64
);
9342 size
+= sizeof ("+0x") - 1 + 8;
9347 s
= *ret
= (asymbol
*) bfd_malloc (size
);
9351 names
= (char *) (s
+ count
);
9352 p
= relplt
->relocation
;
9354 for (i
= 0; i
< count
; i
++, p
+= bed
->s
->int_rels_per_ext_rel
)
9359 addr
= bed
->plt_sym_val (i
, plt
, p
);
9360 if (addr
== (bfd_vma
) -1)
9363 *s
= **p
->sym_ptr_ptr
;
9364 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
9365 we are defining a symbol, ensure one of them is set. */
9366 if ((s
->flags
& BSF_LOCAL
) == 0)
9367 s
->flags
|= BSF_GLOBAL
;
9368 s
->flags
|= BSF_SYNTHETIC
;
9370 s
->value
= addr
- plt
->vma
;
9373 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
9374 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
9380 memcpy (names
, "+0x", sizeof ("+0x") - 1);
9381 names
+= sizeof ("+0x") - 1;
9382 bfd_sprintf_vma (abfd
, buf
, p
->addend
);
9383 for (a
= buf
; *a
== '0'; ++a
)
9386 memcpy (names
, a
, len
);
9389 memcpy (names
, "@plt", sizeof ("@plt"));
9390 names
+= sizeof ("@plt");
9397 /* It is only used by x86-64 so far. */
9398 asection _bfd_elf_large_com_section
9399 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
9400 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
9403 _bfd_elf_set_osabi (bfd
* abfd
,
9404 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
9406 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
9408 i_ehdrp
= elf_elfheader (abfd
);
9410 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
9412 /* To make things simpler for the loader on Linux systems we set the
9413 osabi field to ELFOSABI_LINUX if the binary contains symbols of
9414 the STT_GNU_IFUNC type. */
9415 if (i_ehdrp
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
9416 && elf_tdata (abfd
)->has_ifunc_symbols
)
9417 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_LINUX
;
9421 /* Return TRUE for ELF symbol types that represent functions.
9422 This is the default version of this function, which is sufficient for
9423 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
9426 _bfd_elf_is_function_type (unsigned int type
)
9428 return (type
== STT_FUNC
9429 || type
== STT_GNU_IFUNC
);