1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 BFD support for ELF formats is being worked on.
29 Currently, the best supported back ends are for sparc and i386
30 (running svr4 or Solaris 2).
32 Documentation of the internals of the support code still needs
33 to be written. The code is changing quickly enough that we
34 haven't bothered yet. */
36 /* For sparc64-cross-sparc32. */
44 #include "libiberty.h"
45 #include "safe-ctype.h"
47 static int elf_sort_sections (const void *, const void *);
48 static bfd_boolean
assign_file_positions_except_relocs (bfd
*, struct bfd_link_info
*);
49 static bfd_boolean
prep_headers (bfd
*);
50 static bfd_boolean
swap_out_syms (bfd
*, struct bfd_strtab_hash
**, int) ;
51 static bfd_boolean
elf_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
52 static bfd_boolean
elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
,
55 /* Swap version information in and out. The version information is
56 currently size independent. If that ever changes, this code will
57 need to move into elfcode.h. */
59 /* Swap in a Verdef structure. */
62 _bfd_elf_swap_verdef_in (bfd
*abfd
,
63 const Elf_External_Verdef
*src
,
64 Elf_Internal_Verdef
*dst
)
66 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
67 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
68 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
69 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
70 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
71 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
72 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
75 /* Swap out a Verdef structure. */
78 _bfd_elf_swap_verdef_out (bfd
*abfd
,
79 const Elf_Internal_Verdef
*src
,
80 Elf_External_Verdef
*dst
)
82 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
83 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
84 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
85 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
86 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
87 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
88 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
91 /* Swap in a Verdaux structure. */
94 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
95 const Elf_External_Verdaux
*src
,
96 Elf_Internal_Verdaux
*dst
)
98 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
99 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
102 /* Swap out a Verdaux structure. */
105 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
106 const Elf_Internal_Verdaux
*src
,
107 Elf_External_Verdaux
*dst
)
109 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
110 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
113 /* Swap in a Verneed structure. */
116 _bfd_elf_swap_verneed_in (bfd
*abfd
,
117 const Elf_External_Verneed
*src
,
118 Elf_Internal_Verneed
*dst
)
120 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
121 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
122 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
123 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
124 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
127 /* Swap out a Verneed structure. */
130 _bfd_elf_swap_verneed_out (bfd
*abfd
,
131 const Elf_Internal_Verneed
*src
,
132 Elf_External_Verneed
*dst
)
134 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
135 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
136 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
137 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
138 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
141 /* Swap in a Vernaux structure. */
144 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
145 const Elf_External_Vernaux
*src
,
146 Elf_Internal_Vernaux
*dst
)
148 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
149 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
150 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
151 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
152 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
155 /* Swap out a Vernaux structure. */
158 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
159 const Elf_Internal_Vernaux
*src
,
160 Elf_External_Vernaux
*dst
)
162 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
163 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
164 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
165 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
166 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
169 /* Swap in a Versym structure. */
172 _bfd_elf_swap_versym_in (bfd
*abfd
,
173 const Elf_External_Versym
*src
,
174 Elf_Internal_Versym
*dst
)
176 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
179 /* Swap out a Versym structure. */
182 _bfd_elf_swap_versym_out (bfd
*abfd
,
183 const Elf_Internal_Versym
*src
,
184 Elf_External_Versym
*dst
)
186 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
189 /* Standard ELF hash function. Do not change this function; you will
190 cause invalid hash tables to be generated. */
193 bfd_elf_hash (const char *namearg
)
195 const unsigned char *name
= (const unsigned char *) namearg
;
200 while ((ch
= *name
++) != '\0')
203 if ((g
= (h
& 0xf0000000)) != 0)
206 /* The ELF ABI says `h &= ~g', but this is equivalent in
207 this case and on some machines one insn instead of two. */
211 return h
& 0xffffffff;
214 /* DT_GNU_HASH hash function. Do not change this function; you will
215 cause invalid hash tables to be generated. */
218 bfd_elf_gnu_hash (const char *namearg
)
220 const unsigned char *name
= (const unsigned char *) namearg
;
221 unsigned long h
= 5381;
224 while ((ch
= *name
++) != '\0')
225 h
= (h
<< 5) + h
+ ch
;
226 return h
& 0xffffffff;
230 bfd_elf_mkobject (bfd
*abfd
)
232 if (abfd
->tdata
.any
== NULL
)
234 abfd
->tdata
.any
= bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
235 if (abfd
->tdata
.any
== NULL
)
239 elf_tdata (abfd
)->program_header_size
= (bfd_size_type
) -1;
245 bfd_elf_mkcorefile (bfd
*abfd
)
247 /* I think this can be done just like an object file. */
248 return bfd_elf_mkobject (abfd
);
252 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
254 Elf_Internal_Shdr
**i_shdrp
;
255 bfd_byte
*shstrtab
= NULL
;
257 bfd_size_type shstrtabsize
;
259 i_shdrp
= elf_elfsections (abfd
);
261 || shindex
>= elf_numsections (abfd
)
262 || i_shdrp
[shindex
] == 0)
265 shstrtab
= i_shdrp
[shindex
]->contents
;
266 if (shstrtab
== NULL
)
268 /* No cached one, attempt to read, and cache what we read. */
269 offset
= i_shdrp
[shindex
]->sh_offset
;
270 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
272 /* Allocate and clear an extra byte at the end, to prevent crashes
273 in case the string table is not terminated. */
274 if (shstrtabsize
+ 1 == 0
275 || (shstrtab
= bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
276 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
278 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
280 if (bfd_get_error () != bfd_error_system_call
)
281 bfd_set_error (bfd_error_file_truncated
);
285 shstrtab
[shstrtabsize
] = '\0';
286 i_shdrp
[shindex
]->contents
= shstrtab
;
288 return (char *) shstrtab
;
292 bfd_elf_string_from_elf_section (bfd
*abfd
,
293 unsigned int shindex
,
294 unsigned int strindex
)
296 Elf_Internal_Shdr
*hdr
;
301 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
304 hdr
= elf_elfsections (abfd
)[shindex
];
306 if (hdr
->contents
== NULL
307 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
310 if (strindex
>= hdr
->sh_size
)
312 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
313 (*_bfd_error_handler
)
314 (_("%B: invalid string offset %u >= %lu for section `%s'"),
315 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
316 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
318 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
322 return ((char *) hdr
->contents
) + strindex
;
325 /* Read and convert symbols to internal format.
326 SYMCOUNT specifies the number of symbols to read, starting from
327 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
328 are non-NULL, they are used to store the internal symbols, external
329 symbols, and symbol section index extensions, respectively. */
332 bfd_elf_get_elf_syms (bfd
*ibfd
,
333 Elf_Internal_Shdr
*symtab_hdr
,
336 Elf_Internal_Sym
*intsym_buf
,
338 Elf_External_Sym_Shndx
*extshndx_buf
)
340 Elf_Internal_Shdr
*shndx_hdr
;
342 const bfd_byte
*esym
;
343 Elf_External_Sym_Shndx
*alloc_extshndx
;
344 Elf_External_Sym_Shndx
*shndx
;
345 Elf_Internal_Sym
*isym
;
346 Elf_Internal_Sym
*isymend
;
347 const struct elf_backend_data
*bed
;
355 /* Normal syms might have section extension entries. */
357 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
358 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
360 /* Read the symbols. */
362 alloc_extshndx
= NULL
;
363 bed
= get_elf_backend_data (ibfd
);
364 extsym_size
= bed
->s
->sizeof_sym
;
365 amt
= symcount
* extsym_size
;
366 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
367 if (extsym_buf
== NULL
)
369 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
370 extsym_buf
= alloc_ext
;
372 if (extsym_buf
== NULL
373 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
374 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
380 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
384 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
385 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
386 if (extshndx_buf
== NULL
)
388 alloc_extshndx
= bfd_malloc2 (symcount
,
389 sizeof (Elf_External_Sym_Shndx
));
390 extshndx_buf
= alloc_extshndx
;
392 if (extshndx_buf
== NULL
393 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
394 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
401 if (intsym_buf
== NULL
)
403 intsym_buf
= bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
404 if (intsym_buf
== NULL
)
408 /* Convert the symbols to internal form. */
409 isymend
= intsym_buf
+ symcount
;
410 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
412 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
413 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
415 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
416 (*_bfd_error_handler
) (_("%B symbol number %lu references "
417 "nonexistent SHT_SYMTAB_SHNDX section"),
418 ibfd
, (unsigned long) symoffset
);
424 if (alloc_ext
!= NULL
)
426 if (alloc_extshndx
!= NULL
)
427 free (alloc_extshndx
);
432 /* Look up a symbol name. */
434 bfd_elf_sym_name (bfd
*abfd
,
435 Elf_Internal_Shdr
*symtab_hdr
,
436 Elf_Internal_Sym
*isym
,
440 unsigned int iname
= isym
->st_name
;
441 unsigned int shindex
= symtab_hdr
->sh_link
;
443 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
444 /* Check for a bogus st_shndx to avoid crashing. */
445 && isym
->st_shndx
< elf_numsections (abfd
)
446 && !(isym
->st_shndx
>= SHN_LORESERVE
&& isym
->st_shndx
<= SHN_HIRESERVE
))
448 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
449 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
452 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
455 else if (sym_sec
&& *name
== '\0')
456 name
= bfd_section_name (abfd
, sym_sec
);
461 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
462 sections. The first element is the flags, the rest are section
465 typedef union elf_internal_group
{
466 Elf_Internal_Shdr
*shdr
;
468 } Elf_Internal_Group
;
470 /* Return the name of the group signature symbol. Why isn't the
471 signature just a string? */
474 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
476 Elf_Internal_Shdr
*hdr
;
477 unsigned char esym
[sizeof (Elf64_External_Sym
)];
478 Elf_External_Sym_Shndx eshndx
;
479 Elf_Internal_Sym isym
;
481 /* First we need to ensure the symbol table is available. Make sure
482 that it is a symbol table section. */
483 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
484 if (hdr
->sh_type
!= SHT_SYMTAB
485 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
488 /* Go read the symbol. */
489 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
490 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
491 &isym
, esym
, &eshndx
) == NULL
)
494 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
497 /* Set next_in_group list pointer, and group name for NEWSECT. */
500 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
502 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
504 /* If num_group is zero, read in all SHT_GROUP sections. The count
505 is set to -1 if there are no SHT_GROUP sections. */
508 unsigned int i
, shnum
;
510 /* First count the number of groups. If we have a SHT_GROUP
511 section with just a flag word (ie. sh_size is 4), ignore it. */
512 shnum
= elf_numsections (abfd
);
515 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
516 ( (shdr)->sh_type == SHT_GROUP \
517 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
518 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
519 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
521 for (i
= 0; i
< shnum
; i
++)
523 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
525 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
531 num_group
= (unsigned) -1;
532 elf_tdata (abfd
)->num_group
= num_group
;
536 /* We keep a list of elf section headers for group sections,
537 so we can find them quickly. */
540 elf_tdata (abfd
)->num_group
= num_group
;
541 elf_tdata (abfd
)->group_sect_ptr
542 = bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
543 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
547 for (i
= 0; i
< shnum
; i
++)
549 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
551 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
554 Elf_Internal_Group
*dest
;
556 /* Add to list of sections. */
557 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
560 /* Read the raw contents. */
561 BFD_ASSERT (sizeof (*dest
) >= 4);
562 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
563 shdr
->contents
= bfd_alloc2 (abfd
, shdr
->sh_size
,
565 /* PR binutils/4110: Handle corrupt group headers. */
566 if (shdr
->contents
== NULL
)
569 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
570 bfd_set_error (bfd_error_bad_value
);
574 memset (shdr
->contents
, 0, amt
);
576 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
577 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
581 /* Translate raw contents, a flag word followed by an
582 array of elf section indices all in target byte order,
583 to the flag word followed by an array of elf section
585 src
= shdr
->contents
+ shdr
->sh_size
;
586 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
593 idx
= H_GET_32 (abfd
, src
);
594 if (src
== shdr
->contents
)
597 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
598 shdr
->bfd_section
->flags
599 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
604 ((*_bfd_error_handler
)
605 (_("%B: invalid SHT_GROUP entry"), abfd
));
608 dest
->shdr
= elf_elfsections (abfd
)[idx
];
615 if (num_group
!= (unsigned) -1)
619 for (i
= 0; i
< num_group
; i
++)
621 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
622 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
623 unsigned int n_elt
= shdr
->sh_size
/ 4;
625 /* Look through this group's sections to see if current
626 section is a member. */
628 if ((++idx
)->shdr
== hdr
)
632 /* We are a member of this group. Go looking through
633 other members to see if any others are linked via
635 idx
= (Elf_Internal_Group
*) shdr
->contents
;
636 n_elt
= shdr
->sh_size
/ 4;
638 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
639 && elf_next_in_group (s
) != NULL
)
643 /* Snarf the group name from other member, and
644 insert current section in circular list. */
645 elf_group_name (newsect
) = elf_group_name (s
);
646 elf_next_in_group (newsect
) = elf_next_in_group (s
);
647 elf_next_in_group (s
) = newsect
;
653 gname
= group_signature (abfd
, shdr
);
656 elf_group_name (newsect
) = gname
;
658 /* Start a circular list with one element. */
659 elf_next_in_group (newsect
) = newsect
;
662 /* If the group section has been created, point to the
664 if (shdr
->bfd_section
!= NULL
)
665 elf_next_in_group (shdr
->bfd_section
) = newsect
;
673 if (elf_group_name (newsect
) == NULL
)
675 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
682 _bfd_elf_setup_sections (bfd
*abfd
)
685 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
686 bfd_boolean result
= TRUE
;
689 /* Process SHF_LINK_ORDER. */
690 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
692 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
693 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
695 unsigned int elfsec
= this_hdr
->sh_link
;
696 /* FIXME: The old Intel compiler and old strip/objcopy may
697 not set the sh_link or sh_info fields. Hence we could
698 get the situation where elfsec is 0. */
701 const struct elf_backend_data
*bed
702 = get_elf_backend_data (abfd
);
703 if (bed
->link_order_error_handler
)
704 bed
->link_order_error_handler
705 (_("%B: warning: sh_link not set for section `%A'"),
712 this_hdr
= elf_elfsections (abfd
)[elfsec
];
715 Some strip/objcopy may leave an incorrect value in
716 sh_link. We don't want to proceed. */
717 link
= this_hdr
->bfd_section
;
720 (*_bfd_error_handler
)
721 (_("%B: sh_link [%d] in section `%A' is incorrect"),
722 s
->owner
, s
, elfsec
);
726 elf_linked_to_section (s
) = link
;
731 /* Process section groups. */
732 if (num_group
== (unsigned) -1)
735 for (i
= 0; i
< num_group
; i
++)
737 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
738 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
739 unsigned int n_elt
= shdr
->sh_size
/ 4;
742 if ((++idx
)->shdr
->bfd_section
)
743 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
744 else if (idx
->shdr
->sh_type
== SHT_RELA
745 || idx
->shdr
->sh_type
== SHT_REL
)
746 /* We won't include relocation sections in section groups in
747 output object files. We adjust the group section size here
748 so that relocatable link will work correctly when
749 relocation sections are in section group in input object
751 shdr
->bfd_section
->size
-= 4;
754 /* There are some unknown sections in the group. */
755 (*_bfd_error_handler
)
756 (_("%B: unknown [%d] section `%s' in group [%s]"),
758 (unsigned int) idx
->shdr
->sh_type
,
759 bfd_elf_string_from_elf_section (abfd
,
760 (elf_elfheader (abfd
)
763 shdr
->bfd_section
->name
);
771 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
773 return elf_next_in_group (sec
) != NULL
;
776 /* Make a BFD section from an ELF section. We store a pointer to the
777 BFD section in the bfd_section field of the header. */
780 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
781 Elf_Internal_Shdr
*hdr
,
787 const struct elf_backend_data
*bed
;
789 if (hdr
->bfd_section
!= NULL
)
791 BFD_ASSERT (strcmp (name
,
792 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
796 newsect
= bfd_make_section_anyway (abfd
, name
);
800 hdr
->bfd_section
= newsect
;
801 elf_section_data (newsect
)->this_hdr
= *hdr
;
802 elf_section_data (newsect
)->this_idx
= shindex
;
804 /* Always use the real type/flags. */
805 elf_section_type (newsect
) = hdr
->sh_type
;
806 elf_section_flags (newsect
) = hdr
->sh_flags
;
808 newsect
->filepos
= hdr
->sh_offset
;
810 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
811 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
812 || ! bfd_set_section_alignment (abfd
, newsect
,
813 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
816 flags
= SEC_NO_FLAGS
;
817 if (hdr
->sh_type
!= SHT_NOBITS
)
818 flags
|= SEC_HAS_CONTENTS
;
819 if (hdr
->sh_type
== SHT_GROUP
)
820 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
821 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
824 if (hdr
->sh_type
!= SHT_NOBITS
)
827 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
828 flags
|= SEC_READONLY
;
829 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
831 else if ((flags
& SEC_LOAD
) != 0)
833 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
836 newsect
->entsize
= hdr
->sh_entsize
;
837 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
838 flags
|= SEC_STRINGS
;
840 if (hdr
->sh_flags
& SHF_GROUP
)
841 if (!setup_group (abfd
, hdr
, newsect
))
843 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
844 flags
|= SEC_THREAD_LOCAL
;
846 if ((flags
& SEC_ALLOC
) == 0)
848 /* The debugging sections appear to be recognized only by name,
849 not any sort of flag. Their SEC_ALLOC bits are cleared. */
854 } debug_sections
[] =
856 { STRING_COMMA_LEN ("debug") }, /* 'd' */
857 { NULL
, 0 }, /* 'e' */
858 { NULL
, 0 }, /* 'f' */
859 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
860 { NULL
, 0 }, /* 'h' */
861 { NULL
, 0 }, /* 'i' */
862 { NULL
, 0 }, /* 'j' */
863 { NULL
, 0 }, /* 'k' */
864 { STRING_COMMA_LEN ("line") }, /* 'l' */
865 { NULL
, 0 }, /* 'm' */
866 { NULL
, 0 }, /* 'n' */
867 { NULL
, 0 }, /* 'o' */
868 { NULL
, 0 }, /* 'p' */
869 { NULL
, 0 }, /* 'q' */
870 { NULL
, 0 }, /* 'r' */
871 { STRING_COMMA_LEN ("stab") } /* 's' */
876 int i
= name
[1] - 'd';
878 && i
< (int) ARRAY_SIZE (debug_sections
)
879 && debug_sections
[i
].name
!= NULL
880 && strncmp (&name
[1], debug_sections
[i
].name
,
881 debug_sections
[i
].len
) == 0)
882 flags
|= SEC_DEBUGGING
;
886 /* As a GNU extension, if the name begins with .gnu.linkonce, we
887 only link a single copy of the section. This is used to support
888 g++. g++ will emit each template expansion in its own section.
889 The symbols will be defined as weak, so that multiple definitions
890 are permitted. The GNU linker extension is to actually discard
891 all but one of the sections. */
892 if (CONST_STRNEQ (name
, ".gnu.linkonce")
893 && elf_next_in_group (newsect
) == NULL
)
894 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
896 bed
= get_elf_backend_data (abfd
);
897 if (bed
->elf_backend_section_flags
)
898 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
901 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
904 /* We do not parse the PT_NOTE segments as we are interested even in the
905 separate debug info files which may have the segments offsets corrupted.
906 PT_NOTEs from the core files are currently not parsed using BFD. */
907 if (hdr
->sh_type
== SHT_NOTE
)
911 contents
= bfd_malloc (hdr
->sh_size
);
915 if (!bfd_get_section_contents (abfd
, hdr
->bfd_section
, contents
, 0,
917 || !elf_parse_notes (abfd
, contents
, hdr
->sh_size
, -1))
926 if ((flags
& SEC_ALLOC
) != 0)
928 Elf_Internal_Phdr
*phdr
;
931 /* Look through the phdrs to see if we need to adjust the lma.
932 If all the p_paddr fields are zero, we ignore them, since
933 some ELF linkers produce such output. */
934 phdr
= elf_tdata (abfd
)->phdr
;
935 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
937 if (phdr
->p_paddr
!= 0)
940 if (i
< elf_elfheader (abfd
)->e_phnum
)
942 phdr
= elf_tdata (abfd
)->phdr
;
943 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
945 /* This section is part of this segment if its file
946 offset plus size lies within the segment's memory
947 span and, if the section is loaded, the extent of the
948 loaded data lies within the extent of the segment.
950 Note - we used to check the p_paddr field as well, and
951 refuse to set the LMA if it was 0. This is wrong
952 though, as a perfectly valid initialised segment can
953 have a p_paddr of zero. Some architectures, eg ARM,
954 place special significance on the address 0 and
955 executables need to be able to have a segment which
956 covers this address. */
957 if (phdr
->p_type
== PT_LOAD
958 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
959 && (hdr
->sh_offset
+ hdr
->sh_size
960 <= phdr
->p_offset
+ phdr
->p_memsz
)
961 && ((flags
& SEC_LOAD
) == 0
962 || (hdr
->sh_offset
+ hdr
->sh_size
963 <= phdr
->p_offset
+ phdr
->p_filesz
)))
965 if ((flags
& SEC_LOAD
) == 0)
966 newsect
->lma
= (phdr
->p_paddr
967 + hdr
->sh_addr
- phdr
->p_vaddr
);
969 /* We used to use the same adjustment for SEC_LOAD
970 sections, but that doesn't work if the segment
971 is packed with code from multiple VMAs.
972 Instead we calculate the section LMA based on
973 the segment LMA. It is assumed that the
974 segment will contain sections with contiguous
975 LMAs, even if the VMAs are not. */
976 newsect
->lma
= (phdr
->p_paddr
977 + hdr
->sh_offset
- phdr
->p_offset
);
979 /* With contiguous segments, we can't tell from file
980 offsets whether a section with zero size should
981 be placed at the end of one segment or the
982 beginning of the next. Decide based on vaddr. */
983 if (hdr
->sh_addr
>= phdr
->p_vaddr
984 && (hdr
->sh_addr
+ hdr
->sh_size
985 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
1000 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
1003 Helper functions for GDB to locate the string tables.
1004 Since BFD hides string tables from callers, GDB needs to use an
1005 internal hook to find them. Sun's .stabstr, in particular,
1006 isn't even pointed to by the .stab section, so ordinary
1007 mechanisms wouldn't work to find it, even if we had some.
1010 struct elf_internal_shdr
*
1011 bfd_elf_find_section (bfd
*abfd
, char *name
)
1013 Elf_Internal_Shdr
**i_shdrp
;
1018 i_shdrp
= elf_elfsections (abfd
);
1019 if (i_shdrp
!= NULL
)
1021 shstrtab
= bfd_elf_get_str_section (abfd
,
1022 elf_elfheader (abfd
)->e_shstrndx
);
1023 if (shstrtab
!= NULL
)
1025 max
= elf_numsections (abfd
);
1026 for (i
= 1; i
< max
; i
++)
1027 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
1034 const char *const bfd_elf_section_type_names
[] = {
1035 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1036 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1037 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1040 /* ELF relocs are against symbols. If we are producing relocatable
1041 output, and the reloc is against an external symbol, and nothing
1042 has given us any additional addend, the resulting reloc will also
1043 be against the same symbol. In such a case, we don't want to
1044 change anything about the way the reloc is handled, since it will
1045 all be done at final link time. Rather than put special case code
1046 into bfd_perform_relocation, all the reloc types use this howto
1047 function. It just short circuits the reloc if producing
1048 relocatable output against an external symbol. */
1050 bfd_reloc_status_type
1051 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1052 arelent
*reloc_entry
,
1054 void *data ATTRIBUTE_UNUSED
,
1055 asection
*input_section
,
1057 char **error_message ATTRIBUTE_UNUSED
)
1059 if (output_bfd
!= NULL
1060 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1061 && (! reloc_entry
->howto
->partial_inplace
1062 || reloc_entry
->addend
== 0))
1064 reloc_entry
->address
+= input_section
->output_offset
;
1065 return bfd_reloc_ok
;
1068 return bfd_reloc_continue
;
1071 /* Copy the program header and other data from one object module to
1075 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1077 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1078 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1081 BFD_ASSERT (!elf_flags_init (obfd
)
1082 || (elf_elfheader (obfd
)->e_flags
1083 == elf_elfheader (ibfd
)->e_flags
));
1085 elf_gp (obfd
) = elf_gp (ibfd
);
1086 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1087 elf_flags_init (obfd
) = TRUE
;
1089 /* Copy object attributes. */
1090 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1096 get_segment_type (unsigned int p_type
)
1101 case PT_NULL
: pt
= "NULL"; break;
1102 case PT_LOAD
: pt
= "LOAD"; break;
1103 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1104 case PT_INTERP
: pt
= "INTERP"; break;
1105 case PT_NOTE
: pt
= "NOTE"; break;
1106 case PT_SHLIB
: pt
= "SHLIB"; break;
1107 case PT_PHDR
: pt
= "PHDR"; break;
1108 case PT_TLS
: pt
= "TLS"; break;
1109 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1110 case PT_GNU_STACK
: pt
= "STACK"; break;
1111 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1112 default: pt
= NULL
; break;
1117 /* Print out the program headers. */
1120 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1123 Elf_Internal_Phdr
*p
;
1125 bfd_byte
*dynbuf
= NULL
;
1127 p
= elf_tdata (abfd
)->phdr
;
1132 fprintf (f
, _("\nProgram Header:\n"));
1133 c
= elf_elfheader (abfd
)->e_phnum
;
1134 for (i
= 0; i
< c
; i
++, p
++)
1136 const char *pt
= get_segment_type (p
->p_type
);
1141 sprintf (buf
, "0x%lx", p
->p_type
);
1144 fprintf (f
, "%8s off 0x", pt
);
1145 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1146 fprintf (f
, " vaddr 0x");
1147 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1148 fprintf (f
, " paddr 0x");
1149 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1150 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1151 fprintf (f
, " filesz 0x");
1152 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1153 fprintf (f
, " memsz 0x");
1154 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1155 fprintf (f
, " flags %c%c%c",
1156 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1157 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1158 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1159 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1160 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1165 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1169 unsigned long shlink
;
1170 bfd_byte
*extdyn
, *extdynend
;
1172 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1174 fprintf (f
, _("\nDynamic Section:\n"));
1176 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1179 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1182 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1184 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1185 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1188 extdynend
= extdyn
+ s
->size
;
1189 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1191 Elf_Internal_Dyn dyn
;
1194 bfd_boolean stringp
;
1196 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1198 if (dyn
.d_tag
== DT_NULL
)
1205 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1209 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1210 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1211 case DT_PLTGOT
: name
= "PLTGOT"; break;
1212 case DT_HASH
: name
= "HASH"; break;
1213 case DT_STRTAB
: name
= "STRTAB"; break;
1214 case DT_SYMTAB
: name
= "SYMTAB"; break;
1215 case DT_RELA
: name
= "RELA"; break;
1216 case DT_RELASZ
: name
= "RELASZ"; break;
1217 case DT_RELAENT
: name
= "RELAENT"; break;
1218 case DT_STRSZ
: name
= "STRSZ"; break;
1219 case DT_SYMENT
: name
= "SYMENT"; break;
1220 case DT_INIT
: name
= "INIT"; break;
1221 case DT_FINI
: name
= "FINI"; break;
1222 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1223 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1224 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1225 case DT_REL
: name
= "REL"; break;
1226 case DT_RELSZ
: name
= "RELSZ"; break;
1227 case DT_RELENT
: name
= "RELENT"; break;
1228 case DT_PLTREL
: name
= "PLTREL"; break;
1229 case DT_DEBUG
: name
= "DEBUG"; break;
1230 case DT_TEXTREL
: name
= "TEXTREL"; break;
1231 case DT_JMPREL
: name
= "JMPREL"; break;
1232 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1233 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1234 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1235 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1236 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1237 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1238 case DT_FLAGS
: name
= "FLAGS"; break;
1239 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1240 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1241 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1242 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1243 case DT_MOVEENT
: name
= "MOVEENT"; break;
1244 case DT_MOVESZ
: name
= "MOVESZ"; break;
1245 case DT_FEATURE
: name
= "FEATURE"; break;
1246 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1247 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1248 case DT_SYMINENT
: name
= "SYMINENT"; break;
1249 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1250 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1251 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1252 case DT_PLTPAD
: name
= "PLTPAD"; break;
1253 case DT_MOVETAB
: name
= "MOVETAB"; break;
1254 case DT_SYMINFO
: name
= "SYMINFO"; break;
1255 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1256 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1257 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1258 case DT_VERSYM
: name
= "VERSYM"; break;
1259 case DT_VERDEF
: name
= "VERDEF"; break;
1260 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1261 case DT_VERNEED
: name
= "VERNEED"; break;
1262 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1263 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1264 case DT_USED
: name
= "USED"; break;
1265 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1266 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1269 fprintf (f
, " %-11s ", name
);
1271 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1275 unsigned int tagv
= dyn
.d_un
.d_val
;
1277 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1280 fprintf (f
, "%s", string
);
1289 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1290 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1292 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1296 if (elf_dynverdef (abfd
) != 0)
1298 Elf_Internal_Verdef
*t
;
1300 fprintf (f
, _("\nVersion definitions:\n"));
1301 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1303 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1304 t
->vd_flags
, t
->vd_hash
,
1305 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1306 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1308 Elf_Internal_Verdaux
*a
;
1311 for (a
= t
->vd_auxptr
->vda_nextptr
;
1315 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1321 if (elf_dynverref (abfd
) != 0)
1323 Elf_Internal_Verneed
*t
;
1325 fprintf (f
, _("\nVersion References:\n"));
1326 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1328 Elf_Internal_Vernaux
*a
;
1330 fprintf (f
, _(" required from %s:\n"),
1331 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1332 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1333 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1334 a
->vna_flags
, a
->vna_other
,
1335 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1347 /* Display ELF-specific fields of a symbol. */
1350 bfd_elf_print_symbol (bfd
*abfd
,
1353 bfd_print_symbol_type how
)
1358 case bfd_print_symbol_name
:
1359 fprintf (file
, "%s", symbol
->name
);
1361 case bfd_print_symbol_more
:
1362 fprintf (file
, "elf ");
1363 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1364 fprintf (file
, " %lx", (long) symbol
->flags
);
1366 case bfd_print_symbol_all
:
1368 const char *section_name
;
1369 const char *name
= NULL
;
1370 const struct elf_backend_data
*bed
;
1371 unsigned char st_other
;
1374 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1376 bed
= get_elf_backend_data (abfd
);
1377 if (bed
->elf_backend_print_symbol_all
)
1378 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1382 name
= symbol
->name
;
1383 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1386 fprintf (file
, " %s\t", section_name
);
1387 /* Print the "other" value for a symbol. For common symbols,
1388 we've already printed the size; now print the alignment.
1389 For other symbols, we have no specified alignment, and
1390 we've printed the address; now print the size. */
1391 if (symbol
->section
&& bfd_is_com_section (symbol
->section
))
1392 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1394 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1395 bfd_fprintf_vma (abfd
, file
, val
);
1397 /* If we have version information, print it. */
1398 if (elf_tdata (abfd
)->dynversym_section
!= 0
1399 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1400 || elf_tdata (abfd
)->dynverref_section
!= 0))
1402 unsigned int vernum
;
1403 const char *version_string
;
1405 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1408 version_string
= "";
1409 else if (vernum
== 1)
1410 version_string
= "Base";
1411 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1413 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1416 Elf_Internal_Verneed
*t
;
1418 version_string
= "";
1419 for (t
= elf_tdata (abfd
)->verref
;
1423 Elf_Internal_Vernaux
*a
;
1425 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1427 if (a
->vna_other
== vernum
)
1429 version_string
= a
->vna_nodename
;
1436 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1437 fprintf (file
, " %-11s", version_string
);
1442 fprintf (file
, " (%s)", version_string
);
1443 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1448 /* If the st_other field is not zero, print it. */
1449 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1454 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1455 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1456 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1458 /* Some other non-defined flags are also present, so print
1460 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1463 fprintf (file
, " %s", name
);
1469 /* Allocate an ELF string table--force the first byte to be zero. */
1471 struct bfd_strtab_hash
*
1472 _bfd_elf_stringtab_init (void)
1474 struct bfd_strtab_hash
*ret
;
1476 ret
= _bfd_stringtab_init ();
1481 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1482 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1483 if (loc
== (bfd_size_type
) -1)
1485 _bfd_stringtab_free (ret
);
1492 /* ELF .o/exec file reading */
1494 /* Create a new bfd section from an ELF section header. */
1497 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1499 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1500 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1501 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1504 name
= bfd_elf_string_from_elf_section (abfd
,
1505 elf_elfheader (abfd
)->e_shstrndx
,
1510 switch (hdr
->sh_type
)
1513 /* Inactive section. Throw it away. */
1516 case SHT_PROGBITS
: /* Normal section with contents. */
1517 case SHT_NOBITS
: /* .bss section. */
1518 case SHT_HASH
: /* .hash section. */
1519 case SHT_NOTE
: /* .note section. */
1520 case SHT_INIT_ARRAY
: /* .init_array section. */
1521 case SHT_FINI_ARRAY
: /* .fini_array section. */
1522 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1523 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1524 case SHT_GNU_HASH
: /* .gnu.hash section. */
1525 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1527 case SHT_DYNAMIC
: /* Dynamic linking information. */
1528 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1530 if (hdr
->sh_link
> elf_numsections (abfd
)
1531 || elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1533 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1535 Elf_Internal_Shdr
*dynsymhdr
;
1537 /* The shared libraries distributed with hpux11 have a bogus
1538 sh_link field for the ".dynamic" section. Find the
1539 string table for the ".dynsym" section instead. */
1540 if (elf_dynsymtab (abfd
) != 0)
1542 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1543 hdr
->sh_link
= dynsymhdr
->sh_link
;
1547 unsigned int i
, num_sec
;
1549 num_sec
= elf_numsections (abfd
);
1550 for (i
= 1; i
< num_sec
; i
++)
1552 dynsymhdr
= elf_elfsections (abfd
)[i
];
1553 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1555 hdr
->sh_link
= dynsymhdr
->sh_link
;
1563 case SHT_SYMTAB
: /* A symbol table */
1564 if (elf_onesymtab (abfd
) == shindex
)
1567 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1569 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1570 elf_onesymtab (abfd
) = shindex
;
1571 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1572 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1573 abfd
->flags
|= HAS_SYMS
;
1575 /* Sometimes a shared object will map in the symbol table. If
1576 SHF_ALLOC is set, and this is a shared object, then we also
1577 treat this section as a BFD section. We can not base the
1578 decision purely on SHF_ALLOC, because that flag is sometimes
1579 set in a relocatable object file, which would confuse the
1581 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1582 && (abfd
->flags
& DYNAMIC
) != 0
1583 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1587 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1588 can't read symbols without that section loaded as well. It
1589 is most likely specified by the next section header. */
1590 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1592 unsigned int i
, num_sec
;
1594 num_sec
= elf_numsections (abfd
);
1595 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1597 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1598 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1599 && hdr2
->sh_link
== shindex
)
1603 for (i
= 1; i
< shindex
; i
++)
1605 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1606 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1607 && hdr2
->sh_link
== shindex
)
1611 return bfd_section_from_shdr (abfd
, i
);
1615 case SHT_DYNSYM
: /* A dynamic symbol table */
1616 if (elf_dynsymtab (abfd
) == shindex
)
1619 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1621 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1622 elf_dynsymtab (abfd
) = shindex
;
1623 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1624 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1625 abfd
->flags
|= HAS_SYMS
;
1627 /* Besides being a symbol table, we also treat this as a regular
1628 section, so that objcopy can handle it. */
1629 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1631 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1632 if (elf_symtab_shndx (abfd
) == shindex
)
1635 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1636 elf_symtab_shndx (abfd
) = shindex
;
1637 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1638 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1641 case SHT_STRTAB
: /* A string table */
1642 if (hdr
->bfd_section
!= NULL
)
1644 if (ehdr
->e_shstrndx
== shindex
)
1646 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1647 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1650 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1653 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1654 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
1657 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
1660 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1661 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
1662 elf_elfsections (abfd
)[shindex
] = hdr
;
1663 /* We also treat this as a regular section, so that objcopy
1665 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1669 /* If the string table isn't one of the above, then treat it as a
1670 regular section. We need to scan all the headers to be sure,
1671 just in case this strtab section appeared before the above. */
1672 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
1674 unsigned int i
, num_sec
;
1676 num_sec
= elf_numsections (abfd
);
1677 for (i
= 1; i
< num_sec
; i
++)
1679 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1680 if (hdr2
->sh_link
== shindex
)
1682 /* Prevent endless recursion on broken objects. */
1685 if (! bfd_section_from_shdr (abfd
, i
))
1687 if (elf_onesymtab (abfd
) == i
)
1689 if (elf_dynsymtab (abfd
) == i
)
1690 goto dynsymtab_strtab
;
1694 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1698 /* *These* do a lot of work -- but build no sections! */
1700 asection
*target_sect
;
1701 Elf_Internal_Shdr
*hdr2
;
1702 unsigned int num_sec
= elf_numsections (abfd
);
1705 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
1706 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
1709 /* Check for a bogus link to avoid crashing. */
1710 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
1711 || hdr
->sh_link
>= num_sec
)
1713 ((*_bfd_error_handler
)
1714 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1715 abfd
, hdr
->sh_link
, name
, shindex
));
1716 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1720 /* For some incomprehensible reason Oracle distributes
1721 libraries for Solaris in which some of the objects have
1722 bogus sh_link fields. It would be nice if we could just
1723 reject them, but, unfortunately, some people need to use
1724 them. We scan through the section headers; if we find only
1725 one suitable symbol table, we clobber the sh_link to point
1726 to it. I hope this doesn't break anything. */
1727 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1728 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1734 for (scan
= 1; scan
< num_sec
; scan
++)
1736 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1737 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1748 hdr
->sh_link
= found
;
1751 /* Get the symbol table. */
1752 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1753 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
1754 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1757 /* If this reloc section does not use the main symbol table we
1758 don't treat it as a reloc section. BFD can't adequately
1759 represent such a section, so at least for now, we don't
1760 try. We just present it as a normal section. We also
1761 can't use it as a reloc section if it points to the null
1762 section, an invalid section, or another reloc section. */
1763 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
1764 || hdr
->sh_info
== SHN_UNDEF
1765 || (hdr
->sh_info
>= SHN_LORESERVE
&& hdr
->sh_info
<= SHN_HIRESERVE
)
1766 || hdr
->sh_info
>= num_sec
1767 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
1768 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
1769 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1772 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1774 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1775 if (target_sect
== NULL
)
1778 if ((target_sect
->flags
& SEC_RELOC
) == 0
1779 || target_sect
->reloc_count
== 0)
1780 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1784 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1785 amt
= sizeof (*hdr2
);
1786 hdr2
= bfd_alloc (abfd
, amt
);
1787 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1790 elf_elfsections (abfd
)[shindex
] = hdr2
;
1791 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
1792 target_sect
->flags
|= SEC_RELOC
;
1793 target_sect
->relocation
= NULL
;
1794 target_sect
->rel_filepos
= hdr
->sh_offset
;
1795 /* In the section to which the relocations apply, mark whether
1796 its relocations are of the REL or RELA variety. */
1797 if (hdr
->sh_size
!= 0)
1798 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
1799 abfd
->flags
|= HAS_RELOC
;
1803 case SHT_GNU_verdef
:
1804 elf_dynverdef (abfd
) = shindex
;
1805 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1806 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1808 case SHT_GNU_versym
:
1809 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
1811 elf_dynversym (abfd
) = shindex
;
1812 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1813 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1815 case SHT_GNU_verneed
:
1816 elf_dynverref (abfd
) = shindex
;
1817 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1818 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1824 /* We need a BFD section for objcopy and relocatable linking,
1825 and it's handy to have the signature available as the section
1827 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
1829 name
= group_signature (abfd
, hdr
);
1832 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1834 if (hdr
->contents
!= NULL
)
1836 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
1837 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
1840 if (idx
->flags
& GRP_COMDAT
)
1841 hdr
->bfd_section
->flags
1842 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1844 /* We try to keep the same section order as it comes in. */
1846 while (--n_elt
!= 0)
1850 if (idx
->shdr
!= NULL
1851 && (s
= idx
->shdr
->bfd_section
) != NULL
1852 && elf_next_in_group (s
) != NULL
)
1854 elf_next_in_group (hdr
->bfd_section
) = s
;
1862 /* Possibly an attributes section. */
1863 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
1864 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
1866 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1868 _bfd_elf_parse_attributes (abfd
, hdr
);
1872 /* Check for any processor-specific section types. */
1873 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
1876 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
1878 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
1879 /* FIXME: How to properly handle allocated section reserved
1880 for applications? */
1881 (*_bfd_error_handler
)
1882 (_("%B: don't know how to handle allocated, application "
1883 "specific section `%s' [0x%8x]"),
1884 abfd
, name
, hdr
->sh_type
);
1886 /* Allow sections reserved for applications. */
1887 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1890 else if (hdr
->sh_type
>= SHT_LOPROC
1891 && hdr
->sh_type
<= SHT_HIPROC
)
1892 /* FIXME: We should handle this section. */
1893 (*_bfd_error_handler
)
1894 (_("%B: don't know how to handle processor specific section "
1896 abfd
, name
, hdr
->sh_type
);
1897 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
1899 /* Unrecognised OS-specific sections. */
1900 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
1901 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1902 required to correctly process the section and the file should
1903 be rejected with an error message. */
1904 (*_bfd_error_handler
)
1905 (_("%B: don't know how to handle OS specific section "
1907 abfd
, name
, hdr
->sh_type
);
1909 /* Otherwise it should be processed. */
1910 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1913 /* FIXME: We should handle this section. */
1914 (*_bfd_error_handler
)
1915 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1916 abfd
, name
, hdr
->sh_type
);
1924 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1925 Return SEC for sections that have no elf section, and NULL on error. */
1928 bfd_section_from_r_symndx (bfd
*abfd
,
1929 struct sym_sec_cache
*cache
,
1931 unsigned long r_symndx
)
1933 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
1936 if (cache
->abfd
!= abfd
|| cache
->indx
[ent
] != r_symndx
)
1938 Elf_Internal_Shdr
*symtab_hdr
;
1939 unsigned char esym
[sizeof (Elf64_External_Sym
)];
1940 Elf_External_Sym_Shndx eshndx
;
1941 Elf_Internal_Sym isym
;
1943 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1944 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
1945 &isym
, esym
, &eshndx
) == NULL
)
1948 if (cache
->abfd
!= abfd
)
1950 memset (cache
->indx
, -1, sizeof (cache
->indx
));
1953 cache
->indx
[ent
] = r_symndx
;
1954 cache
->shndx
[ent
] = isym
.st_shndx
;
1957 s
= bfd_section_from_elf_index (abfd
, cache
->shndx
[ent
]);
1964 /* Given an ELF section number, retrieve the corresponding BFD
1968 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
1970 if (index
>= elf_numsections (abfd
))
1972 return elf_elfsections (abfd
)[index
]->bfd_section
;
1975 static const struct bfd_elf_special_section special_sections_b
[] =
1977 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1978 { NULL
, 0, 0, 0, 0 }
1981 static const struct bfd_elf_special_section special_sections_c
[] =
1983 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
1984 { NULL
, 0, 0, 0, 0 }
1987 static const struct bfd_elf_special_section special_sections_d
[] =
1989 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1990 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1991 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
1992 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
1993 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
1994 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
1995 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
1996 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
1997 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
1998 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
1999 { NULL
, 0, 0, 0, 0 }
2002 static const struct bfd_elf_special_section special_sections_f
[] =
2004 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2005 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2006 { NULL
, 0, 0, 0, 0 }
2009 static const struct bfd_elf_special_section special_sections_g
[] =
2011 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2012 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2013 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2014 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2015 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2016 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2017 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2018 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2019 { NULL
, 0, 0, 0, 0 }
2022 static const struct bfd_elf_special_section special_sections_h
[] =
2024 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2025 { NULL
, 0, 0, 0, 0 }
2028 static const struct bfd_elf_special_section special_sections_i
[] =
2030 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2031 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2032 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2033 { NULL
, 0, 0, 0, 0 }
2036 static const struct bfd_elf_special_section special_sections_l
[] =
2038 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2039 { NULL
, 0, 0, 0, 0 }
2042 static const struct bfd_elf_special_section special_sections_n
[] =
2044 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2045 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2046 { NULL
, 0, 0, 0, 0 }
2049 static const struct bfd_elf_special_section special_sections_p
[] =
2051 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2052 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2053 { NULL
, 0, 0, 0, 0 }
2056 static const struct bfd_elf_special_section special_sections_r
[] =
2058 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2059 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2060 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2061 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2062 { NULL
, 0, 0, 0, 0 }
2065 static const struct bfd_elf_special_section special_sections_s
[] =
2067 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2068 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2069 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2070 /* See struct bfd_elf_special_section declaration for the semantics of
2071 this special case where .prefix_length != strlen (.prefix). */
2072 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2073 { NULL
, 0, 0, 0, 0 }
2076 static const struct bfd_elf_special_section special_sections_t
[] =
2078 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2079 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2080 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2081 { NULL
, 0, 0, 0, 0 }
2084 static const struct bfd_elf_special_section
*special_sections
[] =
2086 special_sections_b
, /* 'b' */
2087 special_sections_c
, /* 'b' */
2088 special_sections_d
, /* 'd' */
2090 special_sections_f
, /* 'f' */
2091 special_sections_g
, /* 'g' */
2092 special_sections_h
, /* 'h' */
2093 special_sections_i
, /* 'i' */
2096 special_sections_l
, /* 'l' */
2098 special_sections_n
, /* 'n' */
2100 special_sections_p
, /* 'p' */
2102 special_sections_r
, /* 'r' */
2103 special_sections_s
, /* 's' */
2104 special_sections_t
, /* 't' */
2107 const struct bfd_elf_special_section
*
2108 _bfd_elf_get_special_section (const char *name
,
2109 const struct bfd_elf_special_section
*spec
,
2115 len
= strlen (name
);
2117 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2120 int prefix_len
= spec
[i
].prefix_length
;
2122 if (len
< prefix_len
)
2124 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2127 suffix_len
= spec
[i
].suffix_length
;
2128 if (suffix_len
<= 0)
2130 if (name
[prefix_len
] != 0)
2132 if (suffix_len
== 0)
2134 if (name
[prefix_len
] != '.'
2135 && (suffix_len
== -2
2136 || (rela
&& spec
[i
].type
== SHT_REL
)))
2142 if (len
< prefix_len
+ suffix_len
)
2144 if (memcmp (name
+ len
- suffix_len
,
2145 spec
[i
].prefix
+ prefix_len
,
2155 const struct bfd_elf_special_section
*
2156 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2159 const struct bfd_elf_special_section
*spec
;
2160 const struct elf_backend_data
*bed
;
2162 /* See if this is one of the special sections. */
2163 if (sec
->name
== NULL
)
2166 bed
= get_elf_backend_data (abfd
);
2167 spec
= bed
->special_sections
;
2170 spec
= _bfd_elf_get_special_section (sec
->name
,
2171 bed
->special_sections
,
2177 if (sec
->name
[0] != '.')
2180 i
= sec
->name
[1] - 'b';
2181 if (i
< 0 || i
> 't' - 'b')
2184 spec
= special_sections
[i
];
2189 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2193 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2195 struct bfd_elf_section_data
*sdata
;
2196 const struct elf_backend_data
*bed
;
2197 const struct bfd_elf_special_section
*ssect
;
2199 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2202 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2205 sec
->used_by_bfd
= sdata
;
2208 /* Indicate whether or not this section should use RELA relocations. */
2209 bed
= get_elf_backend_data (abfd
);
2210 sec
->use_rela_p
= bed
->default_use_rela_p
;
2212 /* When we read a file, we don't need to set ELF section type and
2213 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2214 anyway. We will set ELF section type and flags for all linker
2215 created sections. If user specifies BFD section flags, we will
2216 set ELF section type and flags based on BFD section flags in
2217 elf_fake_sections. */
2218 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2219 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2221 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2224 elf_section_type (sec
) = ssect
->type
;
2225 elf_section_flags (sec
) = ssect
->attr
;
2229 return _bfd_generic_new_section_hook (abfd
, sec
);
2232 /* Create a new bfd section from an ELF program header.
2234 Since program segments have no names, we generate a synthetic name
2235 of the form segment<NUM>, where NUM is generally the index in the
2236 program header table. For segments that are split (see below) we
2237 generate the names segment<NUM>a and segment<NUM>b.
2239 Note that some program segments may have a file size that is different than
2240 (less than) the memory size. All this means is that at execution the
2241 system must allocate the amount of memory specified by the memory size,
2242 but only initialize it with the first "file size" bytes read from the
2243 file. This would occur for example, with program segments consisting
2244 of combined data+bss.
2246 To handle the above situation, this routine generates TWO bfd sections
2247 for the single program segment. The first has the length specified by
2248 the file size of the segment, and the second has the length specified
2249 by the difference between the two sizes. In effect, the segment is split
2250 into its initialized and uninitialized parts.
2255 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2256 Elf_Internal_Phdr
*hdr
,
2258 const char *typename
)
2266 split
= ((hdr
->p_memsz
> 0)
2267 && (hdr
->p_filesz
> 0)
2268 && (hdr
->p_memsz
> hdr
->p_filesz
));
2270 if (hdr
->p_filesz
> 0)
2272 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2273 len
= strlen (namebuf
) + 1;
2274 name
= bfd_alloc (abfd
, len
);
2277 memcpy (name
, namebuf
, len
);
2278 newsect
= bfd_make_section (abfd
, name
);
2279 if (newsect
== NULL
)
2281 newsect
->vma
= hdr
->p_vaddr
;
2282 newsect
->lma
= hdr
->p_paddr
;
2283 newsect
->size
= hdr
->p_filesz
;
2284 newsect
->filepos
= hdr
->p_offset
;
2285 newsect
->flags
|= SEC_HAS_CONTENTS
;
2286 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2287 if (hdr
->p_type
== PT_LOAD
)
2289 newsect
->flags
|= SEC_ALLOC
;
2290 newsect
->flags
|= SEC_LOAD
;
2291 if (hdr
->p_flags
& PF_X
)
2293 /* FIXME: all we known is that it has execute PERMISSION,
2295 newsect
->flags
|= SEC_CODE
;
2298 if (!(hdr
->p_flags
& PF_W
))
2300 newsect
->flags
|= SEC_READONLY
;
2304 if (hdr
->p_memsz
> hdr
->p_filesz
)
2308 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "b" : "");
2309 len
= strlen (namebuf
) + 1;
2310 name
= bfd_alloc (abfd
, len
);
2313 memcpy (name
, namebuf
, len
);
2314 newsect
= bfd_make_section (abfd
, name
);
2315 if (newsect
== NULL
)
2317 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2318 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2319 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2320 newsect
->filepos
= hdr
->p_offset
+ hdr
->p_filesz
;
2321 align
= newsect
->vma
& -newsect
->vma
;
2322 if (align
== 0 || align
> hdr
->p_align
)
2323 align
= hdr
->p_align
;
2324 newsect
->alignment_power
= bfd_log2 (align
);
2325 if (hdr
->p_type
== PT_LOAD
)
2327 /* Hack for gdb. Segments that have not been modified do
2328 not have their contents written to a core file, on the
2329 assumption that a debugger can find the contents in the
2330 executable. We flag this case by setting the fake
2331 section size to zero. Note that "real" bss sections will
2332 always have their contents dumped to the core file. */
2333 if (bfd_get_format (abfd
) == bfd_core
)
2335 newsect
->flags
|= SEC_ALLOC
;
2336 if (hdr
->p_flags
& PF_X
)
2337 newsect
->flags
|= SEC_CODE
;
2339 if (!(hdr
->p_flags
& PF_W
))
2340 newsect
->flags
|= SEC_READONLY
;
2347 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2349 const struct elf_backend_data
*bed
;
2351 switch (hdr
->p_type
)
2354 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2357 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2360 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2363 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2366 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2368 if (! elf_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2373 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2376 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2378 case PT_GNU_EH_FRAME
:
2379 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2383 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2386 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2389 /* Check for any processor-specific program segment types. */
2390 bed
= get_elf_backend_data (abfd
);
2391 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, index
, "proc");
2395 /* Initialize REL_HDR, the section-header for new section, containing
2396 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2397 relocations; otherwise, we use REL relocations. */
2400 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2401 Elf_Internal_Shdr
*rel_hdr
,
2403 bfd_boolean use_rela_p
)
2406 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2407 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2409 name
= bfd_alloc (abfd
, amt
);
2412 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2414 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2416 if (rel_hdr
->sh_name
== (unsigned int) -1)
2418 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2419 rel_hdr
->sh_entsize
= (use_rela_p
2420 ? bed
->s
->sizeof_rela
2421 : bed
->s
->sizeof_rel
);
2422 rel_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
2423 rel_hdr
->sh_flags
= 0;
2424 rel_hdr
->sh_addr
= 0;
2425 rel_hdr
->sh_size
= 0;
2426 rel_hdr
->sh_offset
= 0;
2431 /* Set up an ELF internal section header for a section. */
2434 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2436 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2437 bfd_boolean
*failedptr
= failedptrarg
;
2438 Elf_Internal_Shdr
*this_hdr
;
2439 unsigned int sh_type
;
2443 /* We already failed; just get out of the bfd_map_over_sections
2448 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2450 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2451 asect
->name
, FALSE
);
2452 if (this_hdr
->sh_name
== (unsigned int) -1)
2458 /* Don't clear sh_flags. Assembler may set additional bits. */
2460 if ((asect
->flags
& SEC_ALLOC
) != 0
2461 || asect
->user_set_vma
)
2462 this_hdr
->sh_addr
= asect
->vma
;
2464 this_hdr
->sh_addr
= 0;
2466 this_hdr
->sh_offset
= 0;
2467 this_hdr
->sh_size
= asect
->size
;
2468 this_hdr
->sh_link
= 0;
2469 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2470 /* The sh_entsize and sh_info fields may have been set already by
2471 copy_private_section_data. */
2473 this_hdr
->bfd_section
= asect
;
2474 this_hdr
->contents
= NULL
;
2476 /* If the section type is unspecified, we set it based on
2478 if (this_hdr
->sh_type
== SHT_NULL
)
2480 if ((asect
->flags
& SEC_GROUP
) != 0)
2481 this_hdr
->sh_type
= SHT_GROUP
;
2482 else if ((asect
->flags
& SEC_ALLOC
) != 0
2483 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2484 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2485 this_hdr
->sh_type
= SHT_NOBITS
;
2487 this_hdr
->sh_type
= SHT_PROGBITS
;
2490 switch (this_hdr
->sh_type
)
2496 case SHT_INIT_ARRAY
:
2497 case SHT_FINI_ARRAY
:
2498 case SHT_PREINIT_ARRAY
:
2505 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2509 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2513 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2517 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2518 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2522 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2523 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2526 case SHT_GNU_versym
:
2527 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2530 case SHT_GNU_verdef
:
2531 this_hdr
->sh_entsize
= 0;
2532 /* objcopy or strip will copy over sh_info, but may not set
2533 cverdefs. The linker will set cverdefs, but sh_info will be
2535 if (this_hdr
->sh_info
== 0)
2536 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2538 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2539 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2542 case SHT_GNU_verneed
:
2543 this_hdr
->sh_entsize
= 0;
2544 /* objcopy or strip will copy over sh_info, but may not set
2545 cverrefs. The linker will set cverrefs, but sh_info will be
2547 if (this_hdr
->sh_info
== 0)
2548 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2550 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2551 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2555 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2559 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2563 if ((asect
->flags
& SEC_ALLOC
) != 0)
2564 this_hdr
->sh_flags
|= SHF_ALLOC
;
2565 if ((asect
->flags
& SEC_READONLY
) == 0)
2566 this_hdr
->sh_flags
|= SHF_WRITE
;
2567 if ((asect
->flags
& SEC_CODE
) != 0)
2568 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2569 if ((asect
->flags
& SEC_MERGE
) != 0)
2571 this_hdr
->sh_flags
|= SHF_MERGE
;
2572 this_hdr
->sh_entsize
= asect
->entsize
;
2573 if ((asect
->flags
& SEC_STRINGS
) != 0)
2574 this_hdr
->sh_flags
|= SHF_STRINGS
;
2576 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2577 this_hdr
->sh_flags
|= SHF_GROUP
;
2578 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2580 this_hdr
->sh_flags
|= SHF_TLS
;
2581 if (asect
->size
== 0
2582 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2584 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2586 this_hdr
->sh_size
= 0;
2589 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2590 if (this_hdr
->sh_size
!= 0)
2591 this_hdr
->sh_type
= SHT_NOBITS
;
2596 /* Check for processor-specific section types. */
2597 sh_type
= this_hdr
->sh_type
;
2598 if (bed
->elf_backend_fake_sections
2599 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2602 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2604 /* Don't change the header type from NOBITS if we are being
2605 called for objcopy --only-keep-debug. */
2606 this_hdr
->sh_type
= sh_type
;
2609 /* If the section has relocs, set up a section header for the
2610 SHT_REL[A] section. If two relocation sections are required for
2611 this section, it is up to the processor-specific back-end to
2612 create the other. */
2613 if ((asect
->flags
& SEC_RELOC
) != 0
2614 && !_bfd_elf_init_reloc_shdr (abfd
,
2615 &elf_section_data (asect
)->rel_hdr
,
2621 /* Fill in the contents of a SHT_GROUP section. */
2624 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2626 bfd_boolean
*failedptr
= failedptrarg
;
2627 unsigned long symindx
;
2628 asection
*elt
, *first
;
2632 /* Ignore linker created group section. See elfNN_ia64_object_p in
2634 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2639 if (elf_group_id (sec
) != NULL
)
2640 symindx
= elf_group_id (sec
)->udata
.i
;
2644 /* If called from the assembler, swap_out_syms will have set up
2645 elf_section_syms; If called for "ld -r", use target_index. */
2646 if (elf_section_syms (abfd
) != NULL
)
2647 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2649 symindx
= sec
->target_index
;
2651 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2653 /* The contents won't be allocated for "ld -r" or objcopy. */
2655 if (sec
->contents
== NULL
)
2658 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2660 /* Arrange for the section to be written out. */
2661 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2662 if (sec
->contents
== NULL
)
2669 loc
= sec
->contents
+ sec
->size
;
2671 /* Get the pointer to the first section in the group that gas
2672 squirreled away here. objcopy arranges for this to be set to the
2673 start of the input section group. */
2674 first
= elt
= elf_next_in_group (sec
);
2676 /* First element is a flag word. Rest of section is elf section
2677 indices for all the sections of the group. Write them backwards
2678 just to keep the group in the same order as given in .section
2679 directives, not that it matters. */
2688 s
= s
->output_section
;
2691 idx
= elf_section_data (s
)->this_idx
;
2692 H_PUT_32 (abfd
, idx
, loc
);
2693 elt
= elf_next_in_group (elt
);
2698 if ((loc
-= 4) != sec
->contents
)
2701 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
2704 /* Assign all ELF section numbers. The dummy first section is handled here
2705 too. The link/info pointers for the standard section types are filled
2706 in here too, while we're at it. */
2709 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
2711 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
2713 unsigned int section_number
, secn
;
2714 Elf_Internal_Shdr
**i_shdrp
;
2715 struct bfd_elf_section_data
*d
;
2719 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
2721 /* SHT_GROUP sections are in relocatable files only. */
2722 if (link_info
== NULL
|| link_info
->relocatable
)
2724 /* Put SHT_GROUP sections first. */
2725 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2727 d
= elf_section_data (sec
);
2729 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
2731 if (sec
->flags
& SEC_LINKER_CREATED
)
2733 /* Remove the linker created SHT_GROUP sections. */
2734 bfd_section_list_remove (abfd
, sec
);
2735 abfd
->section_count
--;
2739 if (section_number
== SHN_LORESERVE
)
2740 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2741 d
->this_idx
= section_number
++;
2747 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2749 d
= elf_section_data (sec
);
2751 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
2753 if (section_number
== SHN_LORESERVE
)
2754 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2755 d
->this_idx
= section_number
++;
2757 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
2758 if ((sec
->flags
& SEC_RELOC
) == 0)
2762 if (section_number
== SHN_LORESERVE
)
2763 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2764 d
->rel_idx
= section_number
++;
2765 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
2770 if (section_number
== SHN_LORESERVE
)
2771 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2772 d
->rel_idx2
= section_number
++;
2773 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
2779 if (section_number
== SHN_LORESERVE
)
2780 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2781 t
->shstrtab_section
= section_number
++;
2782 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
2783 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
2785 if (bfd_get_symcount (abfd
) > 0)
2787 if (section_number
== SHN_LORESERVE
)
2788 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2789 t
->symtab_section
= section_number
++;
2790 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
2791 if (section_number
> SHN_LORESERVE
- 2)
2793 if (section_number
== SHN_LORESERVE
)
2794 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2795 t
->symtab_shndx_section
= section_number
++;
2796 t
->symtab_shndx_hdr
.sh_name
2797 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2798 ".symtab_shndx", FALSE
);
2799 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
2802 if (section_number
== SHN_LORESERVE
)
2803 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2804 t
->strtab_section
= section_number
++;
2805 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
2808 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
2809 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
2811 elf_numsections (abfd
) = section_number
;
2812 elf_elfheader (abfd
)->e_shnum
= section_number
;
2813 if (section_number
> SHN_LORESERVE
)
2814 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
2816 /* Set up the list of section header pointers, in agreement with the
2818 i_shdrp
= bfd_zalloc2 (abfd
, section_number
, sizeof (Elf_Internal_Shdr
*));
2819 if (i_shdrp
== NULL
)
2822 i_shdrp
[0] = bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
2823 if (i_shdrp
[0] == NULL
)
2825 bfd_release (abfd
, i_shdrp
);
2829 elf_elfsections (abfd
) = i_shdrp
;
2831 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
2832 if (bfd_get_symcount (abfd
) > 0)
2834 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
2835 if (elf_numsections (abfd
) > SHN_LORESERVE
)
2837 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
2838 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
2840 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
2841 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
2844 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
2846 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
2850 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
2851 if (d
->rel_idx
!= 0)
2852 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
2853 if (d
->rel_idx2
!= 0)
2854 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
2856 /* Fill in the sh_link and sh_info fields while we're at it. */
2858 /* sh_link of a reloc section is the section index of the symbol
2859 table. sh_info is the section index of the section to which
2860 the relocation entries apply. */
2861 if (d
->rel_idx
!= 0)
2863 d
->rel_hdr
.sh_link
= t
->symtab_section
;
2864 d
->rel_hdr
.sh_info
= d
->this_idx
;
2866 if (d
->rel_idx2
!= 0)
2868 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
2869 d
->rel_hdr2
->sh_info
= d
->this_idx
;
2872 /* We need to set up sh_link for SHF_LINK_ORDER. */
2873 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
2875 s
= elf_linked_to_section (sec
);
2878 /* elf_linked_to_section points to the input section. */
2879 if (link_info
!= NULL
)
2881 /* Check discarded linkonce section. */
2882 if (elf_discarded_section (s
))
2885 (*_bfd_error_handler
)
2886 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2887 abfd
, d
->this_hdr
.bfd_section
,
2889 /* Point to the kept section if it has the same
2890 size as the discarded one. */
2891 kept
= _bfd_elf_check_kept_section (s
, link_info
);
2894 bfd_set_error (bfd_error_bad_value
);
2900 s
= s
->output_section
;
2901 BFD_ASSERT (s
!= NULL
);
2905 /* Handle objcopy. */
2906 if (s
->output_section
== NULL
)
2908 (*_bfd_error_handler
)
2909 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2910 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
2911 bfd_set_error (bfd_error_bad_value
);
2914 s
= s
->output_section
;
2916 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2921 The Intel C compiler generates SHT_IA_64_UNWIND with
2922 SHF_LINK_ORDER. But it doesn't set the sh_link or
2923 sh_info fields. Hence we could get the situation
2925 const struct elf_backend_data
*bed
2926 = get_elf_backend_data (abfd
);
2927 if (bed
->link_order_error_handler
)
2928 bed
->link_order_error_handler
2929 (_("%B: warning: sh_link not set for section `%A'"),
2934 switch (d
->this_hdr
.sh_type
)
2938 /* A reloc section which we are treating as a normal BFD
2939 section. sh_link is the section index of the symbol
2940 table. sh_info is the section index of the section to
2941 which the relocation entries apply. We assume that an
2942 allocated reloc section uses the dynamic symbol table.
2943 FIXME: How can we be sure? */
2944 s
= bfd_get_section_by_name (abfd
, ".dynsym");
2946 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
2948 /* We look up the section the relocs apply to by name. */
2950 if (d
->this_hdr
.sh_type
== SHT_REL
)
2954 s
= bfd_get_section_by_name (abfd
, name
);
2956 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
2960 /* We assume that a section named .stab*str is a stabs
2961 string section. We look for a section with the same name
2962 but without the trailing ``str'', and set its sh_link
2963 field to point to this section. */
2964 if (CONST_STRNEQ (sec
->name
, ".stab")
2965 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
2970 len
= strlen (sec
->name
);
2971 alc
= bfd_malloc (len
- 2);
2974 memcpy (alc
, sec
->name
, len
- 3);
2975 alc
[len
- 3] = '\0';
2976 s
= bfd_get_section_by_name (abfd
, alc
);
2980 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
2982 /* This is a .stab section. */
2983 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
2984 elf_section_data (s
)->this_hdr
.sh_entsize
2985 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
2992 case SHT_GNU_verneed
:
2993 case SHT_GNU_verdef
:
2994 /* sh_link is the section header index of the string table
2995 used for the dynamic entries, or the symbol table, or the
2997 s
= bfd_get_section_by_name (abfd
, ".dynstr");
2999 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3002 case SHT_GNU_LIBLIST
:
3003 /* sh_link is the section header index of the prelink library
3004 list used for the dynamic entries, or the symbol table, or
3005 the version strings. */
3006 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3007 ? ".dynstr" : ".gnu.libstr");
3009 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3014 case SHT_GNU_versym
:
3015 /* sh_link is the section header index of the symbol table
3016 this hash table or version table is for. */
3017 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3019 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3023 d
->this_hdr
.sh_link
= t
->symtab_section
;
3027 for (secn
= 1; secn
< section_number
; ++secn
)
3028 if (i_shdrp
[secn
] == NULL
)
3029 i_shdrp
[secn
] = i_shdrp
[0];
3031 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3032 i_shdrp
[secn
]->sh_name
);
3036 /* Map symbol from it's internal number to the external number, moving
3037 all local symbols to be at the head of the list. */
3040 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3042 /* If the backend has a special mapping, use it. */
3043 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3044 if (bed
->elf_backend_sym_is_global
)
3045 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3047 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
3048 || bfd_is_und_section (bfd_get_section (sym
))
3049 || bfd_is_com_section (bfd_get_section (sym
)));
3052 /* Don't output section symbols for sections that are not going to be
3053 output. Also, don't output section symbols for reloc and other
3054 special sections. */
3057 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3059 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3061 || (sym
->section
->owner
!= abfd
3062 && (sym
->section
->output_section
->owner
!= abfd
3063 || sym
->section
->output_offset
!= 0))));
3067 elf_map_symbols (bfd
*abfd
)
3069 unsigned int symcount
= bfd_get_symcount (abfd
);
3070 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3071 asymbol
**sect_syms
;
3072 unsigned int num_locals
= 0;
3073 unsigned int num_globals
= 0;
3074 unsigned int num_locals2
= 0;
3075 unsigned int num_globals2
= 0;
3082 fprintf (stderr
, "elf_map_symbols\n");
3086 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3088 if (max_index
< asect
->index
)
3089 max_index
= asect
->index
;
3093 sect_syms
= bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3094 if (sect_syms
== NULL
)
3096 elf_section_syms (abfd
) = sect_syms
;
3097 elf_num_section_syms (abfd
) = max_index
;
3099 /* Init sect_syms entries for any section symbols we have already
3100 decided to output. */
3101 for (idx
= 0; idx
< symcount
; idx
++)
3103 asymbol
*sym
= syms
[idx
];
3105 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3106 && !ignore_section_sym (abfd
, sym
))
3108 asection
*sec
= sym
->section
;
3110 if (sec
->owner
!= abfd
)
3111 sec
= sec
->output_section
;
3113 sect_syms
[sec
->index
] = syms
[idx
];
3117 /* Classify all of the symbols. */
3118 for (idx
= 0; idx
< symcount
; idx
++)
3120 if (ignore_section_sym (abfd
, syms
[idx
]))
3122 if (!sym_is_global (abfd
, syms
[idx
]))
3128 /* We will be adding a section symbol for each normal BFD section. Most
3129 sections will already have a section symbol in outsymbols, but
3130 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3131 at least in that case. */
3132 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3134 if (sect_syms
[asect
->index
] == NULL
)
3136 if (!sym_is_global (abfd
, asect
->symbol
))
3143 /* Now sort the symbols so the local symbols are first. */
3144 new_syms
= bfd_alloc2 (abfd
, num_locals
+ num_globals
, sizeof (asymbol
*));
3146 if (new_syms
== NULL
)
3149 for (idx
= 0; idx
< symcount
; idx
++)
3151 asymbol
*sym
= syms
[idx
];
3154 if (ignore_section_sym (abfd
, sym
))
3156 if (!sym_is_global (abfd
, sym
))
3159 i
= num_locals
+ num_globals2
++;
3161 sym
->udata
.i
= i
+ 1;
3163 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3165 if (sect_syms
[asect
->index
] == NULL
)
3167 asymbol
*sym
= asect
->symbol
;
3170 sect_syms
[asect
->index
] = sym
;
3171 if (!sym_is_global (abfd
, sym
))
3174 i
= num_locals
+ num_globals2
++;
3176 sym
->udata
.i
= i
+ 1;
3180 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3182 elf_num_locals (abfd
) = num_locals
;
3183 elf_num_globals (abfd
) = num_globals
;
3187 /* Align to the maximum file alignment that could be required for any
3188 ELF data structure. */
3190 static inline file_ptr
3191 align_file_position (file_ptr off
, int align
)
3193 return (off
+ align
- 1) & ~(align
- 1);
3196 /* Assign a file position to a section, optionally aligning to the
3197 required section alignment. */
3200 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3208 al
= i_shdrp
->sh_addralign
;
3210 offset
= BFD_ALIGN (offset
, al
);
3212 i_shdrp
->sh_offset
= offset
;
3213 if (i_shdrp
->bfd_section
!= NULL
)
3214 i_shdrp
->bfd_section
->filepos
= offset
;
3215 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3216 offset
+= i_shdrp
->sh_size
;
3220 /* Compute the file positions we are going to put the sections at, and
3221 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3222 is not NULL, this is being called by the ELF backend linker. */
3225 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3226 struct bfd_link_info
*link_info
)
3228 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3230 struct bfd_strtab_hash
*strtab
= NULL
;
3231 Elf_Internal_Shdr
*shstrtab_hdr
;
3233 if (abfd
->output_has_begun
)
3236 /* Do any elf backend specific processing first. */
3237 if (bed
->elf_backend_begin_write_processing
)
3238 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3240 if (! prep_headers (abfd
))
3243 /* Post process the headers if necessary. */
3244 if (bed
->elf_backend_post_process_headers
)
3245 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3248 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3252 if (!assign_section_numbers (abfd
, link_info
))
3255 /* The backend linker builds symbol table information itself. */
3256 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3258 /* Non-zero if doing a relocatable link. */
3259 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3261 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3265 if (link_info
== NULL
)
3267 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3272 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3273 /* sh_name was set in prep_headers. */
3274 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3275 shstrtab_hdr
->sh_flags
= 0;
3276 shstrtab_hdr
->sh_addr
= 0;
3277 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3278 shstrtab_hdr
->sh_entsize
= 0;
3279 shstrtab_hdr
->sh_link
= 0;
3280 shstrtab_hdr
->sh_info
= 0;
3281 /* sh_offset is set in assign_file_positions_except_relocs. */
3282 shstrtab_hdr
->sh_addralign
= 1;
3284 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3287 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3290 Elf_Internal_Shdr
*hdr
;
3292 off
= elf_tdata (abfd
)->next_file_pos
;
3294 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3295 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3297 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3298 if (hdr
->sh_size
!= 0)
3299 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3301 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3302 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3304 elf_tdata (abfd
)->next_file_pos
= off
;
3306 /* Now that we know where the .strtab section goes, write it
3308 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3309 || ! _bfd_stringtab_emit (abfd
, strtab
))
3311 _bfd_stringtab_free (strtab
);
3314 abfd
->output_has_begun
= TRUE
;
3319 /* Make an initial estimate of the size of the program header. If we
3320 get the number wrong here, we'll redo section placement. */
3322 static bfd_size_type
3323 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3327 const struct elf_backend_data
*bed
;
3329 /* Assume we will need exactly two PT_LOAD segments: one for text
3330 and one for data. */
3333 s
= bfd_get_section_by_name (abfd
, ".interp");
3334 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3336 /* If we have a loadable interpreter section, we need a
3337 PT_INTERP segment. In this case, assume we also need a
3338 PT_PHDR segment, although that may not be true for all
3343 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3345 /* We need a PT_DYNAMIC segment. */
3348 if (elf_tdata (abfd
)->relro
)
3350 /* We need a PT_GNU_RELRO segment only when there is a
3351 PT_DYNAMIC segment. */
3356 if (elf_tdata (abfd
)->eh_frame_hdr
)
3358 /* We need a PT_GNU_EH_FRAME segment. */
3362 if (elf_tdata (abfd
)->stack_flags
)
3364 /* We need a PT_GNU_STACK segment. */
3368 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3370 if ((s
->flags
& SEC_LOAD
) != 0
3371 && CONST_STRNEQ (s
->name
, ".note"))
3373 /* We need a PT_NOTE segment. */
3375 /* Try to create just one PT_NOTE segment
3376 for all adjacent loadable .note* sections.
3377 gABI requires that within a PT_NOTE segment
3378 (and also inside of each SHT_NOTE section)
3379 each note is padded to a multiple of 4 size,
3380 so we check whether the sections are correctly
3382 if (s
->alignment_power
== 2)
3383 while (s
->next
!= NULL
3384 && s
->next
->alignment_power
== 2
3385 && (s
->next
->flags
& SEC_LOAD
) != 0
3386 && CONST_STRNEQ (s
->next
->name
, ".note"))
3391 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3393 if (s
->flags
& SEC_THREAD_LOCAL
)
3395 /* We need a PT_TLS segment. */
3401 /* Let the backend count up any program headers it might need. */
3402 bed
= get_elf_backend_data (abfd
);
3403 if (bed
->elf_backend_additional_program_headers
)
3407 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3413 return segs
* bed
->s
->sizeof_phdr
;
3416 /* Create a mapping from a set of sections to a program segment. */
3418 static struct elf_segment_map
*
3419 make_mapping (bfd
*abfd
,
3420 asection
**sections
,
3425 struct elf_segment_map
*m
;
3430 amt
= sizeof (struct elf_segment_map
);
3431 amt
+= (to
- from
- 1) * sizeof (asection
*);
3432 m
= bfd_zalloc (abfd
, amt
);
3436 m
->p_type
= PT_LOAD
;
3437 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3438 m
->sections
[i
- from
] = *hdrpp
;
3439 m
->count
= to
- from
;
3441 if (from
== 0 && phdr
)
3443 /* Include the headers in the first PT_LOAD segment. */
3444 m
->includes_filehdr
= 1;
3445 m
->includes_phdrs
= 1;
3451 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3454 struct elf_segment_map
*
3455 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3457 struct elf_segment_map
*m
;
3459 m
= bfd_zalloc (abfd
, sizeof (struct elf_segment_map
));
3463 m
->p_type
= PT_DYNAMIC
;
3465 m
->sections
[0] = dynsec
;
3470 /* Possibly add or remove segments from the segment map. */
3473 elf_modify_segment_map (bfd
*abfd
,
3474 struct bfd_link_info
*info
,
3475 bfd_boolean remove_empty_load
)
3477 struct elf_segment_map
**m
;
3478 const struct elf_backend_data
*bed
;
3480 /* The placement algorithm assumes that non allocated sections are
3481 not in PT_LOAD segments. We ensure this here by removing such
3482 sections from the segment map. We also remove excluded
3483 sections. Finally, any PT_LOAD segment without sections is
3485 m
= &elf_tdata (abfd
)->segment_map
;
3488 unsigned int i
, new_count
;
3490 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3492 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3493 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3494 || (*m
)->p_type
!= PT_LOAD
))
3496 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3500 (*m
)->count
= new_count
;
3502 if (remove_empty_load
&& (*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3508 bed
= get_elf_backend_data (abfd
);
3509 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3511 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3518 /* Set up a mapping from BFD sections to program segments. */
3521 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3524 struct elf_segment_map
*m
;
3525 asection
**sections
= NULL
;
3526 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3527 bfd_boolean no_user_phdrs
;
3529 no_user_phdrs
= elf_tdata (abfd
)->segment_map
== NULL
;
3530 if (no_user_phdrs
&& bfd_count_sections (abfd
) != 0)
3534 struct elf_segment_map
*mfirst
;
3535 struct elf_segment_map
**pm
;
3538 unsigned int phdr_index
;
3539 bfd_vma maxpagesize
;
3541 bfd_boolean phdr_in_segment
= TRUE
;
3542 bfd_boolean writable
;
3544 asection
*first_tls
= NULL
;
3545 asection
*dynsec
, *eh_frame_hdr
;
3548 /* Select the allocated sections, and sort them. */
3550 sections
= bfd_malloc2 (bfd_count_sections (abfd
), sizeof (asection
*));
3551 if (sections
== NULL
)
3555 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3557 if ((s
->flags
& SEC_ALLOC
) != 0)
3563 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3566 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3568 /* Build the mapping. */
3573 /* If we have a .interp section, then create a PT_PHDR segment for
3574 the program headers and a PT_INTERP segment for the .interp
3576 s
= bfd_get_section_by_name (abfd
, ".interp");
3577 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3579 amt
= sizeof (struct elf_segment_map
);
3580 m
= bfd_zalloc (abfd
, amt
);
3584 m
->p_type
= PT_PHDR
;
3585 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3586 m
->p_flags
= PF_R
| PF_X
;
3587 m
->p_flags_valid
= 1;
3588 m
->includes_phdrs
= 1;
3593 amt
= sizeof (struct elf_segment_map
);
3594 m
= bfd_zalloc (abfd
, amt
);
3598 m
->p_type
= PT_INTERP
;
3606 /* Look through the sections. We put sections in the same program
3607 segment when the start of the second section can be placed within
3608 a few bytes of the end of the first section. */
3612 maxpagesize
= bed
->maxpagesize
;
3614 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3616 && (dynsec
->flags
& SEC_LOAD
) == 0)
3619 /* Deal with -Ttext or something similar such that the first section
3620 is not adjacent to the program headers. This is an
3621 approximation, since at this point we don't know exactly how many
3622 program headers we will need. */
3625 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3627 if (phdr_size
== (bfd_size_type
) -1)
3628 phdr_size
= get_program_header_size (abfd
, info
);
3629 if ((abfd
->flags
& D_PAGED
) == 0
3630 || sections
[0]->lma
< phdr_size
3631 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3632 phdr_in_segment
= FALSE
;
3635 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3638 bfd_boolean new_segment
;
3642 /* See if this section and the last one will fit in the same
3645 if (last_hdr
== NULL
)
3647 /* If we don't have a segment yet, then we don't need a new
3648 one (we build the last one after this loop). */
3649 new_segment
= FALSE
;
3651 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3653 /* If this section has a different relation between the
3654 virtual address and the load address, then we need a new
3658 else if (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
3659 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3661 /* If putting this section in this segment would force us to
3662 skip a page in the segment, then we need a new segment. */
3665 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3666 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3668 /* We don't want to put a loadable section after a
3669 nonloadable section in the same segment.
3670 Consider .tbss sections as loadable for this purpose. */
3673 else if ((abfd
->flags
& D_PAGED
) == 0)
3675 /* If the file is not demand paged, which means that we
3676 don't require the sections to be correctly aligned in the
3677 file, then there is no other reason for a new segment. */
3678 new_segment
= FALSE
;
3681 && (hdr
->flags
& SEC_READONLY
) == 0
3682 && (((last_hdr
->lma
+ last_size
- 1)
3683 & ~(maxpagesize
- 1))
3684 != (hdr
->lma
& ~(maxpagesize
- 1))))
3686 /* We don't want to put a writable section in a read only
3687 segment, unless they are on the same page in memory
3688 anyhow. We already know that the last section does not
3689 bring us past the current section on the page, so the
3690 only case in which the new section is not on the same
3691 page as the previous section is when the previous section
3692 ends precisely on a page boundary. */
3697 /* Otherwise, we can use the same segment. */
3698 new_segment
= FALSE
;
3701 /* Allow interested parties a chance to override our decision. */
3702 if (last_hdr
&& info
->callbacks
->override_segment_assignment
)
3703 new_segment
= info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
, last_hdr
, new_segment
);
3707 if ((hdr
->flags
& SEC_READONLY
) == 0)
3710 /* .tbss sections effectively have zero size. */
3711 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
3712 != SEC_THREAD_LOCAL
)
3713 last_size
= hdr
->size
;
3719 /* We need a new program segment. We must create a new program
3720 header holding all the sections from phdr_index until hdr. */
3722 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3729 if ((hdr
->flags
& SEC_READONLY
) == 0)
3735 /* .tbss sections effectively have zero size. */
3736 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
3737 last_size
= hdr
->size
;
3741 phdr_in_segment
= FALSE
;
3744 /* Create a final PT_LOAD program segment. */
3745 if (last_hdr
!= NULL
)
3747 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
3755 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3758 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
3765 /* For each batch of consecutive loadable .note sections,
3766 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3767 because if we link together nonloadable .note sections and
3768 loadable .note sections, we will generate two .note sections
3769 in the output file. FIXME: Using names for section types is
3771 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3773 if ((s
->flags
& SEC_LOAD
) != 0
3774 && CONST_STRNEQ (s
->name
, ".note"))
3778 amt
= sizeof (struct elf_segment_map
);
3779 if (s
->alignment_power
== 2)
3780 for (s2
= s
; s2
->next
!= NULL
; s2
= s2
->next
)
3782 if (s2
->next
->alignment_power
== 2
3783 && (s2
->next
->flags
& SEC_LOAD
) != 0
3784 && CONST_STRNEQ (s2
->next
->name
, ".note")
3785 && align_power (s2
->vma
+ s2
->size
, 2)
3791 amt
+= (count
- 1) * sizeof (asection
*);
3792 m
= bfd_zalloc (abfd
, amt
);
3796 m
->p_type
= PT_NOTE
;
3800 m
->sections
[m
->count
- count
--] = s
;
3801 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3804 m
->sections
[m
->count
- 1] = s
;
3805 BFD_ASSERT ((s
->flags
& SEC_THREAD_LOCAL
) == 0);
3809 if (s
->flags
& SEC_THREAD_LOCAL
)
3817 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3822 amt
= sizeof (struct elf_segment_map
);
3823 amt
+= (tls_count
- 1) * sizeof (asection
*);
3824 m
= bfd_zalloc (abfd
, amt
);
3829 m
->count
= tls_count
;
3830 /* Mandated PF_R. */
3832 m
->p_flags_valid
= 1;
3833 for (i
= 0; i
< tls_count
; ++i
)
3835 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
3836 m
->sections
[i
] = first_tls
;
3837 first_tls
= first_tls
->next
;
3844 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3846 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
3847 if (eh_frame_hdr
!= NULL
3848 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
3850 amt
= sizeof (struct elf_segment_map
);
3851 m
= bfd_zalloc (abfd
, amt
);
3855 m
->p_type
= PT_GNU_EH_FRAME
;
3857 m
->sections
[0] = eh_frame_hdr
->output_section
;
3863 if (elf_tdata (abfd
)->stack_flags
)
3865 amt
= sizeof (struct elf_segment_map
);
3866 m
= bfd_zalloc (abfd
, amt
);
3870 m
->p_type
= PT_GNU_STACK
;
3871 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
3872 m
->p_flags_valid
= 1;
3878 if (dynsec
!= NULL
&& elf_tdata (abfd
)->relro
)
3880 /* We make a PT_GNU_RELRO segment only when there is a
3881 PT_DYNAMIC segment. */
3882 amt
= sizeof (struct elf_segment_map
);
3883 m
= bfd_zalloc (abfd
, amt
);
3887 m
->p_type
= PT_GNU_RELRO
;
3889 m
->p_flags_valid
= 1;
3896 elf_tdata (abfd
)->segment_map
= mfirst
;
3899 if (!elf_modify_segment_map (abfd
, info
, no_user_phdrs
))
3902 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
3904 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
3909 if (sections
!= NULL
)
3914 /* Sort sections by address. */
3917 elf_sort_sections (const void *arg1
, const void *arg2
)
3919 const asection
*sec1
= *(const asection
**) arg1
;
3920 const asection
*sec2
= *(const asection
**) arg2
;
3921 bfd_size_type size1
, size2
;
3923 /* Sort by LMA first, since this is the address used to
3924 place the section into a segment. */
3925 if (sec1
->lma
< sec2
->lma
)
3927 else if (sec1
->lma
> sec2
->lma
)
3930 /* Then sort by VMA. Normally the LMA and the VMA will be
3931 the same, and this will do nothing. */
3932 if (sec1
->vma
< sec2
->vma
)
3934 else if (sec1
->vma
> sec2
->vma
)
3937 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3939 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3945 /* If the indicies are the same, do not return 0
3946 here, but continue to try the next comparison. */
3947 if (sec1
->target_index
- sec2
->target_index
!= 0)
3948 return sec1
->target_index
- sec2
->target_index
;
3953 else if (TOEND (sec2
))
3958 /* Sort by size, to put zero sized sections
3959 before others at the same address. */
3961 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
3962 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
3969 return sec1
->target_index
- sec2
->target_index
;
3972 /* Ian Lance Taylor writes:
3974 We shouldn't be using % with a negative signed number. That's just
3975 not good. We have to make sure either that the number is not
3976 negative, or that the number has an unsigned type. When the types
3977 are all the same size they wind up as unsigned. When file_ptr is a
3978 larger signed type, the arithmetic winds up as signed long long,
3981 What we're trying to say here is something like ``increase OFF by
3982 the least amount that will cause it to be equal to the VMA modulo
3984 /* In other words, something like:
3986 vma_offset = m->sections[0]->vma % bed->maxpagesize;
3987 off_offset = off % bed->maxpagesize;
3988 if (vma_offset < off_offset)
3989 adjustment = vma_offset + bed->maxpagesize - off_offset;
3991 adjustment = vma_offset - off_offset;
3993 which can can be collapsed into the expression below. */
3996 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
3998 return ((vma
- off
) % maxpagesize
);
4002 print_segment_map (const struct elf_segment_map
*m
)
4005 const char *pt
= get_segment_type (m
->p_type
);
4010 if (m
->p_type
>= PT_LOPROC
&& m
->p_type
<= PT_HIPROC
)
4011 sprintf (buf
, "LOPROC+%7.7x",
4012 (unsigned int) (m
->p_type
- PT_LOPROC
));
4013 else if (m
->p_type
>= PT_LOOS
&& m
->p_type
<= PT_HIOS
)
4014 sprintf (buf
, "LOOS+%7.7x",
4015 (unsigned int) (m
->p_type
- PT_LOOS
));
4017 snprintf (buf
, sizeof (buf
), "%8.8x",
4018 (unsigned int) m
->p_type
);
4021 fprintf (stderr
, "%s:", pt
);
4022 for (j
= 0; j
< m
->count
; j
++)
4023 fprintf (stderr
, " %s", m
->sections
[j
]->name
);
4027 /* Assign file positions to the sections based on the mapping from
4028 sections to segments. This function also sets up some fields in
4032 assign_file_positions_for_load_sections (bfd
*abfd
,
4033 struct bfd_link_info
*link_info
)
4035 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4036 struct elf_segment_map
*m
;
4037 Elf_Internal_Phdr
*phdrs
;
4038 Elf_Internal_Phdr
*p
;
4040 bfd_size_type maxpagesize
;
4044 if (link_info
== NULL
4045 && !elf_modify_segment_map (abfd
, link_info
, FALSE
))
4049 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4052 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4053 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4054 elf_elfheader (abfd
)->e_phnum
= alloc
;
4056 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4057 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4059 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4060 >= alloc
* bed
->s
->sizeof_phdr
);
4064 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4068 phdrs
= bfd_alloc2 (abfd
, alloc
, sizeof (Elf_Internal_Phdr
));
4069 elf_tdata (abfd
)->phdr
= phdrs
;
4074 if ((abfd
->flags
& D_PAGED
) != 0)
4075 maxpagesize
= bed
->maxpagesize
;
4077 off
= bed
->s
->sizeof_ehdr
;
4078 off
+= alloc
* bed
->s
->sizeof_phdr
;
4080 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4082 m
= m
->next
, p
++, j
++)
4086 bfd_boolean no_contents
;
4088 /* If elf_segment_map is not from map_sections_to_segments, the
4089 sections may not be correctly ordered. NOTE: sorting should
4090 not be done to the PT_NOTE section of a corefile, which may
4091 contain several pseudo-sections artificially created by bfd.
4092 Sorting these pseudo-sections breaks things badly. */
4094 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4095 && m
->p_type
== PT_NOTE
))
4096 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4099 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4100 number of sections with contents contributing to both p_filesz
4101 and p_memsz, followed by a number of sections with no contents
4102 that just contribute to p_memsz. In this loop, OFF tracks next
4103 available file offset for PT_LOAD and PT_NOTE segments. */
4104 p
->p_type
= m
->p_type
;
4105 p
->p_flags
= m
->p_flags
;
4110 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4112 if (m
->p_paddr_valid
)
4113 p
->p_paddr
= m
->p_paddr
;
4114 else if (m
->count
== 0)
4117 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4119 if (p
->p_type
== PT_LOAD
4120 && (abfd
->flags
& D_PAGED
) != 0)
4122 /* p_align in demand paged PT_LOAD segments effectively stores
4123 the maximum page size. When copying an executable with
4124 objcopy, we set m->p_align from the input file. Use this
4125 value for maxpagesize rather than bed->maxpagesize, which
4126 may be different. Note that we use maxpagesize for PT_TLS
4127 segment alignment later in this function, so we are relying
4128 on at least one PT_LOAD segment appearing before a PT_TLS
4130 if (m
->p_align_valid
)
4131 maxpagesize
= m
->p_align
;
4133 p
->p_align
= maxpagesize
;
4135 else if (m
->count
== 0)
4136 p
->p_align
= 1 << bed
->s
->log_file_align
;
4137 else if (m
->p_align_valid
)
4138 p
->p_align
= m
->p_align
;
4142 no_contents
= FALSE
;
4144 if (p
->p_type
== PT_LOAD
4147 bfd_size_type align
;
4148 unsigned int align_power
= 0;
4150 if (m
->p_align_valid
)
4154 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4156 unsigned int secalign
;
4158 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4159 if (secalign
> align_power
)
4160 align_power
= secalign
;
4162 align
= (bfd_size_type
) 1 << align_power
;
4163 if (align
< maxpagesize
)
4164 align
= maxpagesize
;
4167 for (i
= 0; i
< m
->count
; i
++)
4168 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4169 /* If we aren't making room for this section, then
4170 it must be SHT_NOBITS regardless of what we've
4171 set via struct bfd_elf_special_section. */
4172 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4174 /* Find out whether this segment contains any loadable
4175 sections. If the first section isn't loadable, the same
4176 holds for any other sections. */
4178 while (elf_section_type (m
->sections
[i
]) == SHT_NOBITS
)
4180 /* If a segment starts with .tbss, we need to look
4181 at the next section to decide whether the segment
4182 has any loadable sections. */
4183 if ((elf_section_flags (m
->sections
[i
]) & SHF_TLS
) == 0
4191 off_adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4195 /* We shouldn't need to align the segment on disk since
4196 the segment doesn't need file space, but the gABI
4197 arguably requires the alignment and glibc ld.so
4198 checks it. So to comply with the alignment
4199 requirement but not waste file space, we adjust
4200 p_offset for just this segment. (OFF_ADJUST is
4201 subtracted from OFF later.) This may put p_offset
4202 past the end of file, but that shouldn't matter. */
4207 /* Make sure the .dynamic section is the first section in the
4208 PT_DYNAMIC segment. */
4209 else if (p
->p_type
== PT_DYNAMIC
4211 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4214 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4216 bfd_set_error (bfd_error_bad_value
);
4224 if (m
->includes_filehdr
)
4226 if (!m
->p_flags_valid
)
4228 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4229 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4232 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4234 if (p
->p_vaddr
< (bfd_vma
) off
)
4236 (*_bfd_error_handler
)
4237 (_("%B: Not enough room for program headers, try linking with -N"),
4239 bfd_set_error (bfd_error_bad_value
);
4244 if (!m
->p_paddr_valid
)
4249 if (m
->includes_phdrs
)
4251 if (!m
->p_flags_valid
)
4254 if (!m
->includes_filehdr
)
4256 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4260 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4261 p
->p_vaddr
-= off
- p
->p_offset
;
4262 if (!m
->p_paddr_valid
)
4263 p
->p_paddr
-= off
- p
->p_offset
;
4267 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4268 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4271 if (p
->p_type
== PT_LOAD
4272 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4274 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4280 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4282 p
->p_filesz
+= adjust
;
4283 p
->p_memsz
+= adjust
;
4287 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4288 maps. Set filepos for sections in PT_LOAD segments, and in
4289 core files, for sections in PT_NOTE segments.
4290 assign_file_positions_for_non_load_sections will set filepos
4291 for other sections and update p_filesz for other segments. */
4292 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4295 bfd_size_type align
;
4296 Elf_Internal_Shdr
*this_hdr
;
4299 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4300 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4302 if (p
->p_type
== PT_LOAD
4303 || p
->p_type
== PT_TLS
)
4305 bfd_signed_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
4307 if (this_hdr
->sh_type
!= SHT_NOBITS
4308 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4309 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4310 || p
->p_type
== PT_TLS
)))
4314 (*_bfd_error_handler
)
4315 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4316 abfd
, sec
, (unsigned long) sec
->lma
);
4319 p
->p_memsz
+= adjust
;
4321 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4324 p
->p_filesz
+= adjust
;
4329 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4331 /* The section at i == 0 is the one that actually contains
4335 this_hdr
->sh_offset
= sec
->filepos
= off
;
4336 off
+= this_hdr
->sh_size
;
4337 p
->p_filesz
= this_hdr
->sh_size
;
4343 /* The rest are fake sections that shouldn't be written. */
4352 if (p
->p_type
== PT_LOAD
)
4354 this_hdr
->sh_offset
= sec
->filepos
= off
;
4355 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4356 off
+= this_hdr
->sh_size
;
4359 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4361 p
->p_filesz
+= this_hdr
->sh_size
;
4362 /* A load section without SHF_ALLOC is something like
4363 a note section in a PT_NOTE segment. These take
4364 file space but are not loaded into memory. */
4365 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4366 p
->p_memsz
+= this_hdr
->sh_size
;
4368 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4370 if (p
->p_type
== PT_TLS
)
4371 p
->p_memsz
+= this_hdr
->sh_size
;
4373 /* .tbss is special. It doesn't contribute to p_memsz of
4375 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4376 p
->p_memsz
+= this_hdr
->sh_size
;
4379 if (p
->p_type
== PT_GNU_RELRO
)
4381 else if (align
> p
->p_align
4382 && !m
->p_align_valid
4383 && (p
->p_type
!= PT_LOAD
4384 || (abfd
->flags
& D_PAGED
) == 0))
4388 if (!m
->p_flags_valid
)
4391 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4393 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4399 /* Check that all sections are in a PT_LOAD segment.
4400 Don't check funky gdb generated core files. */
4401 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4402 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4404 Elf_Internal_Shdr
*this_hdr
;
4408 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4409 if (this_hdr
->sh_size
!= 0
4410 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, p
))
4412 (*_bfd_error_handler
)
4413 (_("%B: section `%A' can't be allocated in segment %d"),
4415 print_segment_map (m
);
4416 bfd_set_error (bfd_error_bad_value
);
4422 elf_tdata (abfd
)->next_file_pos
= off
;
4426 /* Assign file positions for the other sections. */
4429 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4430 struct bfd_link_info
*link_info
)
4432 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4433 Elf_Internal_Shdr
**i_shdrpp
;
4434 Elf_Internal_Shdr
**hdrpp
;
4435 Elf_Internal_Phdr
*phdrs
;
4436 Elf_Internal_Phdr
*p
;
4437 struct elf_segment_map
*m
;
4438 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4439 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4441 unsigned int num_sec
;
4445 i_shdrpp
= elf_elfsections (abfd
);
4446 num_sec
= elf_numsections (abfd
);
4447 off
= elf_tdata (abfd
)->next_file_pos
;
4448 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4450 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4451 Elf_Internal_Shdr
*hdr
;
4454 if (hdr
->bfd_section
!= NULL
4455 && (hdr
->bfd_section
->filepos
!= 0
4456 || (hdr
->sh_type
== SHT_NOBITS
4457 && hdr
->contents
== NULL
)))
4458 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4459 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4461 if (hdr
->sh_size
!= 0)
4462 ((*_bfd_error_handler
)
4463 (_("%B: warning: allocated section `%s' not in segment"),
4465 (hdr
->bfd_section
== NULL
4467 : hdr
->bfd_section
->name
)));
4468 /* We don't need to page align empty sections. */
4469 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4470 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4473 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4475 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4478 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4479 && hdr
->bfd_section
== NULL
)
4480 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4481 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4482 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4483 hdr
->sh_offset
= -1;
4485 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4487 if (i
== SHN_LORESERVE
- 1)
4489 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4490 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4494 /* Now that we have set the section file positions, we can set up
4495 the file positions for the non PT_LOAD segments. */
4499 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4501 phdrs
= elf_tdata (abfd
)->phdr
;
4502 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4507 if (p
->p_type
!= PT_LOAD
)
4510 if (m
->includes_filehdr
)
4512 filehdr_vaddr
= p
->p_vaddr
;
4513 filehdr_paddr
= p
->p_paddr
;
4515 if (m
->includes_phdrs
)
4517 phdrs_vaddr
= p
->p_vaddr
;
4518 phdrs_paddr
= p
->p_paddr
;
4519 if (m
->includes_filehdr
)
4521 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4522 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4527 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4533 if (p
->p_type
!= PT_LOAD
4534 && (p
->p_type
!= PT_NOTE
|| bfd_get_format (abfd
) != bfd_core
))
4536 Elf_Internal_Shdr
*hdr
;
4537 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4539 hdr
= &elf_section_data (m
->sections
[m
->count
- 1])->this_hdr
;
4540 p
->p_filesz
= (m
->sections
[m
->count
- 1]->filepos
4541 - m
->sections
[0]->filepos
);
4542 if (hdr
->sh_type
!= SHT_NOBITS
)
4543 p
->p_filesz
+= hdr
->sh_size
;
4545 p
->p_offset
= m
->sections
[0]->filepos
;
4550 if (m
->includes_filehdr
)
4552 p
->p_vaddr
= filehdr_vaddr
;
4553 if (! m
->p_paddr_valid
)
4554 p
->p_paddr
= filehdr_paddr
;
4556 else if (m
->includes_phdrs
)
4558 p
->p_vaddr
= phdrs_vaddr
;
4559 if (! m
->p_paddr_valid
)
4560 p
->p_paddr
= phdrs_paddr
;
4562 else if (p
->p_type
== PT_GNU_RELRO
)
4564 Elf_Internal_Phdr
*lp
;
4566 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4568 if (lp
->p_type
== PT_LOAD
4569 && lp
->p_vaddr
<= link_info
->relro_end
4570 && lp
->p_vaddr
>= link_info
->relro_start
4571 && (lp
->p_vaddr
+ lp
->p_filesz
4572 >= link_info
->relro_end
))
4576 if (lp
< phdrs
+ count
4577 && link_info
->relro_end
> lp
->p_vaddr
)
4579 p
->p_vaddr
= lp
->p_vaddr
;
4580 p
->p_paddr
= lp
->p_paddr
;
4581 p
->p_offset
= lp
->p_offset
;
4582 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4583 p
->p_memsz
= p
->p_filesz
;
4585 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4589 memset (p
, 0, sizeof *p
);
4590 p
->p_type
= PT_NULL
;
4596 elf_tdata (abfd
)->next_file_pos
= off
;
4601 /* Work out the file positions of all the sections. This is called by
4602 _bfd_elf_compute_section_file_positions. All the section sizes and
4603 VMAs must be known before this is called.
4605 Reloc sections come in two flavours: Those processed specially as
4606 "side-channel" data attached to a section to which they apply, and
4607 those that bfd doesn't process as relocations. The latter sort are
4608 stored in a normal bfd section by bfd_section_from_shdr. We don't
4609 consider the former sort here, unless they form part of the loadable
4610 image. Reloc sections not assigned here will be handled later by
4611 assign_file_positions_for_relocs.
4613 We also don't set the positions of the .symtab and .strtab here. */
4616 assign_file_positions_except_relocs (bfd
*abfd
,
4617 struct bfd_link_info
*link_info
)
4619 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4620 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4622 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4624 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4625 && bfd_get_format (abfd
) != bfd_core
)
4627 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4628 unsigned int num_sec
= elf_numsections (abfd
);
4629 Elf_Internal_Shdr
**hdrpp
;
4632 /* Start after the ELF header. */
4633 off
= i_ehdrp
->e_ehsize
;
4635 /* We are not creating an executable, which means that we are
4636 not creating a program header, and that the actual order of
4637 the sections in the file is unimportant. */
4638 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4640 Elf_Internal_Shdr
*hdr
;
4643 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4644 && hdr
->bfd_section
== NULL
)
4645 || i
== tdata
->symtab_section
4646 || i
== tdata
->symtab_shndx_section
4647 || i
== tdata
->strtab_section
)
4649 hdr
->sh_offset
= -1;
4652 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4654 if (i
== SHN_LORESERVE
- 1)
4656 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4657 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4665 /* Assign file positions for the loaded sections based on the
4666 assignment of sections to segments. */
4667 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4670 /* And for non-load sections. */
4671 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4674 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4676 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4680 /* Write out the program headers. */
4681 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4682 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4683 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4686 off
= tdata
->next_file_pos
;
4689 /* Place the section headers. */
4690 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4691 i_ehdrp
->e_shoff
= off
;
4692 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4694 tdata
->next_file_pos
= off
;
4700 prep_headers (bfd
*abfd
)
4702 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4703 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4704 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4705 struct elf_strtab_hash
*shstrtab
;
4706 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4708 i_ehdrp
= elf_elfheader (abfd
);
4709 i_shdrp
= elf_elfsections (abfd
);
4711 shstrtab
= _bfd_elf_strtab_init ();
4712 if (shstrtab
== NULL
)
4715 elf_shstrtab (abfd
) = shstrtab
;
4717 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4718 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4719 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4720 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4722 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4723 i_ehdrp
->e_ident
[EI_DATA
] =
4724 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4725 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4727 if ((abfd
->flags
& DYNAMIC
) != 0)
4728 i_ehdrp
->e_type
= ET_DYN
;
4729 else if ((abfd
->flags
& EXEC_P
) != 0)
4730 i_ehdrp
->e_type
= ET_EXEC
;
4731 else if (bfd_get_format (abfd
) == bfd_core
)
4732 i_ehdrp
->e_type
= ET_CORE
;
4734 i_ehdrp
->e_type
= ET_REL
;
4736 switch (bfd_get_arch (abfd
))
4738 case bfd_arch_unknown
:
4739 i_ehdrp
->e_machine
= EM_NONE
;
4742 /* There used to be a long list of cases here, each one setting
4743 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4744 in the corresponding bfd definition. To avoid duplication,
4745 the switch was removed. Machines that need special handling
4746 can generally do it in elf_backend_final_write_processing(),
4747 unless they need the information earlier than the final write.
4748 Such need can generally be supplied by replacing the tests for
4749 e_machine with the conditions used to determine it. */
4751 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
4754 i_ehdrp
->e_version
= bed
->s
->ev_current
;
4755 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
4757 /* No program header, for now. */
4758 i_ehdrp
->e_phoff
= 0;
4759 i_ehdrp
->e_phentsize
= 0;
4760 i_ehdrp
->e_phnum
= 0;
4762 /* Each bfd section is section header entry. */
4763 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
4764 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
4766 /* If we're building an executable, we'll need a program header table. */
4767 if (abfd
->flags
& EXEC_P
)
4768 /* It all happens later. */
4772 i_ehdrp
->e_phentsize
= 0;
4774 i_ehdrp
->e_phoff
= 0;
4777 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
4778 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
4779 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
4780 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
4781 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
4782 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
4783 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4784 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
4785 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
4791 /* Assign file positions for all the reloc sections which are not part
4792 of the loadable file image. */
4795 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
4798 unsigned int i
, num_sec
;
4799 Elf_Internal_Shdr
**shdrpp
;
4801 off
= elf_tdata (abfd
)->next_file_pos
;
4803 num_sec
= elf_numsections (abfd
);
4804 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
4806 Elf_Internal_Shdr
*shdrp
;
4809 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
4810 && shdrp
->sh_offset
== -1)
4811 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
4814 elf_tdata (abfd
)->next_file_pos
= off
;
4818 _bfd_elf_write_object_contents (bfd
*abfd
)
4820 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4821 Elf_Internal_Ehdr
*i_ehdrp
;
4822 Elf_Internal_Shdr
**i_shdrp
;
4824 unsigned int count
, num_sec
;
4826 if (! abfd
->output_has_begun
4827 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
4830 i_shdrp
= elf_elfsections (abfd
);
4831 i_ehdrp
= elf_elfheader (abfd
);
4834 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
4838 _bfd_elf_assign_file_positions_for_relocs (abfd
);
4840 /* After writing the headers, we need to write the sections too... */
4841 num_sec
= elf_numsections (abfd
);
4842 for (count
= 1; count
< num_sec
; count
++)
4844 if (bed
->elf_backend_section_processing
)
4845 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
4846 if (i_shdrp
[count
]->contents
)
4848 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
4850 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
4851 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
4854 if (count
== SHN_LORESERVE
- 1)
4855 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4858 /* Write out the section header names. */
4859 if (elf_shstrtab (abfd
) != NULL
4860 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
4861 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
4864 if (bed
->elf_backend_final_write_processing
)
4865 (*bed
->elf_backend_final_write_processing
) (abfd
,
4866 elf_tdata (abfd
)->linker
);
4868 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
4871 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
4872 if (elf_tdata (abfd
)->after_write_object_contents
)
4873 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
4879 _bfd_elf_write_corefile_contents (bfd
*abfd
)
4881 /* Hopefully this can be done just like an object file. */
4882 return _bfd_elf_write_object_contents (abfd
);
4885 /* Given a section, search the header to find them. */
4888 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
4890 const struct elf_backend_data
*bed
;
4893 if (elf_section_data (asect
) != NULL
4894 && elf_section_data (asect
)->this_idx
!= 0)
4895 return elf_section_data (asect
)->this_idx
;
4897 if (bfd_is_abs_section (asect
))
4899 else if (bfd_is_com_section (asect
))
4901 else if (bfd_is_und_section (asect
))
4906 bed
= get_elf_backend_data (abfd
);
4907 if (bed
->elf_backend_section_from_bfd_section
)
4911 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
4916 bfd_set_error (bfd_error_nonrepresentable_section
);
4921 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4925 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
4927 asymbol
*asym_ptr
= *asym_ptr_ptr
;
4929 flagword flags
= asym_ptr
->flags
;
4931 /* When gas creates relocations against local labels, it creates its
4932 own symbol for the section, but does put the symbol into the
4933 symbol chain, so udata is 0. When the linker is generating
4934 relocatable output, this section symbol may be for one of the
4935 input sections rather than the output section. */
4936 if (asym_ptr
->udata
.i
== 0
4937 && (flags
& BSF_SECTION_SYM
)
4938 && asym_ptr
->section
)
4943 sec
= asym_ptr
->section
;
4944 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
4945 sec
= sec
->output_section
;
4946 if (sec
->owner
== abfd
4947 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
4948 && elf_section_syms (abfd
)[indx
] != NULL
)
4949 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
4952 idx
= asym_ptr
->udata
.i
;
4956 /* This case can occur when using --strip-symbol on a symbol
4957 which is used in a relocation entry. */
4958 (*_bfd_error_handler
)
4959 (_("%B: symbol `%s' required but not present"),
4960 abfd
, bfd_asymbol_name (asym_ptr
));
4961 bfd_set_error (bfd_error_no_symbols
);
4968 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4969 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
4970 elf_symbol_flags (flags
));
4978 /* Rewrite program header information. */
4981 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
4983 Elf_Internal_Ehdr
*iehdr
;
4984 struct elf_segment_map
*map
;
4985 struct elf_segment_map
*map_first
;
4986 struct elf_segment_map
**pointer_to_map
;
4987 Elf_Internal_Phdr
*segment
;
4990 unsigned int num_segments
;
4991 bfd_boolean phdr_included
= FALSE
;
4992 bfd_vma maxpagesize
;
4993 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
4994 unsigned int phdr_adjust_num
= 0;
4995 const struct elf_backend_data
*bed
;
4997 bed
= get_elf_backend_data (ibfd
);
4998 iehdr
= elf_elfheader (ibfd
);
5001 pointer_to_map
= &map_first
;
5003 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5004 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5006 /* Returns the end address of the segment + 1. */
5007 #define SEGMENT_END(segment, start) \
5008 (start + (segment->p_memsz > segment->p_filesz \
5009 ? segment->p_memsz : segment->p_filesz))
5011 #define SECTION_SIZE(section, segment) \
5012 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5013 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5014 ? section->size : 0)
5016 /* Returns TRUE if the given section is contained within
5017 the given segment. VMA addresses are compared. */
5018 #define IS_CONTAINED_BY_VMA(section, segment) \
5019 (section->vma >= segment->p_vaddr \
5020 && (section->vma + SECTION_SIZE (section, segment) \
5021 <= (SEGMENT_END (segment, segment->p_vaddr))))
5023 /* Returns TRUE if the given section is contained within
5024 the given segment. LMA addresses are compared. */
5025 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5026 (section->lma >= base \
5027 && (section->lma + SECTION_SIZE (section, segment) \
5028 <= SEGMENT_END (segment, base)))
5030 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5031 #define IS_COREFILE_NOTE(p, s) \
5032 (p->p_type == PT_NOTE \
5033 && bfd_get_format (ibfd) == bfd_core \
5034 && s->vma == 0 && s->lma == 0 \
5035 && (bfd_vma) s->filepos >= p->p_offset \
5036 && ((bfd_vma) s->filepos + s->size \
5037 <= p->p_offset + p->p_filesz))
5039 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5040 linker, which generates a PT_INTERP section with p_vaddr and
5041 p_memsz set to 0. */
5042 #define IS_SOLARIS_PT_INTERP(p, s) \
5044 && p->p_paddr == 0 \
5045 && p->p_memsz == 0 \
5046 && p->p_filesz > 0 \
5047 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5049 && (bfd_vma) s->filepos >= p->p_offset \
5050 && ((bfd_vma) s->filepos + s->size \
5051 <= p->p_offset + p->p_filesz))
5053 /* Decide if the given section should be included in the given segment.
5054 A section will be included if:
5055 1. It is within the address space of the segment -- we use the LMA
5056 if that is set for the segment and the VMA otherwise,
5057 2. It is an allocated segment,
5058 3. There is an output section associated with it,
5059 4. The section has not already been allocated to a previous segment.
5060 5. PT_GNU_STACK segments do not include any sections.
5061 6. PT_TLS segment includes only SHF_TLS sections.
5062 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5063 8. PT_DYNAMIC should not contain empty sections at the beginning
5064 (with the possible exception of .dynamic). */
5065 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5066 ((((segment->p_paddr \
5067 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5068 : IS_CONTAINED_BY_VMA (section, segment)) \
5069 && (section->flags & SEC_ALLOC) != 0) \
5070 || IS_COREFILE_NOTE (segment, section)) \
5071 && segment->p_type != PT_GNU_STACK \
5072 && (segment->p_type != PT_TLS \
5073 || (section->flags & SEC_THREAD_LOCAL)) \
5074 && (segment->p_type == PT_LOAD \
5075 || segment->p_type == PT_TLS \
5076 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5077 && (segment->p_type != PT_DYNAMIC \
5078 || SECTION_SIZE (section, segment) > 0 \
5079 || (segment->p_paddr \
5080 ? segment->p_paddr != section->lma \
5081 : segment->p_vaddr != section->vma) \
5082 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5084 && ! section->segment_mark)
5086 /* If the output section of a section in the input segment is NULL,
5087 it is removed from the corresponding output segment. */
5088 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5089 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5090 && section->output_section != NULL)
5092 /* Returns TRUE iff seg1 starts after the end of seg2. */
5093 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5094 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5096 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5097 their VMA address ranges and their LMA address ranges overlap.
5098 It is possible to have overlapping VMA ranges without overlapping LMA
5099 ranges. RedBoot images for example can have both .data and .bss mapped
5100 to the same VMA range, but with the .data section mapped to a different
5102 #define SEGMENT_OVERLAPS(seg1, seg2) \
5103 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5104 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5105 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5106 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5108 /* Initialise the segment mark field. */
5109 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5110 section
->segment_mark
= FALSE
;
5112 /* Scan through the segments specified in the program header
5113 of the input BFD. For this first scan we look for overlaps
5114 in the loadable segments. These can be created by weird
5115 parameters to objcopy. Also, fix some solaris weirdness. */
5116 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5121 Elf_Internal_Phdr
*segment2
;
5123 if (segment
->p_type
== PT_INTERP
)
5124 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5125 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5127 /* Mininal change so that the normal section to segment
5128 assignment code will work. */
5129 segment
->p_vaddr
= section
->vma
;
5133 if (segment
->p_type
!= PT_LOAD
)
5136 /* Determine if this segment overlaps any previous segments. */
5137 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5139 bfd_signed_vma extra_length
;
5141 if (segment2
->p_type
!= PT_LOAD
5142 || ! SEGMENT_OVERLAPS (segment
, segment2
))
5145 /* Merge the two segments together. */
5146 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5148 /* Extend SEGMENT2 to include SEGMENT and then delete
5151 SEGMENT_END (segment
, segment
->p_vaddr
)
5152 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
5154 if (extra_length
> 0)
5156 segment2
->p_memsz
+= extra_length
;
5157 segment2
->p_filesz
+= extra_length
;
5160 segment
->p_type
= PT_NULL
;
5162 /* Since we have deleted P we must restart the outer loop. */
5164 segment
= elf_tdata (ibfd
)->phdr
;
5169 /* Extend SEGMENT to include SEGMENT2 and then delete
5172 SEGMENT_END (segment2
, segment2
->p_vaddr
)
5173 - SEGMENT_END (segment
, segment
->p_vaddr
);
5175 if (extra_length
> 0)
5177 segment
->p_memsz
+= extra_length
;
5178 segment
->p_filesz
+= extra_length
;
5181 segment2
->p_type
= PT_NULL
;
5186 /* The second scan attempts to assign sections to segments. */
5187 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5191 unsigned int section_count
;
5192 asection
** sections
;
5193 asection
* output_section
;
5195 bfd_vma matching_lma
;
5196 bfd_vma suggested_lma
;
5199 asection
* first_section
;
5201 if (segment
->p_type
== PT_NULL
)
5204 first_section
= NULL
;
5205 /* Compute how many sections might be placed into this segment. */
5206 for (section
= ibfd
->sections
, section_count
= 0;
5208 section
= section
->next
)
5210 /* Find the first section in the input segment, which may be
5211 removed from the corresponding output segment. */
5212 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5214 if (first_section
== NULL
)
5215 first_section
= section
;
5216 if (section
->output_section
!= NULL
)
5221 /* Allocate a segment map big enough to contain
5222 all of the sections we have selected. */
5223 amt
= sizeof (struct elf_segment_map
);
5224 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5225 map
= bfd_zalloc (obfd
, amt
);
5229 /* Initialise the fields of the segment map. Default to
5230 using the physical address of the segment in the input BFD. */
5232 map
->p_type
= segment
->p_type
;
5233 map
->p_flags
= segment
->p_flags
;
5234 map
->p_flags_valid
= 1;
5236 /* If the first section in the input segment is removed, there is
5237 no need to preserve segment physical address in the corresponding
5239 if (!first_section
|| first_section
->output_section
!= NULL
)
5241 map
->p_paddr
= segment
->p_paddr
;
5242 map
->p_paddr_valid
= 1;
5245 /* Determine if this segment contains the ELF file header
5246 and if it contains the program headers themselves. */
5247 map
->includes_filehdr
= (segment
->p_offset
== 0
5248 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5250 map
->includes_phdrs
= 0;
5252 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5254 map
->includes_phdrs
=
5255 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5256 && (segment
->p_offset
+ segment
->p_filesz
5257 >= ((bfd_vma
) iehdr
->e_phoff
5258 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5260 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5261 phdr_included
= TRUE
;
5264 if (section_count
== 0)
5266 /* Special segments, such as the PT_PHDR segment, may contain
5267 no sections, but ordinary, loadable segments should contain
5268 something. They are allowed by the ELF spec however, so only
5269 a warning is produced. */
5270 if (segment
->p_type
== PT_LOAD
)
5271 (*_bfd_error_handler
)
5272 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5276 *pointer_to_map
= map
;
5277 pointer_to_map
= &map
->next
;
5282 /* Now scan the sections in the input BFD again and attempt
5283 to add their corresponding output sections to the segment map.
5284 The problem here is how to handle an output section which has
5285 been moved (ie had its LMA changed). There are four possibilities:
5287 1. None of the sections have been moved.
5288 In this case we can continue to use the segment LMA from the
5291 2. All of the sections have been moved by the same amount.
5292 In this case we can change the segment's LMA to match the LMA
5293 of the first section.
5295 3. Some of the sections have been moved, others have not.
5296 In this case those sections which have not been moved can be
5297 placed in the current segment which will have to have its size,
5298 and possibly its LMA changed, and a new segment or segments will
5299 have to be created to contain the other sections.
5301 4. The sections have been moved, but not by the same amount.
5302 In this case we can change the segment's LMA to match the LMA
5303 of the first section and we will have to create a new segment
5304 or segments to contain the other sections.
5306 In order to save time, we allocate an array to hold the section
5307 pointers that we are interested in. As these sections get assigned
5308 to a segment, they are removed from this array. */
5310 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5311 to work around this long long bug. */
5312 sections
= bfd_malloc2 (section_count
, sizeof (asection
*));
5313 if (sections
== NULL
)
5316 /* Step One: Scan for segment vs section LMA conflicts.
5317 Also add the sections to the section array allocated above.
5318 Also add the sections to the current segment. In the common
5319 case, where the sections have not been moved, this means that
5320 we have completely filled the segment, and there is nothing
5326 for (j
= 0, section
= ibfd
->sections
;
5328 section
= section
->next
)
5330 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5332 output_section
= section
->output_section
;
5334 sections
[j
++] = section
;
5336 /* The Solaris native linker always sets p_paddr to 0.
5337 We try to catch that case here, and set it to the
5338 correct value. Note - some backends require that
5339 p_paddr be left as zero. */
5340 if (segment
->p_paddr
== 0
5341 && segment
->p_vaddr
!= 0
5342 && (! bed
->want_p_paddr_set_to_zero
)
5344 && output_section
->lma
!= 0
5345 && (output_section
->vma
== (segment
->p_vaddr
5346 + (map
->includes_filehdr
5349 + (map
->includes_phdrs
5351 * iehdr
->e_phentsize
)
5353 map
->p_paddr
= segment
->p_vaddr
;
5355 /* Match up the physical address of the segment with the
5356 LMA address of the output section. */
5357 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5358 || IS_COREFILE_NOTE (segment
, section
)
5359 || (bed
->want_p_paddr_set_to_zero
&&
5360 IS_CONTAINED_BY_VMA (output_section
, segment
)))
5362 if (matching_lma
== 0 || output_section
->lma
< matching_lma
)
5363 matching_lma
= output_section
->lma
;
5365 /* We assume that if the section fits within the segment
5366 then it does not overlap any other section within that
5368 map
->sections
[isec
++] = output_section
;
5370 else if (suggested_lma
== 0)
5371 suggested_lma
= output_section
->lma
;
5375 BFD_ASSERT (j
== section_count
);
5377 /* Step Two: Adjust the physical address of the current segment,
5379 if (isec
== section_count
)
5381 /* All of the sections fitted within the segment as currently
5382 specified. This is the default case. Add the segment to
5383 the list of built segments and carry on to process the next
5384 program header in the input BFD. */
5385 map
->count
= section_count
;
5386 *pointer_to_map
= map
;
5387 pointer_to_map
= &map
->next
;
5389 if (matching_lma
!= map
->p_paddr
5390 && !map
->includes_filehdr
&& !map
->includes_phdrs
)
5391 /* There is some padding before the first section in the
5392 segment. So, we must account for that in the output
5394 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5401 if (matching_lma
!= 0)
5403 /* At least one section fits inside the current segment.
5404 Keep it, but modify its physical address to match the
5405 LMA of the first section that fitted. */
5406 map
->p_paddr
= matching_lma
;
5410 /* None of the sections fitted inside the current segment.
5411 Change the current segment's physical address to match
5412 the LMA of the first section. */
5413 map
->p_paddr
= suggested_lma
;
5416 /* Offset the segment physical address from the lma
5417 to allow for space taken up by elf headers. */
5418 if (map
->includes_filehdr
)
5419 map
->p_paddr
-= iehdr
->e_ehsize
;
5421 if (map
->includes_phdrs
)
5423 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5425 /* iehdr->e_phnum is just an estimate of the number
5426 of program headers that we will need. Make a note
5427 here of the number we used and the segment we chose
5428 to hold these headers, so that we can adjust the
5429 offset when we know the correct value. */
5430 phdr_adjust_num
= iehdr
->e_phnum
;
5431 phdr_adjust_seg
= map
;
5435 /* Step Three: Loop over the sections again, this time assigning
5436 those that fit to the current segment and removing them from the
5437 sections array; but making sure not to leave large gaps. Once all
5438 possible sections have been assigned to the current segment it is
5439 added to the list of built segments and if sections still remain
5440 to be assigned, a new segment is constructed before repeating
5448 /* Fill the current segment with sections that fit. */
5449 for (j
= 0; j
< section_count
; j
++)
5451 section
= sections
[j
];
5453 if (section
== NULL
)
5456 output_section
= section
->output_section
;
5458 BFD_ASSERT (output_section
!= NULL
);
5460 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5461 || IS_COREFILE_NOTE (segment
, section
))
5463 if (map
->count
== 0)
5465 /* If the first section in a segment does not start at
5466 the beginning of the segment, then something is
5468 if (output_section
->lma
!=
5470 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5471 + (map
->includes_phdrs
5472 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5478 asection
* prev_sec
;
5480 prev_sec
= map
->sections
[map
->count
- 1];
5482 /* If the gap between the end of the previous section
5483 and the start of this section is more than
5484 maxpagesize then we need to start a new segment. */
5485 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5487 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5488 || ((prev_sec
->lma
+ prev_sec
->size
)
5489 > output_section
->lma
))
5491 if (suggested_lma
== 0)
5492 suggested_lma
= output_section
->lma
;
5498 map
->sections
[map
->count
++] = output_section
;
5501 section
->segment_mark
= TRUE
;
5503 else if (suggested_lma
== 0)
5504 suggested_lma
= output_section
->lma
;
5507 BFD_ASSERT (map
->count
> 0);
5509 /* Add the current segment to the list of built segments. */
5510 *pointer_to_map
= map
;
5511 pointer_to_map
= &map
->next
;
5513 if (isec
< section_count
)
5515 /* We still have not allocated all of the sections to
5516 segments. Create a new segment here, initialise it
5517 and carry on looping. */
5518 amt
= sizeof (struct elf_segment_map
);
5519 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5520 map
= bfd_alloc (obfd
, amt
);
5527 /* Initialise the fields of the segment map. Set the physical
5528 physical address to the LMA of the first section that has
5529 not yet been assigned. */
5531 map
->p_type
= segment
->p_type
;
5532 map
->p_flags
= segment
->p_flags
;
5533 map
->p_flags_valid
= 1;
5534 map
->p_paddr
= suggested_lma
;
5535 map
->p_paddr_valid
= 1;
5536 map
->includes_filehdr
= 0;
5537 map
->includes_phdrs
= 0;
5540 while (isec
< section_count
);
5545 /* The Solaris linker creates program headers in which all the
5546 p_paddr fields are zero. When we try to objcopy or strip such a
5547 file, we get confused. Check for this case, and if we find it
5548 reset the p_paddr_valid fields. */
5549 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5550 if (map
->p_paddr
!= 0)
5553 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5554 map
->p_paddr_valid
= 0;
5556 elf_tdata (obfd
)->segment_map
= map_first
;
5558 /* If we had to estimate the number of program headers that were
5559 going to be needed, then check our estimate now and adjust
5560 the offset if necessary. */
5561 if (phdr_adjust_seg
!= NULL
)
5565 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5568 if (count
> phdr_adjust_num
)
5569 phdr_adjust_seg
->p_paddr
5570 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5575 #undef IS_CONTAINED_BY_VMA
5576 #undef IS_CONTAINED_BY_LMA
5577 #undef IS_COREFILE_NOTE
5578 #undef IS_SOLARIS_PT_INTERP
5579 #undef IS_SECTION_IN_INPUT_SEGMENT
5580 #undef INCLUDE_SECTION_IN_SEGMENT
5581 #undef SEGMENT_AFTER_SEGMENT
5582 #undef SEGMENT_OVERLAPS
5586 /* Copy ELF program header information. */
5589 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5591 Elf_Internal_Ehdr
*iehdr
;
5592 struct elf_segment_map
*map
;
5593 struct elf_segment_map
*map_first
;
5594 struct elf_segment_map
**pointer_to_map
;
5595 Elf_Internal_Phdr
*segment
;
5597 unsigned int num_segments
;
5598 bfd_boolean phdr_included
= FALSE
;
5600 iehdr
= elf_elfheader (ibfd
);
5603 pointer_to_map
= &map_first
;
5605 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5606 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5611 unsigned int section_count
;
5613 Elf_Internal_Shdr
*this_hdr
;
5614 asection
*first_section
= NULL
;
5615 asection
*lowest_section
= NULL
;
5617 /* FIXME: Do we need to copy PT_NULL segment? */
5618 if (segment
->p_type
== PT_NULL
)
5621 /* Compute how many sections are in this segment. */
5622 for (section
= ibfd
->sections
, section_count
= 0;
5624 section
= section
->next
)
5626 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5627 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5630 first_section
= lowest_section
= section
;
5631 if (section
->lma
< lowest_section
->lma
)
5632 lowest_section
= section
;
5637 /* Allocate a segment map big enough to contain
5638 all of the sections we have selected. */
5639 amt
= sizeof (struct elf_segment_map
);
5640 if (section_count
!= 0)
5641 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5642 map
= bfd_zalloc (obfd
, amt
);
5646 /* Initialize the fields of the output segment map with the
5649 map
->p_type
= segment
->p_type
;
5650 map
->p_flags
= segment
->p_flags
;
5651 map
->p_flags_valid
= 1;
5652 map
->p_paddr
= segment
->p_paddr
;
5653 map
->p_paddr_valid
= 1;
5654 map
->p_align
= segment
->p_align
;
5655 map
->p_align_valid
= 1;
5656 map
->p_vaddr_offset
= 0;
5658 /* Determine if this segment contains the ELF file header
5659 and if it contains the program headers themselves. */
5660 map
->includes_filehdr
= (segment
->p_offset
== 0
5661 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5663 map
->includes_phdrs
= 0;
5664 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5666 map
->includes_phdrs
=
5667 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5668 && (segment
->p_offset
+ segment
->p_filesz
5669 >= ((bfd_vma
) iehdr
->e_phoff
5670 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5672 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5673 phdr_included
= TRUE
;
5676 if (!map
->includes_phdrs
&& !map
->includes_filehdr
)
5677 /* There is some other padding before the first section. */
5678 map
->p_vaddr_offset
= ((lowest_section
? lowest_section
->lma
: 0)
5679 - segment
->p_paddr
);
5681 if (section_count
!= 0)
5683 unsigned int isec
= 0;
5685 for (section
= first_section
;
5687 section
= section
->next
)
5689 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5690 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5692 map
->sections
[isec
++] = section
->output_section
;
5693 if (isec
== section_count
)
5699 map
->count
= section_count
;
5700 *pointer_to_map
= map
;
5701 pointer_to_map
= &map
->next
;
5704 elf_tdata (obfd
)->segment_map
= map_first
;
5708 /* Copy private BFD data. This copies or rewrites ELF program header
5712 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5714 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5715 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5718 if (elf_tdata (ibfd
)->phdr
== NULL
)
5721 if (ibfd
->xvec
== obfd
->xvec
)
5723 /* Check to see if any sections in the input BFD
5724 covered by ELF program header have changed. */
5725 Elf_Internal_Phdr
*segment
;
5726 asection
*section
, *osec
;
5727 unsigned int i
, num_segments
;
5728 Elf_Internal_Shdr
*this_hdr
;
5730 /* Initialize the segment mark field. */
5731 for (section
= obfd
->sections
; section
!= NULL
;
5732 section
= section
->next
)
5733 section
->segment_mark
= FALSE
;
5735 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5736 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5740 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5741 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5742 which severly confuses things, so always regenerate the segment
5743 map in this case. */
5744 if (segment
->p_paddr
== 0
5745 && segment
->p_memsz
== 0
5746 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
5749 for (section
= ibfd
->sections
;
5750 section
!= NULL
; section
= section
->next
)
5752 /* We mark the output section so that we know it comes
5753 from the input BFD. */
5754 osec
= section
->output_section
;
5756 osec
->segment_mark
= TRUE
;
5758 /* Check if this section is covered by the segment. */
5759 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5760 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5762 /* FIXME: Check if its output section is changed or
5763 removed. What else do we need to check? */
5765 || section
->flags
!= osec
->flags
5766 || section
->lma
!= osec
->lma
5767 || section
->vma
!= osec
->vma
5768 || section
->size
!= osec
->size
5769 || section
->rawsize
!= osec
->rawsize
5770 || section
->alignment_power
!= osec
->alignment_power
)
5776 /* Check to see if any output section do not come from the
5778 for (section
= obfd
->sections
; section
!= NULL
;
5779 section
= section
->next
)
5781 if (section
->segment_mark
== FALSE
)
5784 section
->segment_mark
= FALSE
;
5787 return copy_elf_program_header (ibfd
, obfd
);
5791 return rewrite_elf_program_header (ibfd
, obfd
);
5794 /* Initialize private output section information from input section. */
5797 _bfd_elf_init_private_section_data (bfd
*ibfd
,
5801 struct bfd_link_info
*link_info
)
5804 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5805 bfd_boolean need_group
= link_info
== NULL
|| link_info
->relocatable
;
5807 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5808 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5811 /* Don't copy the output ELF section type from input if the
5812 output BFD section flags have been set to something different.
5813 elf_fake_sections will set ELF section type based on BFD
5815 if (elf_section_type (osec
) == SHT_NULL
5816 && (osec
->flags
== isec
->flags
|| !osec
->flags
))
5817 elf_section_type (osec
) = elf_section_type (isec
);
5819 /* FIXME: Is this correct for all OS/PROC specific flags? */
5820 elf_section_flags (osec
) |= (elf_section_flags (isec
)
5821 & (SHF_MASKOS
| SHF_MASKPROC
));
5823 /* Set things up for objcopy and relocatable link. The output
5824 SHT_GROUP section will have its elf_next_in_group pointing back
5825 to the input group members. Ignore linker created group section.
5826 See elfNN_ia64_object_p in elfxx-ia64.c. */
5829 if (elf_sec_group (isec
) == NULL
5830 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
5832 if (elf_section_flags (isec
) & SHF_GROUP
)
5833 elf_section_flags (osec
) |= SHF_GROUP
;
5834 elf_next_in_group (osec
) = elf_next_in_group (isec
);
5835 elf_group_name (osec
) = elf_group_name (isec
);
5839 ihdr
= &elf_section_data (isec
)->this_hdr
;
5841 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5842 don't use the output section of the linked-to section since it
5843 may be NULL at this point. */
5844 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
5846 ohdr
= &elf_section_data (osec
)->this_hdr
;
5847 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
5848 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
5851 osec
->use_rela_p
= isec
->use_rela_p
;
5856 /* Copy private section information. This copies over the entsize
5857 field, and sometimes the info field. */
5860 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
5865 Elf_Internal_Shdr
*ihdr
, *ohdr
;
5867 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
5868 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
5871 ihdr
= &elf_section_data (isec
)->this_hdr
;
5872 ohdr
= &elf_section_data (osec
)->this_hdr
;
5874 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
5876 if (ihdr
->sh_type
== SHT_SYMTAB
5877 || ihdr
->sh_type
== SHT_DYNSYM
5878 || ihdr
->sh_type
== SHT_GNU_verneed
5879 || ihdr
->sh_type
== SHT_GNU_verdef
)
5880 ohdr
->sh_info
= ihdr
->sh_info
;
5882 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
5886 /* Copy private header information. */
5889 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
5893 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5894 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5897 /* Copy over private BFD data if it has not already been copied.
5898 This must be done here, rather than in the copy_private_bfd_data
5899 entry point, because the latter is called after the section
5900 contents have been set, which means that the program headers have
5901 already been worked out. */
5902 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
5904 if (! copy_private_bfd_data (ibfd
, obfd
))
5908 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
5909 but this might be wrong if we deleted the group section. */
5910 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
5911 if (elf_section_type (isec
) == SHT_GROUP
5912 && isec
->output_section
== NULL
)
5914 asection
*first
= elf_next_in_group (isec
);
5915 asection
*s
= first
;
5918 if (s
->output_section
!= NULL
)
5920 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
5921 elf_group_name (s
->output_section
) = NULL
;
5923 s
= elf_next_in_group (s
);
5932 /* Copy private symbol information. If this symbol is in a section
5933 which we did not map into a BFD section, try to map the section
5934 index correctly. We use special macro definitions for the mapped
5935 section indices; these definitions are interpreted by the
5936 swap_out_syms function. */
5938 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5939 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5940 #define MAP_STRTAB (SHN_HIOS + 3)
5941 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5942 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5945 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
5950 elf_symbol_type
*isym
, *osym
;
5952 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5953 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5956 isym
= elf_symbol_from (ibfd
, isymarg
);
5957 osym
= elf_symbol_from (obfd
, osymarg
);
5961 && bfd_is_abs_section (isym
->symbol
.section
))
5965 shndx
= isym
->internal_elf_sym
.st_shndx
;
5966 if (shndx
== elf_onesymtab (ibfd
))
5967 shndx
= MAP_ONESYMTAB
;
5968 else if (shndx
== elf_dynsymtab (ibfd
))
5969 shndx
= MAP_DYNSYMTAB
;
5970 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
5972 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
5973 shndx
= MAP_SHSTRTAB
;
5974 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
5975 shndx
= MAP_SYM_SHNDX
;
5976 osym
->internal_elf_sym
.st_shndx
= shndx
;
5982 /* Swap out the symbols. */
5985 swap_out_syms (bfd
*abfd
,
5986 struct bfd_strtab_hash
**sttp
,
5989 const struct elf_backend_data
*bed
;
5992 struct bfd_strtab_hash
*stt
;
5993 Elf_Internal_Shdr
*symtab_hdr
;
5994 Elf_Internal_Shdr
*symtab_shndx_hdr
;
5995 Elf_Internal_Shdr
*symstrtab_hdr
;
5996 bfd_byte
*outbound_syms
;
5997 bfd_byte
*outbound_shndx
;
6000 bfd_boolean name_local_sections
;
6002 if (!elf_map_symbols (abfd
))
6005 /* Dump out the symtabs. */
6006 stt
= _bfd_elf_stringtab_init ();
6010 bed
= get_elf_backend_data (abfd
);
6011 symcount
= bfd_get_symcount (abfd
);
6012 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6013 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6014 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6015 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6016 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6017 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
6019 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6020 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6022 outbound_syms
= bfd_alloc2 (abfd
, 1 + symcount
, bed
->s
->sizeof_sym
);
6023 if (outbound_syms
== NULL
)
6025 _bfd_stringtab_free (stt
);
6028 symtab_hdr
->contents
= outbound_syms
;
6030 outbound_shndx
= NULL
;
6031 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6032 if (symtab_shndx_hdr
->sh_name
!= 0)
6034 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6035 outbound_shndx
= bfd_zalloc2 (abfd
, 1 + symcount
,
6036 sizeof (Elf_External_Sym_Shndx
));
6037 if (outbound_shndx
== NULL
)
6039 _bfd_stringtab_free (stt
);
6043 symtab_shndx_hdr
->contents
= outbound_shndx
;
6044 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6045 symtab_shndx_hdr
->sh_size
= amt
;
6046 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6047 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6050 /* Now generate the data (for "contents"). */
6052 /* Fill in zeroth symbol and swap it out. */
6053 Elf_Internal_Sym sym
;
6059 sym
.st_shndx
= SHN_UNDEF
;
6060 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6061 outbound_syms
+= bed
->s
->sizeof_sym
;
6062 if (outbound_shndx
!= NULL
)
6063 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6067 = (bed
->elf_backend_name_local_section_symbols
6068 && bed
->elf_backend_name_local_section_symbols (abfd
));
6070 syms
= bfd_get_outsymbols (abfd
);
6071 for (idx
= 0; idx
< symcount
; idx
++)
6073 Elf_Internal_Sym sym
;
6074 bfd_vma value
= syms
[idx
]->value
;
6075 elf_symbol_type
*type_ptr
;
6076 flagword flags
= syms
[idx
]->flags
;
6079 if (!name_local_sections
6080 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6082 /* Local section symbols have no name. */
6087 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6090 if (sym
.st_name
== (unsigned long) -1)
6092 _bfd_stringtab_free (stt
);
6097 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6099 if ((flags
& BSF_SECTION_SYM
) == 0
6100 && bfd_is_com_section (syms
[idx
]->section
))
6102 /* ELF common symbols put the alignment into the `value' field,
6103 and the size into the `size' field. This is backwards from
6104 how BFD handles it, so reverse it here. */
6105 sym
.st_size
= value
;
6106 if (type_ptr
== NULL
6107 || type_ptr
->internal_elf_sym
.st_value
== 0)
6108 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6110 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6111 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6112 (abfd
, syms
[idx
]->section
);
6116 asection
*sec
= syms
[idx
]->section
;
6119 if (sec
->output_section
)
6121 value
+= sec
->output_offset
;
6122 sec
= sec
->output_section
;
6125 /* Don't add in the section vma for relocatable output. */
6126 if (! relocatable_p
)
6128 sym
.st_value
= value
;
6129 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6131 if (bfd_is_abs_section (sec
)
6133 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6135 /* This symbol is in a real ELF section which we did
6136 not create as a BFD section. Undo the mapping done
6137 by copy_private_symbol_data. */
6138 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6142 shndx
= elf_onesymtab (abfd
);
6145 shndx
= elf_dynsymtab (abfd
);
6148 shndx
= elf_tdata (abfd
)->strtab_section
;
6151 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6154 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6162 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6168 /* Writing this would be a hell of a lot easier if
6169 we had some decent documentation on bfd, and
6170 knew what to expect of the library, and what to
6171 demand of applications. For example, it
6172 appears that `objcopy' might not set the
6173 section of a symbol to be a section that is
6174 actually in the output file. */
6175 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6178 _bfd_error_handler (_("\
6179 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6180 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6182 bfd_set_error (bfd_error_invalid_operation
);
6183 _bfd_stringtab_free (stt
);
6187 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6188 BFD_ASSERT (shndx
!= -1);
6192 sym
.st_shndx
= shndx
;
6195 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6197 else if ((flags
& BSF_FUNCTION
) != 0)
6199 else if ((flags
& BSF_OBJECT
) != 0)
6201 else if ((flags
& BSF_RELC
) != 0)
6203 else if ((flags
& BSF_SRELC
) != 0)
6208 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6211 /* Processor-specific types. */
6212 if (type_ptr
!= NULL
6213 && bed
->elf_backend_get_symbol_type
)
6214 type
= ((*bed
->elf_backend_get_symbol_type
)
6215 (&type_ptr
->internal_elf_sym
, type
));
6217 if (flags
& BSF_SECTION_SYM
)
6219 if (flags
& BSF_GLOBAL
)
6220 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6222 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6224 else if (bfd_is_com_section (syms
[idx
]->section
))
6225 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
6226 else if (bfd_is_und_section (syms
[idx
]->section
))
6227 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6231 else if (flags
& BSF_FILE
)
6232 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6235 int bind
= STB_LOCAL
;
6237 if (flags
& BSF_LOCAL
)
6239 else if (flags
& BSF_WEAK
)
6241 else if (flags
& BSF_GLOBAL
)
6244 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6247 if (type_ptr
!= NULL
)
6248 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6252 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6253 outbound_syms
+= bed
->s
->sizeof_sym
;
6254 if (outbound_shndx
!= NULL
)
6255 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6259 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6260 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6262 symstrtab_hdr
->sh_flags
= 0;
6263 symstrtab_hdr
->sh_addr
= 0;
6264 symstrtab_hdr
->sh_entsize
= 0;
6265 symstrtab_hdr
->sh_link
= 0;
6266 symstrtab_hdr
->sh_info
= 0;
6267 symstrtab_hdr
->sh_addralign
= 1;
6272 /* Return the number of bytes required to hold the symtab vector.
6274 Note that we base it on the count plus 1, since we will null terminate
6275 the vector allocated based on this size. However, the ELF symbol table
6276 always has a dummy entry as symbol #0, so it ends up even. */
6279 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6283 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6285 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6286 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6288 symtab_size
-= sizeof (asymbol
*);
6294 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6298 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6300 if (elf_dynsymtab (abfd
) == 0)
6302 bfd_set_error (bfd_error_invalid_operation
);
6306 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6307 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6309 symtab_size
-= sizeof (asymbol
*);
6315 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6318 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6321 /* Canonicalize the relocs. */
6324 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6331 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6333 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6336 tblptr
= section
->relocation
;
6337 for (i
= 0; i
< section
->reloc_count
; i
++)
6338 *relptr
++ = tblptr
++;
6342 return section
->reloc_count
;
6346 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6348 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6349 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6352 bfd_get_symcount (abfd
) = symcount
;
6357 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6358 asymbol
**allocation
)
6360 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6361 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6364 bfd_get_dynamic_symcount (abfd
) = symcount
;
6368 /* Return the size required for the dynamic reloc entries. Any loadable
6369 section that was actually installed in the BFD, and has type SHT_REL
6370 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6371 dynamic reloc section. */
6374 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6379 if (elf_dynsymtab (abfd
) == 0)
6381 bfd_set_error (bfd_error_invalid_operation
);
6385 ret
= sizeof (arelent
*);
6386 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6387 if ((s
->flags
& SEC_LOAD
) != 0
6388 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6389 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6390 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6391 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6392 * sizeof (arelent
*));
6397 /* Canonicalize the dynamic relocation entries. Note that we return the
6398 dynamic relocations as a single block, although they are actually
6399 associated with particular sections; the interface, which was
6400 designed for SunOS style shared libraries, expects that there is only
6401 one set of dynamic relocs. Any loadable section that was actually
6402 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6403 dynamic symbol table, is considered to be a dynamic reloc section. */
6406 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6410 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6414 if (elf_dynsymtab (abfd
) == 0)
6416 bfd_set_error (bfd_error_invalid_operation
);
6420 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6422 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6424 if ((s
->flags
& SEC_LOAD
) != 0
6425 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6426 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6427 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6432 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6434 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6436 for (i
= 0; i
< count
; i
++)
6447 /* Read in the version information. */
6450 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6452 bfd_byte
*contents
= NULL
;
6453 unsigned int freeidx
= 0;
6455 if (elf_dynverref (abfd
) != 0)
6457 Elf_Internal_Shdr
*hdr
;
6458 Elf_External_Verneed
*everneed
;
6459 Elf_Internal_Verneed
*iverneed
;
6461 bfd_byte
*contents_end
;
6463 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6465 elf_tdata (abfd
)->verref
= bfd_zalloc2 (abfd
, hdr
->sh_info
,
6466 sizeof (Elf_Internal_Verneed
));
6467 if (elf_tdata (abfd
)->verref
== NULL
)
6470 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6472 contents
= bfd_malloc (hdr
->sh_size
);
6473 if (contents
== NULL
)
6475 error_return_verref
:
6476 elf_tdata (abfd
)->verref
= NULL
;
6477 elf_tdata (abfd
)->cverrefs
= 0;
6480 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6481 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6482 goto error_return_verref
;
6484 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6485 goto error_return_verref
;
6487 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6488 == sizeof (Elf_External_Vernaux
));
6489 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6490 everneed
= (Elf_External_Verneed
*) contents
;
6491 iverneed
= elf_tdata (abfd
)->verref
;
6492 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6494 Elf_External_Vernaux
*evernaux
;
6495 Elf_Internal_Vernaux
*ivernaux
;
6498 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6500 iverneed
->vn_bfd
= abfd
;
6502 iverneed
->vn_filename
=
6503 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6505 if (iverneed
->vn_filename
== NULL
)
6506 goto error_return_verref
;
6508 if (iverneed
->vn_cnt
== 0)
6509 iverneed
->vn_auxptr
= NULL
;
6512 iverneed
->vn_auxptr
= bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6513 sizeof (Elf_Internal_Vernaux
));
6514 if (iverneed
->vn_auxptr
== NULL
)
6515 goto error_return_verref
;
6518 if (iverneed
->vn_aux
6519 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6520 goto error_return_verref
;
6522 evernaux
= ((Elf_External_Vernaux
*)
6523 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6524 ivernaux
= iverneed
->vn_auxptr
;
6525 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6527 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6529 ivernaux
->vna_nodename
=
6530 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6531 ivernaux
->vna_name
);
6532 if (ivernaux
->vna_nodename
== NULL
)
6533 goto error_return_verref
;
6535 if (j
+ 1 < iverneed
->vn_cnt
)
6536 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6538 ivernaux
->vna_nextptr
= NULL
;
6540 if (ivernaux
->vna_next
6541 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6542 goto error_return_verref
;
6544 evernaux
= ((Elf_External_Vernaux
*)
6545 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6547 if (ivernaux
->vna_other
> freeidx
)
6548 freeidx
= ivernaux
->vna_other
;
6551 if (i
+ 1 < hdr
->sh_info
)
6552 iverneed
->vn_nextref
= iverneed
+ 1;
6554 iverneed
->vn_nextref
= NULL
;
6556 if (iverneed
->vn_next
6557 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6558 goto error_return_verref
;
6560 everneed
= ((Elf_External_Verneed
*)
6561 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6568 if (elf_dynverdef (abfd
) != 0)
6570 Elf_Internal_Shdr
*hdr
;
6571 Elf_External_Verdef
*everdef
;
6572 Elf_Internal_Verdef
*iverdef
;
6573 Elf_Internal_Verdef
*iverdefarr
;
6574 Elf_Internal_Verdef iverdefmem
;
6576 unsigned int maxidx
;
6577 bfd_byte
*contents_end_def
, *contents_end_aux
;
6579 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6581 contents
= bfd_malloc (hdr
->sh_size
);
6582 if (contents
== NULL
)
6584 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6585 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6588 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6591 BFD_ASSERT (sizeof (Elf_External_Verdef
)
6592 >= sizeof (Elf_External_Verdaux
));
6593 contents_end_def
= contents
+ hdr
->sh_size
6594 - sizeof (Elf_External_Verdef
);
6595 contents_end_aux
= contents
+ hdr
->sh_size
6596 - sizeof (Elf_External_Verdaux
);
6598 /* We know the number of entries in the section but not the maximum
6599 index. Therefore we have to run through all entries and find
6601 everdef
= (Elf_External_Verdef
*) contents
;
6603 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6605 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6607 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6608 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6610 if (iverdefmem
.vd_next
6611 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
6614 everdef
= ((Elf_External_Verdef
*)
6615 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6618 if (default_imported_symver
)
6620 if (freeidx
> maxidx
)
6625 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, maxidx
,
6626 sizeof (Elf_Internal_Verdef
));
6627 if (elf_tdata (abfd
)->verdef
== NULL
)
6630 elf_tdata (abfd
)->cverdefs
= maxidx
;
6632 everdef
= (Elf_External_Verdef
*) contents
;
6633 iverdefarr
= elf_tdata (abfd
)->verdef
;
6634 for (i
= 0; i
< hdr
->sh_info
; i
++)
6636 Elf_External_Verdaux
*everdaux
;
6637 Elf_Internal_Verdaux
*iverdaux
;
6640 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6642 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
6644 error_return_verdef
:
6645 elf_tdata (abfd
)->verdef
= NULL
;
6646 elf_tdata (abfd
)->cverdefs
= 0;
6650 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6651 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6653 iverdef
->vd_bfd
= abfd
;
6655 if (iverdef
->vd_cnt
== 0)
6656 iverdef
->vd_auxptr
= NULL
;
6659 iverdef
->vd_auxptr
= bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
6660 sizeof (Elf_Internal_Verdaux
));
6661 if (iverdef
->vd_auxptr
== NULL
)
6662 goto error_return_verdef
;
6666 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
6667 goto error_return_verdef
;
6669 everdaux
= ((Elf_External_Verdaux
*)
6670 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6671 iverdaux
= iverdef
->vd_auxptr
;
6672 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
6674 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
6676 iverdaux
->vda_nodename
=
6677 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6678 iverdaux
->vda_name
);
6679 if (iverdaux
->vda_nodename
== NULL
)
6680 goto error_return_verdef
;
6682 if (j
+ 1 < iverdef
->vd_cnt
)
6683 iverdaux
->vda_nextptr
= iverdaux
+ 1;
6685 iverdaux
->vda_nextptr
= NULL
;
6687 if (iverdaux
->vda_next
6688 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
6689 goto error_return_verdef
;
6691 everdaux
= ((Elf_External_Verdaux
*)
6692 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
6695 if (iverdef
->vd_cnt
)
6696 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
6698 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
6699 iverdef
->vd_nextdef
= iverdef
+ 1;
6701 iverdef
->vd_nextdef
= NULL
;
6703 everdef
= ((Elf_External_Verdef
*)
6704 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
6710 else if (default_imported_symver
)
6717 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, freeidx
,
6718 sizeof (Elf_Internal_Verdef
));
6719 if (elf_tdata (abfd
)->verdef
== NULL
)
6722 elf_tdata (abfd
)->cverdefs
= freeidx
;
6725 /* Create a default version based on the soname. */
6726 if (default_imported_symver
)
6728 Elf_Internal_Verdef
*iverdef
;
6729 Elf_Internal_Verdaux
*iverdaux
;
6731 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
6733 iverdef
->vd_version
= VER_DEF_CURRENT
;
6734 iverdef
->vd_flags
= 0;
6735 iverdef
->vd_ndx
= freeidx
;
6736 iverdef
->vd_cnt
= 1;
6738 iverdef
->vd_bfd
= abfd
;
6740 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
6741 if (iverdef
->vd_nodename
== NULL
)
6742 goto error_return_verdef
;
6743 iverdef
->vd_nextdef
= NULL
;
6744 iverdef
->vd_auxptr
= bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
6745 if (iverdef
->vd_auxptr
== NULL
)
6746 goto error_return_verdef
;
6748 iverdaux
= iverdef
->vd_auxptr
;
6749 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
6750 iverdaux
->vda_nextptr
= NULL
;
6756 if (contents
!= NULL
)
6762 _bfd_elf_make_empty_symbol (bfd
*abfd
)
6764 elf_symbol_type
*newsym
;
6765 bfd_size_type amt
= sizeof (elf_symbol_type
);
6767 newsym
= bfd_zalloc (abfd
, amt
);
6772 newsym
->symbol
.the_bfd
= abfd
;
6773 return &newsym
->symbol
;
6778 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
6782 bfd_symbol_info (symbol
, ret
);
6785 /* Return whether a symbol name implies a local symbol. Most targets
6786 use this function for the is_local_label_name entry point, but some
6790 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
6793 /* Normal local symbols start with ``.L''. */
6794 if (name
[0] == '.' && name
[1] == 'L')
6797 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6798 DWARF debugging symbols starting with ``..''. */
6799 if (name
[0] == '.' && name
[1] == '.')
6802 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6803 emitting DWARF debugging output. I suspect this is actually a
6804 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6805 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6806 underscore to be emitted on some ELF targets). For ease of use,
6807 we treat such symbols as local. */
6808 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
6815 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
6816 asymbol
*symbol ATTRIBUTE_UNUSED
)
6823 _bfd_elf_set_arch_mach (bfd
*abfd
,
6824 enum bfd_architecture arch
,
6825 unsigned long machine
)
6827 /* If this isn't the right architecture for this backend, and this
6828 isn't the generic backend, fail. */
6829 if (arch
!= get_elf_backend_data (abfd
)->arch
6830 && arch
!= bfd_arch_unknown
6831 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
6834 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
6837 /* Find the function to a particular section and offset,
6838 for error reporting. */
6841 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
6845 const char **filename_ptr
,
6846 const char **functionname_ptr
)
6848 const char *filename
;
6849 asymbol
*func
, *file
;
6852 /* ??? Given multiple file symbols, it is impossible to reliably
6853 choose the right file name for global symbols. File symbols are
6854 local symbols, and thus all file symbols must sort before any
6855 global symbols. The ELF spec may be interpreted to say that a
6856 file symbol must sort before other local symbols, but currently
6857 ld -r doesn't do this. So, for ld -r output, it is possible to
6858 make a better choice of file name for local symbols by ignoring
6859 file symbols appearing after a given local symbol. */
6860 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
6866 state
= nothing_seen
;
6868 for (p
= symbols
; *p
!= NULL
; p
++)
6872 q
= (elf_symbol_type
*) *p
;
6874 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
6880 if (state
== symbol_seen
)
6881 state
= file_after_symbol_seen
;
6885 if (bfd_get_section (&q
->symbol
) == section
6886 && q
->symbol
.value
>= low_func
6887 && q
->symbol
.value
<= offset
)
6889 func
= (asymbol
*) q
;
6890 low_func
= q
->symbol
.value
;
6893 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
6894 || state
!= file_after_symbol_seen
))
6895 filename
= bfd_asymbol_name (file
);
6899 if (state
== nothing_seen
)
6900 state
= symbol_seen
;
6907 *filename_ptr
= filename
;
6908 if (functionname_ptr
)
6909 *functionname_ptr
= bfd_asymbol_name (func
);
6914 /* Find the nearest line to a particular section and offset,
6915 for error reporting. */
6918 _bfd_elf_find_nearest_line (bfd
*abfd
,
6922 const char **filename_ptr
,
6923 const char **functionname_ptr
,
6924 unsigned int *line_ptr
)
6928 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
6929 filename_ptr
, functionname_ptr
,
6932 if (!*functionname_ptr
)
6933 elf_find_function (abfd
, section
, symbols
, offset
,
6934 *filename_ptr
? NULL
: filename_ptr
,
6940 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
6941 filename_ptr
, functionname_ptr
,
6943 &elf_tdata (abfd
)->dwarf2_find_line_info
))
6945 if (!*functionname_ptr
)
6946 elf_find_function (abfd
, section
, symbols
, offset
,
6947 *filename_ptr
? NULL
: filename_ptr
,
6953 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
6954 &found
, filename_ptr
,
6955 functionname_ptr
, line_ptr
,
6956 &elf_tdata (abfd
)->line_info
))
6958 if (found
&& (*functionname_ptr
|| *line_ptr
))
6961 if (symbols
== NULL
)
6964 if (! elf_find_function (abfd
, section
, symbols
, offset
,
6965 filename_ptr
, functionname_ptr
))
6972 /* Find the line for a symbol. */
6975 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
6976 const char **filename_ptr
, unsigned int *line_ptr
)
6978 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
6979 filename_ptr
, line_ptr
, 0,
6980 &elf_tdata (abfd
)->dwarf2_find_line_info
);
6983 /* After a call to bfd_find_nearest_line, successive calls to
6984 bfd_find_inliner_info can be used to get source information about
6985 each level of function inlining that terminated at the address
6986 passed to bfd_find_nearest_line. Currently this is only supported
6987 for DWARF2 with appropriate DWARF3 extensions. */
6990 _bfd_elf_find_inliner_info (bfd
*abfd
,
6991 const char **filename_ptr
,
6992 const char **functionname_ptr
,
6993 unsigned int *line_ptr
)
6996 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
6997 functionname_ptr
, line_ptr
,
6998 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7003 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7005 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7006 int ret
= bed
->s
->sizeof_ehdr
;
7008 if (!info
->relocatable
)
7010 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7012 if (phdr_size
== (bfd_size_type
) -1)
7014 struct elf_segment_map
*m
;
7017 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7018 phdr_size
+= bed
->s
->sizeof_phdr
;
7021 phdr_size
= get_program_header_size (abfd
, info
);
7024 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7032 _bfd_elf_set_section_contents (bfd
*abfd
,
7034 const void *location
,
7036 bfd_size_type count
)
7038 Elf_Internal_Shdr
*hdr
;
7041 if (! abfd
->output_has_begun
7042 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7045 hdr
= &elf_section_data (section
)->this_hdr
;
7046 pos
= hdr
->sh_offset
+ offset
;
7047 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7048 || bfd_bwrite (location
, count
, abfd
) != count
)
7055 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7056 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7057 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7062 /* Try to convert a non-ELF reloc into an ELF one. */
7065 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7067 /* Check whether we really have an ELF howto. */
7069 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7071 bfd_reloc_code_real_type code
;
7072 reloc_howto_type
*howto
;
7074 /* Alien reloc: Try to determine its type to replace it with an
7075 equivalent ELF reloc. */
7077 if (areloc
->howto
->pc_relative
)
7079 switch (areloc
->howto
->bitsize
)
7082 code
= BFD_RELOC_8_PCREL
;
7085 code
= BFD_RELOC_12_PCREL
;
7088 code
= BFD_RELOC_16_PCREL
;
7091 code
= BFD_RELOC_24_PCREL
;
7094 code
= BFD_RELOC_32_PCREL
;
7097 code
= BFD_RELOC_64_PCREL
;
7103 howto
= bfd_reloc_type_lookup (abfd
, code
);
7105 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7107 if (howto
->pcrel_offset
)
7108 areloc
->addend
+= areloc
->address
;
7110 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7115 switch (areloc
->howto
->bitsize
)
7121 code
= BFD_RELOC_14
;
7124 code
= BFD_RELOC_16
;
7127 code
= BFD_RELOC_26
;
7130 code
= BFD_RELOC_32
;
7133 code
= BFD_RELOC_64
;
7139 howto
= bfd_reloc_type_lookup (abfd
, code
);
7143 areloc
->howto
= howto
;
7151 (*_bfd_error_handler
)
7152 (_("%B: unsupported relocation type %s"),
7153 abfd
, areloc
->howto
->name
);
7154 bfd_set_error (bfd_error_bad_value
);
7159 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7161 if (bfd_get_format (abfd
) == bfd_object
)
7163 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7164 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7165 _bfd_dwarf2_cleanup_debug_info (abfd
);
7168 return _bfd_generic_close_and_cleanup (abfd
);
7171 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7172 in the relocation's offset. Thus we cannot allow any sort of sanity
7173 range-checking to interfere. There is nothing else to do in processing
7176 bfd_reloc_status_type
7177 _bfd_elf_rel_vtable_reloc_fn
7178 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7179 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7180 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7181 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7183 return bfd_reloc_ok
;
7186 /* Elf core file support. Much of this only works on native
7187 toolchains, since we rely on knowing the
7188 machine-dependent procfs structure in order to pick
7189 out details about the corefile. */
7191 #ifdef HAVE_SYS_PROCFS_H
7192 # include <sys/procfs.h>
7195 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7198 elfcore_make_pid (bfd
*abfd
)
7200 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
7201 + (elf_tdata (abfd
)->core_pid
));
7204 /* If there isn't a section called NAME, make one, using
7205 data from SECT. Note, this function will generate a
7206 reference to NAME, so you shouldn't deallocate or
7210 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7214 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7217 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7221 sect2
->size
= sect
->size
;
7222 sect2
->filepos
= sect
->filepos
;
7223 sect2
->alignment_power
= sect
->alignment_power
;
7227 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7228 actually creates up to two pseudosections:
7229 - For the single-threaded case, a section named NAME, unless
7230 such a section already exists.
7231 - For the multi-threaded case, a section named "NAME/PID", where
7232 PID is elfcore_make_pid (abfd).
7233 Both pseudosections have identical contents. */
7235 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7241 char *threaded_name
;
7245 /* Build the section name. */
7247 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7248 len
= strlen (buf
) + 1;
7249 threaded_name
= bfd_alloc (abfd
, len
);
7250 if (threaded_name
== NULL
)
7252 memcpy (threaded_name
, buf
, len
);
7254 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7259 sect
->filepos
= filepos
;
7260 sect
->alignment_power
= 2;
7262 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7265 /* prstatus_t exists on:
7267 linux 2.[01] + glibc
7271 #if defined (HAVE_PRSTATUS_T)
7274 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7279 if (note
->descsz
== sizeof (prstatus_t
))
7283 size
= sizeof (prstat
.pr_reg
);
7284 offset
= offsetof (prstatus_t
, pr_reg
);
7285 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7287 /* Do not overwrite the core signal if it
7288 has already been set by another thread. */
7289 if (elf_tdata (abfd
)->core_signal
== 0)
7290 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7291 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7293 /* pr_who exists on:
7296 pr_who doesn't exist on:
7299 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7300 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7303 #if defined (HAVE_PRSTATUS32_T)
7304 else if (note
->descsz
== sizeof (prstatus32_t
))
7306 /* 64-bit host, 32-bit corefile */
7307 prstatus32_t prstat
;
7309 size
= sizeof (prstat
.pr_reg
);
7310 offset
= offsetof (prstatus32_t
, pr_reg
);
7311 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7313 /* Do not overwrite the core signal if it
7314 has already been set by another thread. */
7315 if (elf_tdata (abfd
)->core_signal
== 0)
7316 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7317 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7319 /* pr_who exists on:
7322 pr_who doesn't exist on:
7325 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7326 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7329 #endif /* HAVE_PRSTATUS32_T */
7332 /* Fail - we don't know how to handle any other
7333 note size (ie. data object type). */
7337 /* Make a ".reg/999" section and a ".reg" section. */
7338 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7339 size
, note
->descpos
+ offset
);
7341 #endif /* defined (HAVE_PRSTATUS_T) */
7343 /* Create a pseudosection containing the exact contents of NOTE. */
7345 elfcore_make_note_pseudosection (bfd
*abfd
,
7347 Elf_Internal_Note
*note
)
7349 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7350 note
->descsz
, note
->descpos
);
7353 /* There isn't a consistent prfpregset_t across platforms,
7354 but it doesn't matter, because we don't have to pick this
7355 data structure apart. */
7358 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7360 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7363 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7364 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7368 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7370 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7373 #if defined (HAVE_PRPSINFO_T)
7374 typedef prpsinfo_t elfcore_psinfo_t
;
7375 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7376 typedef prpsinfo32_t elfcore_psinfo32_t
;
7380 #if defined (HAVE_PSINFO_T)
7381 typedef psinfo_t elfcore_psinfo_t
;
7382 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7383 typedef psinfo32_t elfcore_psinfo32_t
;
7387 /* return a malloc'ed copy of a string at START which is at
7388 most MAX bytes long, possibly without a terminating '\0'.
7389 the copy will always have a terminating '\0'. */
7392 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7395 char *end
= memchr (start
, '\0', max
);
7403 dups
= bfd_alloc (abfd
, len
+ 1);
7407 memcpy (dups
, start
, len
);
7413 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7415 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7417 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7419 elfcore_psinfo_t psinfo
;
7421 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7423 elf_tdata (abfd
)->core_program
7424 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7425 sizeof (psinfo
.pr_fname
));
7427 elf_tdata (abfd
)->core_command
7428 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7429 sizeof (psinfo
.pr_psargs
));
7431 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7432 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7434 /* 64-bit host, 32-bit corefile */
7435 elfcore_psinfo32_t psinfo
;
7437 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7439 elf_tdata (abfd
)->core_program
7440 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7441 sizeof (psinfo
.pr_fname
));
7443 elf_tdata (abfd
)->core_command
7444 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7445 sizeof (psinfo
.pr_psargs
));
7451 /* Fail - we don't know how to handle any other
7452 note size (ie. data object type). */
7456 /* Note that for some reason, a spurious space is tacked
7457 onto the end of the args in some (at least one anyway)
7458 implementations, so strip it off if it exists. */
7461 char *command
= elf_tdata (abfd
)->core_command
;
7462 int n
= strlen (command
);
7464 if (0 < n
&& command
[n
- 1] == ' ')
7465 command
[n
- 1] = '\0';
7470 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7472 #if defined (HAVE_PSTATUS_T)
7474 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7476 if (note
->descsz
== sizeof (pstatus_t
)
7477 #if defined (HAVE_PXSTATUS_T)
7478 || note
->descsz
== sizeof (pxstatus_t
)
7484 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7486 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7488 #if defined (HAVE_PSTATUS32_T)
7489 else if (note
->descsz
== sizeof (pstatus32_t
))
7491 /* 64-bit host, 32-bit corefile */
7494 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7496 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7499 /* Could grab some more details from the "representative"
7500 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7501 NT_LWPSTATUS note, presumably. */
7505 #endif /* defined (HAVE_PSTATUS_T) */
7507 #if defined (HAVE_LWPSTATUS_T)
7509 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7511 lwpstatus_t lwpstat
;
7517 if (note
->descsz
!= sizeof (lwpstat
)
7518 #if defined (HAVE_LWPXSTATUS_T)
7519 && note
->descsz
!= sizeof (lwpxstatus_t
)
7524 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7526 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7527 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7529 /* Make a ".reg/999" section. */
7531 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7532 len
= strlen (buf
) + 1;
7533 name
= bfd_alloc (abfd
, len
);
7536 memcpy (name
, buf
, len
);
7538 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7542 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7543 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7544 sect
->filepos
= note
->descpos
7545 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7548 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7549 sect
->size
= sizeof (lwpstat
.pr_reg
);
7550 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7553 sect
->alignment_power
= 2;
7555 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7558 /* Make a ".reg2/999" section */
7560 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7561 len
= strlen (buf
) + 1;
7562 name
= bfd_alloc (abfd
, len
);
7565 memcpy (name
, buf
, len
);
7567 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7571 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7572 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7573 sect
->filepos
= note
->descpos
7574 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7577 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7578 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7579 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7582 sect
->alignment_power
= 2;
7584 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7586 #endif /* defined (HAVE_LWPSTATUS_T) */
7589 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7596 int is_active_thread
;
7599 if (note
->descsz
< 728)
7602 if (! CONST_STRNEQ (note
->namedata
, "win32"))
7605 type
= bfd_get_32 (abfd
, note
->descdata
);
7609 case 1 /* NOTE_INFO_PROCESS */:
7610 /* FIXME: need to add ->core_command. */
7611 /* process_info.pid */
7612 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7613 /* process_info.signal */
7614 elf_tdata (abfd
)->core_signal
= bfd_get_32 (abfd
, note
->descdata
+ 12);
7617 case 2 /* NOTE_INFO_THREAD */:
7618 /* Make a ".reg/999" section. */
7619 /* thread_info.tid */
7620 sprintf (buf
, ".reg/%ld", (long) bfd_get_32 (abfd
, note
->descdata
+ 8));
7622 len
= strlen (buf
) + 1;
7623 name
= bfd_alloc (abfd
, len
);
7627 memcpy (name
, buf
, len
);
7629 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7633 /* sizeof (thread_info.thread_context) */
7635 /* offsetof (thread_info.thread_context) */
7636 sect
->filepos
= note
->descpos
+ 12;
7637 sect
->alignment_power
= 2;
7639 /* thread_info.is_active_thread */
7640 is_active_thread
= bfd_get_32 (abfd
, note
->descdata
+ 8);
7642 if (is_active_thread
)
7643 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7647 case 3 /* NOTE_INFO_MODULE */:
7648 /* Make a ".module/xxxxxxxx" section. */
7649 /* module_info.base_address */
7650 base_addr
= bfd_get_32 (abfd
, note
->descdata
+ 4);
7651 sprintf (buf
, ".module/%08lx", (long) base_addr
);
7653 len
= strlen (buf
) + 1;
7654 name
= bfd_alloc (abfd
, len
);
7658 memcpy (name
, buf
, len
);
7660 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7665 sect
->size
= note
->descsz
;
7666 sect
->filepos
= note
->descpos
;
7667 sect
->alignment_power
= 2;
7678 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7680 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7688 if (bed
->elf_backend_grok_prstatus
)
7689 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
7691 #if defined (HAVE_PRSTATUS_T)
7692 return elfcore_grok_prstatus (abfd
, note
);
7697 #if defined (HAVE_PSTATUS_T)
7699 return elfcore_grok_pstatus (abfd
, note
);
7702 #if defined (HAVE_LWPSTATUS_T)
7704 return elfcore_grok_lwpstatus (abfd
, note
);
7707 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
7708 return elfcore_grok_prfpreg (abfd
, note
);
7710 case NT_WIN32PSTATUS
:
7711 return elfcore_grok_win32pstatus (abfd
, note
);
7713 case NT_PRXFPREG
: /* Linux SSE extension */
7714 if (note
->namesz
== 6
7715 && strcmp (note
->namedata
, "LINUX") == 0)
7716 return elfcore_grok_prxfpreg (abfd
, note
);
7722 if (bed
->elf_backend_grok_psinfo
)
7723 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
7725 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7726 return elfcore_grok_psinfo (abfd
, note
);
7733 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
7738 sect
->size
= note
->descsz
;
7739 sect
->filepos
= note
->descpos
;
7740 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
7748 elfobj_grok_gnu_build_id (bfd
*abfd
, Elf_Internal_Note
*note
)
7750 elf_tdata (abfd
)->build_id_size
= note
->descsz
;
7751 elf_tdata (abfd
)->build_id
= bfd_alloc (abfd
, note
->descsz
);
7752 if (elf_tdata (abfd
)->build_id
== NULL
)
7755 memcpy (elf_tdata (abfd
)->build_id
, note
->descdata
, note
->descsz
);
7761 elfobj_grok_gnu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7768 case NT_GNU_BUILD_ID
:
7769 return elfobj_grok_gnu_build_id (abfd
, note
);
7774 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
7778 cp
= strchr (note
->namedata
, '@');
7781 *lwpidp
= atoi(cp
+ 1);
7788 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7790 /* Signal number at offset 0x08. */
7791 elf_tdata (abfd
)->core_signal
7792 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
7794 /* Process ID at offset 0x50. */
7795 elf_tdata (abfd
)->core_pid
7796 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
7798 /* Command name at 0x7c (max 32 bytes, including nul). */
7799 elf_tdata (abfd
)->core_command
7800 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
7802 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
7807 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7811 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
7812 elf_tdata (abfd
)->core_lwpid
= lwp
;
7814 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
7816 /* NetBSD-specific core "procinfo". Note that we expect to
7817 find this note before any of the others, which is fine,
7818 since the kernel writes this note out first when it
7819 creates a core file. */
7821 return elfcore_grok_netbsd_procinfo (abfd
, note
);
7824 /* As of Jan 2002 there are no other machine-independent notes
7825 defined for NetBSD core files. If the note type is less
7826 than the start of the machine-dependent note types, we don't
7829 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
7833 switch (bfd_get_arch (abfd
))
7835 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7836 PT_GETFPREGS == mach+2. */
7838 case bfd_arch_alpha
:
7839 case bfd_arch_sparc
:
7842 case NT_NETBSDCORE_FIRSTMACH
+0:
7843 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7845 case NT_NETBSDCORE_FIRSTMACH
+2:
7846 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7852 /* On all other arch's, PT_GETREGS == mach+1 and
7853 PT_GETFPREGS == mach+3. */
7858 case NT_NETBSDCORE_FIRSTMACH
+1:
7859 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
7861 case NT_NETBSDCORE_FIRSTMACH
+3:
7862 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7872 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
7874 void *ddata
= note
->descdata
;
7881 /* nto_procfs_status 'pid' field is at offset 0. */
7882 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
7884 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7885 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
7887 /* nto_procfs_status 'flags' field is at offset 8. */
7888 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
7890 /* nto_procfs_status 'what' field is at offset 14. */
7891 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
7893 elf_tdata (abfd
)->core_signal
= sig
;
7894 elf_tdata (abfd
)->core_lwpid
= *tid
;
7897 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7898 do not come from signals so we make sure we set the current
7899 thread just in case. */
7900 if (flags
& 0x00000080)
7901 elf_tdata (abfd
)->core_lwpid
= *tid
;
7903 /* Make a ".qnx_core_status/%d" section. */
7904 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
7906 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7911 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7915 sect
->size
= note
->descsz
;
7916 sect
->filepos
= note
->descpos
;
7917 sect
->alignment_power
= 2;
7919 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
7923 elfcore_grok_nto_regs (bfd
*abfd
,
7924 Elf_Internal_Note
*note
,
7932 /* Make a "(base)/%d" section. */
7933 sprintf (buf
, "%s/%ld", base
, tid
);
7935 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
7940 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7944 sect
->size
= note
->descsz
;
7945 sect
->filepos
= note
->descpos
;
7946 sect
->alignment_power
= 2;
7948 /* This is the current thread. */
7949 if (elf_tdata (abfd
)->core_lwpid
== tid
)
7950 return elfcore_maybe_make_sect (abfd
, base
, sect
);
7955 #define BFD_QNT_CORE_INFO 7
7956 #define BFD_QNT_CORE_STATUS 8
7957 #define BFD_QNT_CORE_GREG 9
7958 #define BFD_QNT_CORE_FPREG 10
7961 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7963 /* Every GREG section has a STATUS section before it. Store the
7964 tid from the previous call to pass down to the next gregs
7966 static long tid
= 1;
7970 case BFD_QNT_CORE_INFO
:
7971 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
7972 case BFD_QNT_CORE_STATUS
:
7973 return elfcore_grok_nto_status (abfd
, note
, &tid
);
7974 case BFD_QNT_CORE_GREG
:
7975 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
7976 case BFD_QNT_CORE_FPREG
:
7977 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
7984 elfcore_grok_spu_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7990 /* Use note name as section name. */
7992 name
= bfd_alloc (abfd
, len
);
7995 memcpy (name
, note
->namedata
, len
);
7996 name
[len
- 1] = '\0';
7998 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8002 sect
->size
= note
->descsz
;
8003 sect
->filepos
= note
->descpos
;
8004 sect
->alignment_power
= 1;
8009 /* Function: elfcore_write_note
8012 buffer to hold note, and current size of buffer
8016 size of data for note
8018 Writes note to end of buffer. ELF64 notes are written exactly as
8019 for ELF32, despite the current (as of 2006) ELF gabi specifying
8020 that they ought to have 8-byte namesz and descsz field, and have
8021 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8024 Pointer to realloc'd buffer, *BUFSIZ updated. */
8027 elfcore_write_note (bfd
*abfd
,
8035 Elf_External_Note
*xnp
;
8042 namesz
= strlen (name
) + 1;
8044 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8046 buf
= realloc (buf
, *bufsiz
+ newspace
);
8047 dest
= buf
+ *bufsiz
;
8048 *bufsiz
+= newspace
;
8049 xnp
= (Elf_External_Note
*) dest
;
8050 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8051 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8052 H_PUT_32 (abfd
, type
, xnp
->type
);
8056 memcpy (dest
, name
, namesz
);
8064 memcpy (dest
, input
, size
);
8074 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8076 elfcore_write_prpsinfo (bfd
*abfd
,
8082 const char *note_name
= "CORE";
8083 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8085 if (bed
->elf_backend_write_core_note
!= NULL
)
8088 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8089 NT_PRPSINFO
, fname
, psargs
);
8094 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8095 if (bed
->s
->elfclass
== ELFCLASS32
)
8097 #if defined (HAVE_PSINFO32_T)
8099 int note_type
= NT_PSINFO
;
8102 int note_type
= NT_PRPSINFO
;
8105 memset (&data
, 0, sizeof (data
));
8106 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8107 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8108 return elfcore_write_note (abfd
, buf
, bufsiz
,
8109 note_name
, note_type
, &data
, sizeof (data
));
8114 #if defined (HAVE_PSINFO_T)
8116 int note_type
= NT_PSINFO
;
8119 int note_type
= NT_PRPSINFO
;
8122 memset (&data
, 0, sizeof (data
));
8123 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8124 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8125 return elfcore_write_note (abfd
, buf
, bufsiz
,
8126 note_name
, note_type
, &data
, sizeof (data
));
8129 #endif /* PSINFO_T or PRPSINFO_T */
8131 #if defined (HAVE_PRSTATUS_T)
8133 elfcore_write_prstatus (bfd
*abfd
,
8140 const char *note_name
= "CORE";
8141 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8143 if (bed
->elf_backend_write_core_note
!= NULL
)
8146 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8148 pid
, cursig
, gregs
);
8153 #if defined (HAVE_PRSTATUS32_T)
8154 if (bed
->s
->elfclass
== ELFCLASS32
)
8156 prstatus32_t prstat
;
8158 memset (&prstat
, 0, sizeof (prstat
));
8159 prstat
.pr_pid
= pid
;
8160 prstat
.pr_cursig
= cursig
;
8161 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8162 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8163 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8170 memset (&prstat
, 0, sizeof (prstat
));
8171 prstat
.pr_pid
= pid
;
8172 prstat
.pr_cursig
= cursig
;
8173 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8174 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8175 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8178 #endif /* HAVE_PRSTATUS_T */
8180 #if defined (HAVE_LWPSTATUS_T)
8182 elfcore_write_lwpstatus (bfd
*abfd
,
8189 lwpstatus_t lwpstat
;
8190 const char *note_name
= "CORE";
8192 memset (&lwpstat
, 0, sizeof (lwpstat
));
8193 lwpstat
.pr_lwpid
= pid
>> 16;
8194 lwpstat
.pr_cursig
= cursig
;
8195 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8196 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8197 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8199 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8200 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8202 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8203 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8206 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8207 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8209 #endif /* HAVE_LWPSTATUS_T */
8211 #if defined (HAVE_PSTATUS_T)
8213 elfcore_write_pstatus (bfd
*abfd
,
8217 int cursig ATTRIBUTE_UNUSED
,
8218 const void *gregs ATTRIBUTE_UNUSED
)
8220 const char *note_name
= "CORE";
8221 #if defined (HAVE_PSTATUS32_T)
8222 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8224 if (bed
->s
->elfclass
== ELFCLASS32
)
8228 memset (&pstat
, 0, sizeof (pstat
));
8229 pstat
.pr_pid
= pid
& 0xffff;
8230 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8231 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8239 memset (&pstat
, 0, sizeof (pstat
));
8240 pstat
.pr_pid
= pid
& 0xffff;
8241 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8242 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8246 #endif /* HAVE_PSTATUS_T */
8249 elfcore_write_prfpreg (bfd
*abfd
,
8255 const char *note_name
= "CORE";
8256 return elfcore_write_note (abfd
, buf
, bufsiz
,
8257 note_name
, NT_FPREGSET
, fpregs
, size
);
8261 elfcore_write_prxfpreg (bfd
*abfd
,
8264 const void *xfpregs
,
8267 char *note_name
= "LINUX";
8268 return elfcore_write_note (abfd
, buf
, bufsiz
,
8269 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8273 elf_parse_notes (bfd
*abfd
, char *buf
, size_t size
, file_ptr offset
)
8278 while (p
< buf
+ size
)
8280 /* FIXME: bad alignment assumption. */
8281 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
8282 Elf_Internal_Note in
;
8284 in
.type
= H_GET_32 (abfd
, xnp
->type
);
8286 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
8287 in
.namedata
= xnp
->name
;
8289 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
8290 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
8291 in
.descpos
= offset
+ (in
.descdata
- buf
);
8293 switch (bfd_get_format (abfd
))
8299 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
8301 if (! elfcore_grok_netbsd_note (abfd
, &in
))
8304 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
8306 if (! elfcore_grok_nto_note (abfd
, &in
))
8309 else if (CONST_STRNEQ (in
.namedata
, "SPU/"))
8311 if (! elfcore_grok_spu_note (abfd
, &in
))
8316 if (! elfcore_grok_note (abfd
, &in
))
8322 if (in
.namesz
== sizeof "GNU" && strcmp (in
.namedata
, "GNU") == 0)
8324 if (! elfobj_grok_gnu_note (abfd
, &in
))
8330 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
8337 elf_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
8344 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
8347 buf
= bfd_malloc (size
);
8351 if (bfd_bread (buf
, size
, abfd
) != size
8352 || !elf_parse_notes (abfd
, buf
, size
, offset
))
8362 /* Providing external access to the ELF program header table. */
8364 /* Return an upper bound on the number of bytes required to store a
8365 copy of ABFD's program header table entries. Return -1 if an error
8366 occurs; bfd_get_error will return an appropriate code. */
8369 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
8371 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8373 bfd_set_error (bfd_error_wrong_format
);
8377 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
8380 /* Copy ABFD's program header table entries to *PHDRS. The entries
8381 will be stored as an array of Elf_Internal_Phdr structures, as
8382 defined in include/elf/internal.h. To find out how large the
8383 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8385 Return the number of program header table entries read, or -1 if an
8386 error occurs; bfd_get_error will return an appropriate code. */
8389 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
8393 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8395 bfd_set_error (bfd_error_wrong_format
);
8399 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
8400 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
8401 num_phdrs
* sizeof (Elf_Internal_Phdr
));
8407 _bfd_elf_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
8410 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
8412 i_ehdrp
= elf_elfheader (abfd
);
8413 if (i_ehdrp
== NULL
)
8414 sprintf_vma (buf
, value
);
8417 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
8419 #if BFD_HOST_64BIT_LONG
8420 sprintf (buf
, "%016lx", value
);
8422 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
8423 _bfd_int64_low (value
));
8427 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
8430 sprintf_vma (buf
, value
);
8435 _bfd_elf_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
8438 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
8440 i_ehdrp
= elf_elfheader (abfd
);
8441 if (i_ehdrp
== NULL
)
8442 fprintf_vma ((FILE *) stream
, value
);
8445 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
8447 #if BFD_HOST_64BIT_LONG
8448 fprintf ((FILE *) stream
, "%016lx", value
);
8450 fprintf ((FILE *) stream
, "%08lx%08lx",
8451 _bfd_int64_high (value
), _bfd_int64_low (value
));
8455 fprintf ((FILE *) stream
, "%08lx",
8456 (unsigned long) (value
& 0xffffffff));
8459 fprintf_vma ((FILE *) stream
, value
);
8463 enum elf_reloc_type_class
8464 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
8466 return reloc_class_normal
;
8469 /* For RELA architectures, return the relocation value for a
8470 relocation against a local symbol. */
8473 _bfd_elf_rela_local_sym (bfd
*abfd
,
8474 Elf_Internal_Sym
*sym
,
8476 Elf_Internal_Rela
*rel
)
8478 asection
*sec
= *psec
;
8481 relocation
= (sec
->output_section
->vma
8482 + sec
->output_offset
8484 if ((sec
->flags
& SEC_MERGE
)
8485 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
8486 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
8489 _bfd_merged_section_offset (abfd
, psec
,
8490 elf_section_data (sec
)->sec_info
,
8491 sym
->st_value
+ rel
->r_addend
);
8494 /* If we have changed the section, and our original section is
8495 marked with SEC_EXCLUDE, it means that the original
8496 SEC_MERGE section has been completely subsumed in some
8497 other SEC_MERGE section. In this case, we need to leave
8498 some info around for --emit-relocs. */
8499 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
8500 sec
->kept_section
= *psec
;
8503 rel
->r_addend
-= relocation
;
8504 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
8510 _bfd_elf_rel_local_sym (bfd
*abfd
,
8511 Elf_Internal_Sym
*sym
,
8515 asection
*sec
= *psec
;
8517 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
8518 return sym
->st_value
+ addend
;
8520 return _bfd_merged_section_offset (abfd
, psec
,
8521 elf_section_data (sec
)->sec_info
,
8522 sym
->st_value
+ addend
);
8526 _bfd_elf_section_offset (bfd
*abfd
,
8527 struct bfd_link_info
*info
,
8531 switch (sec
->sec_info_type
)
8533 case ELF_INFO_TYPE_STABS
:
8534 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
8536 case ELF_INFO_TYPE_EH_FRAME
:
8537 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
8543 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8544 reconstruct an ELF file by reading the segments out of remote memory
8545 based on the ELF file header at EHDR_VMA and the ELF program headers it
8546 points to. If not null, *LOADBASEP is filled in with the difference
8547 between the VMAs from which the segments were read, and the VMAs the
8548 file headers (and hence BFD's idea of each section's VMA) put them at.
8550 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8551 remote memory at target address VMA into the local buffer at MYADDR; it
8552 should return zero on success or an `errno' code on failure. TEMPL must
8553 be a BFD for an ELF target with the word size and byte order found in
8554 the remote memory. */
8557 bfd_elf_bfd_from_remote_memory
8561 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
8563 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
8564 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
8568 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
8569 long symcount ATTRIBUTE_UNUSED
,
8570 asymbol
**syms ATTRIBUTE_UNUSED
,
8575 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8578 const char *relplt_name
;
8579 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8583 Elf_Internal_Shdr
*hdr
;
8589 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
8592 if (dynsymcount
<= 0)
8595 if (!bed
->plt_sym_val
)
8598 relplt_name
= bed
->relplt_name
;
8599 if (relplt_name
== NULL
)
8600 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
8601 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
8605 hdr
= &elf_section_data (relplt
)->this_hdr
;
8606 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
8607 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
8610 plt
= bfd_get_section_by_name (abfd
, ".plt");
8614 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8615 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
8618 count
= relplt
->size
/ hdr
->sh_entsize
;
8619 size
= count
* sizeof (asymbol
);
8620 p
= relplt
->relocation
;
8621 for (i
= 0; i
< count
; i
++, p
++)
8622 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
8624 s
= *ret
= bfd_malloc (size
);
8628 names
= (char *) (s
+ count
);
8629 p
= relplt
->relocation
;
8631 for (i
= 0; i
< count
; i
++, s
++, p
++)
8636 addr
= bed
->plt_sym_val (i
, plt
, p
);
8637 if (addr
== (bfd_vma
) -1)
8640 *s
= **p
->sym_ptr_ptr
;
8641 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8642 we are defining a symbol, ensure one of them is set. */
8643 if ((s
->flags
& BSF_LOCAL
) == 0)
8644 s
->flags
|= BSF_GLOBAL
;
8646 s
->value
= addr
- plt
->vma
;
8648 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
8649 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
8651 memcpy (names
, "@plt", sizeof ("@plt"));
8652 names
+= sizeof ("@plt");
8659 /* It is only used by x86-64 so far. */
8660 asection _bfd_elf_large_com_section
8661 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
8662 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
8665 _bfd_elf_set_osabi (bfd
* abfd
,
8666 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
8668 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
8670 i_ehdrp
= elf_elfheader (abfd
);
8672 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
8676 /* Return TRUE for ELF symbol types that represent functions.
8677 This is the default version of this function, which is sufficient for
8678 most targets. It returns true if TYPE is STT_FUNC. */
8681 _bfd_elf_is_function_type (unsigned int type
)
8683 return (type
== STT_FUNC
);