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
elfcore_read_notes (bfd
*, file_ptr
, bfd_size_type
) ;
53 /* Swap version information in and out. The version information is
54 currently size independent. If that ever changes, this code will
55 need to move into elfcode.h. */
57 /* Swap in a Verdef structure. */
60 _bfd_elf_swap_verdef_in (bfd
*abfd
,
61 const Elf_External_Verdef
*src
,
62 Elf_Internal_Verdef
*dst
)
64 dst
->vd_version
= H_GET_16 (abfd
, src
->vd_version
);
65 dst
->vd_flags
= H_GET_16 (abfd
, src
->vd_flags
);
66 dst
->vd_ndx
= H_GET_16 (abfd
, src
->vd_ndx
);
67 dst
->vd_cnt
= H_GET_16 (abfd
, src
->vd_cnt
);
68 dst
->vd_hash
= H_GET_32 (abfd
, src
->vd_hash
);
69 dst
->vd_aux
= H_GET_32 (abfd
, src
->vd_aux
);
70 dst
->vd_next
= H_GET_32 (abfd
, src
->vd_next
);
73 /* Swap out a Verdef structure. */
76 _bfd_elf_swap_verdef_out (bfd
*abfd
,
77 const Elf_Internal_Verdef
*src
,
78 Elf_External_Verdef
*dst
)
80 H_PUT_16 (abfd
, src
->vd_version
, dst
->vd_version
);
81 H_PUT_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
82 H_PUT_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
83 H_PUT_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
84 H_PUT_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
85 H_PUT_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
86 H_PUT_32 (abfd
, src
->vd_next
, dst
->vd_next
);
89 /* Swap in a Verdaux structure. */
92 _bfd_elf_swap_verdaux_in (bfd
*abfd
,
93 const Elf_External_Verdaux
*src
,
94 Elf_Internal_Verdaux
*dst
)
96 dst
->vda_name
= H_GET_32 (abfd
, src
->vda_name
);
97 dst
->vda_next
= H_GET_32 (abfd
, src
->vda_next
);
100 /* Swap out a Verdaux structure. */
103 _bfd_elf_swap_verdaux_out (bfd
*abfd
,
104 const Elf_Internal_Verdaux
*src
,
105 Elf_External_Verdaux
*dst
)
107 H_PUT_32 (abfd
, src
->vda_name
, dst
->vda_name
);
108 H_PUT_32 (abfd
, src
->vda_next
, dst
->vda_next
);
111 /* Swap in a Verneed structure. */
114 _bfd_elf_swap_verneed_in (bfd
*abfd
,
115 const Elf_External_Verneed
*src
,
116 Elf_Internal_Verneed
*dst
)
118 dst
->vn_version
= H_GET_16 (abfd
, src
->vn_version
);
119 dst
->vn_cnt
= H_GET_16 (abfd
, src
->vn_cnt
);
120 dst
->vn_file
= H_GET_32 (abfd
, src
->vn_file
);
121 dst
->vn_aux
= H_GET_32 (abfd
, src
->vn_aux
);
122 dst
->vn_next
= H_GET_32 (abfd
, src
->vn_next
);
125 /* Swap out a Verneed structure. */
128 _bfd_elf_swap_verneed_out (bfd
*abfd
,
129 const Elf_Internal_Verneed
*src
,
130 Elf_External_Verneed
*dst
)
132 H_PUT_16 (abfd
, src
->vn_version
, dst
->vn_version
);
133 H_PUT_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
134 H_PUT_32 (abfd
, src
->vn_file
, dst
->vn_file
);
135 H_PUT_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
136 H_PUT_32 (abfd
, src
->vn_next
, dst
->vn_next
);
139 /* Swap in a Vernaux structure. */
142 _bfd_elf_swap_vernaux_in (bfd
*abfd
,
143 const Elf_External_Vernaux
*src
,
144 Elf_Internal_Vernaux
*dst
)
146 dst
->vna_hash
= H_GET_32 (abfd
, src
->vna_hash
);
147 dst
->vna_flags
= H_GET_16 (abfd
, src
->vna_flags
);
148 dst
->vna_other
= H_GET_16 (abfd
, src
->vna_other
);
149 dst
->vna_name
= H_GET_32 (abfd
, src
->vna_name
);
150 dst
->vna_next
= H_GET_32 (abfd
, src
->vna_next
);
153 /* Swap out a Vernaux structure. */
156 _bfd_elf_swap_vernaux_out (bfd
*abfd
,
157 const Elf_Internal_Vernaux
*src
,
158 Elf_External_Vernaux
*dst
)
160 H_PUT_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
161 H_PUT_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
162 H_PUT_16 (abfd
, src
->vna_other
, dst
->vna_other
);
163 H_PUT_32 (abfd
, src
->vna_name
, dst
->vna_name
);
164 H_PUT_32 (abfd
, src
->vna_next
, dst
->vna_next
);
167 /* Swap in a Versym structure. */
170 _bfd_elf_swap_versym_in (bfd
*abfd
,
171 const Elf_External_Versym
*src
,
172 Elf_Internal_Versym
*dst
)
174 dst
->vs_vers
= H_GET_16 (abfd
, src
->vs_vers
);
177 /* Swap out a Versym structure. */
180 _bfd_elf_swap_versym_out (bfd
*abfd
,
181 const Elf_Internal_Versym
*src
,
182 Elf_External_Versym
*dst
)
184 H_PUT_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
187 /* Standard ELF hash function. Do not change this function; you will
188 cause invalid hash tables to be generated. */
191 bfd_elf_hash (const char *namearg
)
193 const unsigned char *name
= (const unsigned char *) namearg
;
198 while ((ch
= *name
++) != '\0')
201 if ((g
= (h
& 0xf0000000)) != 0)
204 /* The ELF ABI says `h &= ~g', but this is equivalent in
205 this case and on some machines one insn instead of two. */
209 return h
& 0xffffffff;
212 /* DT_GNU_HASH hash function. Do not change this function; you will
213 cause invalid hash tables to be generated. */
216 bfd_elf_gnu_hash (const char *namearg
)
218 const unsigned char *name
= (const unsigned char *) namearg
;
219 unsigned long h
= 5381;
222 while ((ch
= *name
++) != '\0')
223 h
= (h
<< 5) + h
+ ch
;
224 return h
& 0xffffffff;
228 bfd_elf_mkobject (bfd
*abfd
)
230 if (abfd
->tdata
.any
== NULL
)
232 abfd
->tdata
.any
= bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
233 if (abfd
->tdata
.any
== NULL
)
237 elf_tdata (abfd
)->program_header_size
= (bfd_size_type
) -1;
243 bfd_elf_mkcorefile (bfd
*abfd
)
245 /* I think this can be done just like an object file. */
246 return bfd_elf_mkobject (abfd
);
250 bfd_elf_get_str_section (bfd
*abfd
, unsigned int shindex
)
252 Elf_Internal_Shdr
**i_shdrp
;
253 bfd_byte
*shstrtab
= NULL
;
255 bfd_size_type shstrtabsize
;
257 i_shdrp
= elf_elfsections (abfd
);
259 || shindex
>= elf_numsections (abfd
)
260 || i_shdrp
[shindex
] == 0)
263 shstrtab
= i_shdrp
[shindex
]->contents
;
264 if (shstrtab
== NULL
)
266 /* No cached one, attempt to read, and cache what we read. */
267 offset
= i_shdrp
[shindex
]->sh_offset
;
268 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
270 /* Allocate and clear an extra byte at the end, to prevent crashes
271 in case the string table is not terminated. */
272 if (shstrtabsize
+ 1 == 0
273 || (shstrtab
= bfd_alloc (abfd
, shstrtabsize
+ 1)) == NULL
274 || bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
276 else if (bfd_bread (shstrtab
, shstrtabsize
, abfd
) != shstrtabsize
)
278 if (bfd_get_error () != bfd_error_system_call
)
279 bfd_set_error (bfd_error_file_truncated
);
283 shstrtab
[shstrtabsize
] = '\0';
284 i_shdrp
[shindex
]->contents
= shstrtab
;
286 return (char *) shstrtab
;
290 bfd_elf_string_from_elf_section (bfd
*abfd
,
291 unsigned int shindex
,
292 unsigned int strindex
)
294 Elf_Internal_Shdr
*hdr
;
299 if (elf_elfsections (abfd
) == NULL
|| shindex
>= elf_numsections (abfd
))
302 hdr
= elf_elfsections (abfd
)[shindex
];
304 if (hdr
->contents
== NULL
305 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
308 if (strindex
>= hdr
->sh_size
)
310 unsigned int shstrndx
= elf_elfheader(abfd
)->e_shstrndx
;
311 (*_bfd_error_handler
)
312 (_("%B: invalid string offset %u >= %lu for section `%s'"),
313 abfd
, strindex
, (unsigned long) hdr
->sh_size
,
314 (shindex
== shstrndx
&& strindex
== hdr
->sh_name
316 : bfd_elf_string_from_elf_section (abfd
, shstrndx
, hdr
->sh_name
)));
320 return ((char *) hdr
->contents
) + strindex
;
323 /* Read and convert symbols to internal format.
324 SYMCOUNT specifies the number of symbols to read, starting from
325 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
326 are non-NULL, they are used to store the internal symbols, external
327 symbols, and symbol section index extensions, respectively. */
330 bfd_elf_get_elf_syms (bfd
*ibfd
,
331 Elf_Internal_Shdr
*symtab_hdr
,
334 Elf_Internal_Sym
*intsym_buf
,
336 Elf_External_Sym_Shndx
*extshndx_buf
)
338 Elf_Internal_Shdr
*shndx_hdr
;
340 const bfd_byte
*esym
;
341 Elf_External_Sym_Shndx
*alloc_extshndx
;
342 Elf_External_Sym_Shndx
*shndx
;
343 Elf_Internal_Sym
*isym
;
344 Elf_Internal_Sym
*isymend
;
345 const struct elf_backend_data
*bed
;
353 /* Normal syms might have section extension entries. */
355 if (symtab_hdr
== &elf_tdata (ibfd
)->symtab_hdr
)
356 shndx_hdr
= &elf_tdata (ibfd
)->symtab_shndx_hdr
;
358 /* Read the symbols. */
360 alloc_extshndx
= NULL
;
361 bed
= get_elf_backend_data (ibfd
);
362 extsym_size
= bed
->s
->sizeof_sym
;
363 amt
= symcount
* extsym_size
;
364 pos
= symtab_hdr
->sh_offset
+ symoffset
* extsym_size
;
365 if (extsym_buf
== NULL
)
367 alloc_ext
= bfd_malloc2 (symcount
, extsym_size
);
368 extsym_buf
= alloc_ext
;
370 if (extsym_buf
== NULL
371 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
372 || bfd_bread (extsym_buf
, amt
, ibfd
) != amt
)
378 if (shndx_hdr
== NULL
|| shndx_hdr
->sh_size
== 0)
382 amt
= symcount
* sizeof (Elf_External_Sym_Shndx
);
383 pos
= shndx_hdr
->sh_offset
+ symoffset
* sizeof (Elf_External_Sym_Shndx
);
384 if (extshndx_buf
== NULL
)
386 alloc_extshndx
= bfd_malloc2 (symcount
,
387 sizeof (Elf_External_Sym_Shndx
));
388 extshndx_buf
= alloc_extshndx
;
390 if (extshndx_buf
== NULL
391 || bfd_seek (ibfd
, pos
, SEEK_SET
) != 0
392 || bfd_bread (extshndx_buf
, amt
, ibfd
) != amt
)
399 if (intsym_buf
== NULL
)
401 intsym_buf
= bfd_malloc2 (symcount
, sizeof (Elf_Internal_Sym
));
402 if (intsym_buf
== NULL
)
406 /* Convert the symbols to internal form. */
407 isymend
= intsym_buf
+ symcount
;
408 for (esym
= extsym_buf
, isym
= intsym_buf
, shndx
= extshndx_buf
;
410 esym
+= extsym_size
, isym
++, shndx
= shndx
!= NULL
? shndx
+ 1 : NULL
)
411 if (!(*bed
->s
->swap_symbol_in
) (ibfd
, esym
, shndx
, isym
))
413 symoffset
+= (esym
- (bfd_byte
*) extsym_buf
) / extsym_size
;
414 (*_bfd_error_handler
) (_("%B symbol number %lu references "
415 "nonexistent SHT_SYMTAB_SHNDX section"),
416 ibfd
, (unsigned long) symoffset
);
422 if (alloc_ext
!= NULL
)
424 if (alloc_extshndx
!= NULL
)
425 free (alloc_extshndx
);
430 /* Look up a symbol name. */
432 bfd_elf_sym_name (bfd
*abfd
,
433 Elf_Internal_Shdr
*symtab_hdr
,
434 Elf_Internal_Sym
*isym
,
438 unsigned int iname
= isym
->st_name
;
439 unsigned int shindex
= symtab_hdr
->sh_link
;
441 if (iname
== 0 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
442 /* Check for a bogus st_shndx to avoid crashing. */
443 && isym
->st_shndx
< elf_numsections (abfd
)
444 && !(isym
->st_shndx
>= SHN_LORESERVE
&& isym
->st_shndx
<= SHN_HIRESERVE
))
446 iname
= elf_elfsections (abfd
)[isym
->st_shndx
]->sh_name
;
447 shindex
= elf_elfheader (abfd
)->e_shstrndx
;
450 name
= bfd_elf_string_from_elf_section (abfd
, shindex
, iname
);
453 else if (sym_sec
&& *name
== '\0')
454 name
= bfd_section_name (abfd
, sym_sec
);
459 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
460 sections. The first element is the flags, the rest are section
463 typedef union elf_internal_group
{
464 Elf_Internal_Shdr
*shdr
;
466 } Elf_Internal_Group
;
468 /* Return the name of the group signature symbol. Why isn't the
469 signature just a string? */
472 group_signature (bfd
*abfd
, Elf_Internal_Shdr
*ghdr
)
474 Elf_Internal_Shdr
*hdr
;
475 unsigned char esym
[sizeof (Elf64_External_Sym
)];
476 Elf_External_Sym_Shndx eshndx
;
477 Elf_Internal_Sym isym
;
479 /* First we need to ensure the symbol table is available. Make sure
480 that it is a symbol table section. */
481 hdr
= elf_elfsections (abfd
) [ghdr
->sh_link
];
482 if (hdr
->sh_type
!= SHT_SYMTAB
483 || ! bfd_section_from_shdr (abfd
, ghdr
->sh_link
))
486 /* Go read the symbol. */
487 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
488 if (bfd_elf_get_elf_syms (abfd
, hdr
, 1, ghdr
->sh_info
,
489 &isym
, esym
, &eshndx
) == NULL
)
492 return bfd_elf_sym_name (abfd
, hdr
, &isym
, NULL
);
495 /* Set next_in_group list pointer, and group name for NEWSECT. */
498 setup_group (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*newsect
)
500 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
502 /* If num_group is zero, read in all SHT_GROUP sections. The count
503 is set to -1 if there are no SHT_GROUP sections. */
506 unsigned int i
, shnum
;
508 /* First count the number of groups. If we have a SHT_GROUP
509 section with just a flag word (ie. sh_size is 4), ignore it. */
510 shnum
= elf_numsections (abfd
);
513 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
514 ( (shdr)->sh_type == SHT_GROUP \
515 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
516 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
517 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
519 for (i
= 0; i
< shnum
; i
++)
521 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
523 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
529 num_group
= (unsigned) -1;
530 elf_tdata (abfd
)->num_group
= num_group
;
534 /* We keep a list of elf section headers for group sections,
535 so we can find them quickly. */
538 elf_tdata (abfd
)->num_group
= num_group
;
539 elf_tdata (abfd
)->group_sect_ptr
540 = bfd_alloc2 (abfd
, num_group
, sizeof (Elf_Internal_Shdr
*));
541 if (elf_tdata (abfd
)->group_sect_ptr
== NULL
)
545 for (i
= 0; i
< shnum
; i
++)
547 Elf_Internal_Shdr
*shdr
= elf_elfsections (abfd
)[i
];
549 if (IS_VALID_GROUP_SECTION_HEADER (shdr
))
552 Elf_Internal_Group
*dest
;
554 /* Add to list of sections. */
555 elf_tdata (abfd
)->group_sect_ptr
[num_group
] = shdr
;
558 /* Read the raw contents. */
559 BFD_ASSERT (sizeof (*dest
) >= 4);
560 amt
= shdr
->sh_size
* sizeof (*dest
) / 4;
561 shdr
->contents
= bfd_alloc2 (abfd
, shdr
->sh_size
,
563 /* PR binutils/4110: Handle corrupt group headers. */
564 if (shdr
->contents
== NULL
)
567 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd
, shdr
->sh_size
);
568 bfd_set_error (bfd_error_bad_value
);
572 memset (shdr
->contents
, 0, amt
);
574 if (bfd_seek (abfd
, shdr
->sh_offset
, SEEK_SET
) != 0
575 || (bfd_bread (shdr
->contents
, shdr
->sh_size
, abfd
)
579 /* Translate raw contents, a flag word followed by an
580 array of elf section indices all in target byte order,
581 to the flag word followed by an array of elf section
583 src
= shdr
->contents
+ shdr
->sh_size
;
584 dest
= (Elf_Internal_Group
*) (shdr
->contents
+ amt
);
591 idx
= H_GET_32 (abfd
, src
);
592 if (src
== shdr
->contents
)
595 if (shdr
->bfd_section
!= NULL
&& (idx
& GRP_COMDAT
))
596 shdr
->bfd_section
->flags
597 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
602 ((*_bfd_error_handler
)
603 (_("%B: invalid SHT_GROUP entry"), abfd
));
606 dest
->shdr
= elf_elfsections (abfd
)[idx
];
613 if (num_group
!= (unsigned) -1)
617 for (i
= 0; i
< num_group
; i
++)
619 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
620 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
621 unsigned int n_elt
= shdr
->sh_size
/ 4;
623 /* Look through this group's sections to see if current
624 section is a member. */
626 if ((++idx
)->shdr
== hdr
)
630 /* We are a member of this group. Go looking through
631 other members to see if any others are linked via
633 idx
= (Elf_Internal_Group
*) shdr
->contents
;
634 n_elt
= shdr
->sh_size
/ 4;
636 if ((s
= (++idx
)->shdr
->bfd_section
) != NULL
637 && elf_next_in_group (s
) != NULL
)
641 /* Snarf the group name from other member, and
642 insert current section in circular list. */
643 elf_group_name (newsect
) = elf_group_name (s
);
644 elf_next_in_group (newsect
) = elf_next_in_group (s
);
645 elf_next_in_group (s
) = newsect
;
651 gname
= group_signature (abfd
, shdr
);
654 elf_group_name (newsect
) = gname
;
656 /* Start a circular list with one element. */
657 elf_next_in_group (newsect
) = newsect
;
660 /* If the group section has been created, point to the
662 if (shdr
->bfd_section
!= NULL
)
663 elf_next_in_group (shdr
->bfd_section
) = newsect
;
671 if (elf_group_name (newsect
) == NULL
)
673 (*_bfd_error_handler
) (_("%B: no group info for section %A"),
680 _bfd_elf_setup_sections (bfd
*abfd
)
683 unsigned int num_group
= elf_tdata (abfd
)->num_group
;
684 bfd_boolean result
= TRUE
;
687 /* Process SHF_LINK_ORDER. */
688 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
690 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (s
)->this_hdr
;
691 if ((this_hdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
693 unsigned int elfsec
= this_hdr
->sh_link
;
694 /* FIXME: The old Intel compiler and old strip/objcopy may
695 not set the sh_link or sh_info fields. Hence we could
696 get the situation where elfsec is 0. */
699 const struct elf_backend_data
*bed
700 = get_elf_backend_data (abfd
);
701 if (bed
->link_order_error_handler
)
702 bed
->link_order_error_handler
703 (_("%B: warning: sh_link not set for section `%A'"),
710 this_hdr
= elf_elfsections (abfd
)[elfsec
];
713 Some strip/objcopy may leave an incorrect value in
714 sh_link. We don't want to proceed. */
715 link
= this_hdr
->bfd_section
;
718 (*_bfd_error_handler
)
719 (_("%B: sh_link [%d] in section `%A' is incorrect"),
720 s
->owner
, s
, elfsec
);
724 elf_linked_to_section (s
) = link
;
729 /* Process section groups. */
730 if (num_group
== (unsigned) -1)
733 for (i
= 0; i
< num_group
; i
++)
735 Elf_Internal_Shdr
*shdr
= elf_tdata (abfd
)->group_sect_ptr
[i
];
736 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) shdr
->contents
;
737 unsigned int n_elt
= shdr
->sh_size
/ 4;
740 if ((++idx
)->shdr
->bfd_section
)
741 elf_sec_group (idx
->shdr
->bfd_section
) = shdr
->bfd_section
;
742 else if (idx
->shdr
->sh_type
== SHT_RELA
743 || idx
->shdr
->sh_type
== SHT_REL
)
744 /* We won't include relocation sections in section groups in
745 output object files. We adjust the group section size here
746 so that relocatable link will work correctly when
747 relocation sections are in section group in input object
749 shdr
->bfd_section
->size
-= 4;
752 /* There are some unknown sections in the group. */
753 (*_bfd_error_handler
)
754 (_("%B: unknown [%d] section `%s' in group [%s]"),
756 (unsigned int) idx
->shdr
->sh_type
,
757 bfd_elf_string_from_elf_section (abfd
,
758 (elf_elfheader (abfd
)
761 shdr
->bfd_section
->name
);
769 bfd_elf_is_group_section (bfd
*abfd ATTRIBUTE_UNUSED
, const asection
*sec
)
771 return elf_next_in_group (sec
) != NULL
;
774 /* Make a BFD section from an ELF section. We store a pointer to the
775 BFD section in the bfd_section field of the header. */
778 _bfd_elf_make_section_from_shdr (bfd
*abfd
,
779 Elf_Internal_Shdr
*hdr
,
785 const struct elf_backend_data
*bed
;
787 if (hdr
->bfd_section
!= NULL
)
789 BFD_ASSERT (strcmp (name
,
790 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
794 newsect
= bfd_make_section_anyway (abfd
, name
);
798 hdr
->bfd_section
= newsect
;
799 elf_section_data (newsect
)->this_hdr
= *hdr
;
800 elf_section_data (newsect
)->this_idx
= shindex
;
802 /* Always use the real type/flags. */
803 elf_section_type (newsect
) = hdr
->sh_type
;
804 elf_section_flags (newsect
) = hdr
->sh_flags
;
806 newsect
->filepos
= hdr
->sh_offset
;
808 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
809 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
810 || ! bfd_set_section_alignment (abfd
, newsect
,
811 bfd_log2 ((bfd_vma
) hdr
->sh_addralign
)))
814 flags
= SEC_NO_FLAGS
;
815 if (hdr
->sh_type
!= SHT_NOBITS
)
816 flags
|= SEC_HAS_CONTENTS
;
817 if (hdr
->sh_type
== SHT_GROUP
)
818 flags
|= SEC_GROUP
| SEC_EXCLUDE
;
819 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
822 if (hdr
->sh_type
!= SHT_NOBITS
)
825 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
826 flags
|= SEC_READONLY
;
827 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
829 else if ((flags
& SEC_LOAD
) != 0)
831 if ((hdr
->sh_flags
& SHF_MERGE
) != 0)
834 newsect
->entsize
= hdr
->sh_entsize
;
835 if ((hdr
->sh_flags
& SHF_STRINGS
) != 0)
836 flags
|= SEC_STRINGS
;
838 if (hdr
->sh_flags
& SHF_GROUP
)
839 if (!setup_group (abfd
, hdr
, newsect
))
841 if ((hdr
->sh_flags
& SHF_TLS
) != 0)
842 flags
|= SEC_THREAD_LOCAL
;
844 if ((flags
& SEC_ALLOC
) == 0)
846 /* The debugging sections appear to be recognized only by name,
847 not any sort of flag. Their SEC_ALLOC bits are cleared. */
852 } debug_sections
[] =
854 { STRING_COMMA_LEN ("debug") }, /* 'd' */
855 { NULL
, 0 }, /* 'e' */
856 { NULL
, 0 }, /* 'f' */
857 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
858 { NULL
, 0 }, /* 'h' */
859 { NULL
, 0 }, /* 'i' */
860 { NULL
, 0 }, /* 'j' */
861 { NULL
, 0 }, /* 'k' */
862 { STRING_COMMA_LEN ("line") }, /* 'l' */
863 { NULL
, 0 }, /* 'm' */
864 { NULL
, 0 }, /* 'n' */
865 { NULL
, 0 }, /* 'o' */
866 { NULL
, 0 }, /* 'p' */
867 { NULL
, 0 }, /* 'q' */
868 { NULL
, 0 }, /* 'r' */
869 { STRING_COMMA_LEN ("stab") } /* 's' */
874 int i
= name
[1] - 'd';
876 && i
< (int) ARRAY_SIZE (debug_sections
)
877 && debug_sections
[i
].name
!= NULL
878 && strncmp (&name
[1], debug_sections
[i
].name
,
879 debug_sections
[i
].len
) == 0)
880 flags
|= SEC_DEBUGGING
;
884 /* As a GNU extension, if the name begins with .gnu.linkonce, we
885 only link a single copy of the section. This is used to support
886 g++. g++ will emit each template expansion in its own section.
887 The symbols will be defined as weak, so that multiple definitions
888 are permitted. The GNU linker extension is to actually discard
889 all but one of the sections. */
890 if (CONST_STRNEQ (name
, ".gnu.linkonce")
891 && elf_next_in_group (newsect
) == NULL
)
892 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
894 bed
= get_elf_backend_data (abfd
);
895 if (bed
->elf_backend_section_flags
)
896 if (! bed
->elf_backend_section_flags (&flags
, hdr
))
899 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
902 if ((flags
& SEC_ALLOC
) != 0)
904 Elf_Internal_Phdr
*phdr
;
907 /* Look through the phdrs to see if we need to adjust the lma.
908 If all the p_paddr fields are zero, we ignore them, since
909 some ELF linkers produce such output. */
910 phdr
= elf_tdata (abfd
)->phdr
;
911 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
913 if (phdr
->p_paddr
!= 0)
916 if (i
< elf_elfheader (abfd
)->e_phnum
)
918 phdr
= elf_tdata (abfd
)->phdr
;
919 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
921 /* This section is part of this segment if its file
922 offset plus size lies within the segment's memory
923 span and, if the section is loaded, the extent of the
924 loaded data lies within the extent of the segment.
926 Note - we used to check the p_paddr field as well, and
927 refuse to set the LMA if it was 0. This is wrong
928 though, as a perfectly valid initialised segment can
929 have a p_paddr of zero. Some architectures, eg ARM,
930 place special significance on the address 0 and
931 executables need to be able to have a segment which
932 covers this address. */
933 if (phdr
->p_type
== PT_LOAD
934 && (bfd_vma
) hdr
->sh_offset
>= phdr
->p_offset
935 && (hdr
->sh_offset
+ hdr
->sh_size
936 <= phdr
->p_offset
+ phdr
->p_memsz
)
937 && ((flags
& SEC_LOAD
) == 0
938 || (hdr
->sh_offset
+ hdr
->sh_size
939 <= phdr
->p_offset
+ phdr
->p_filesz
)))
941 if ((flags
& SEC_LOAD
) == 0)
942 newsect
->lma
= (phdr
->p_paddr
943 + hdr
->sh_addr
- phdr
->p_vaddr
);
945 /* We used to use the same adjustment for SEC_LOAD
946 sections, but that doesn't work if the segment
947 is packed with code from multiple VMAs.
948 Instead we calculate the section LMA based on
949 the segment LMA. It is assumed that the
950 segment will contain sections with contiguous
951 LMAs, even if the VMAs are not. */
952 newsect
->lma
= (phdr
->p_paddr
953 + hdr
->sh_offset
- phdr
->p_offset
);
955 /* With contiguous segments, we can't tell from file
956 offsets whether a section with zero size should
957 be placed at the end of one segment or the
958 beginning of the next. Decide based on vaddr. */
959 if (hdr
->sh_addr
>= phdr
->p_vaddr
960 && (hdr
->sh_addr
+ hdr
->sh_size
961 <= phdr
->p_vaddr
+ phdr
->p_memsz
))
976 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
979 Helper functions for GDB to locate the string tables.
980 Since BFD hides string tables from callers, GDB needs to use an
981 internal hook to find them. Sun's .stabstr, in particular,
982 isn't even pointed to by the .stab section, so ordinary
983 mechanisms wouldn't work to find it, even if we had some.
986 struct elf_internal_shdr
*
987 bfd_elf_find_section (bfd
*abfd
, char *name
)
989 Elf_Internal_Shdr
**i_shdrp
;
994 i_shdrp
= elf_elfsections (abfd
);
997 shstrtab
= bfd_elf_get_str_section (abfd
,
998 elf_elfheader (abfd
)->e_shstrndx
);
999 if (shstrtab
!= NULL
)
1001 max
= elf_numsections (abfd
);
1002 for (i
= 1; i
< max
; i
++)
1003 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
1010 const char *const bfd_elf_section_type_names
[] = {
1011 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1012 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1013 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1016 /* ELF relocs are against symbols. If we are producing relocatable
1017 output, and the reloc is against an external symbol, and nothing
1018 has given us any additional addend, the resulting reloc will also
1019 be against the same symbol. In such a case, we don't want to
1020 change anything about the way the reloc is handled, since it will
1021 all be done at final link time. Rather than put special case code
1022 into bfd_perform_relocation, all the reloc types use this howto
1023 function. It just short circuits the reloc if producing
1024 relocatable output against an external symbol. */
1026 bfd_reloc_status_type
1027 bfd_elf_generic_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
1028 arelent
*reloc_entry
,
1030 void *data ATTRIBUTE_UNUSED
,
1031 asection
*input_section
,
1033 char **error_message ATTRIBUTE_UNUSED
)
1035 if (output_bfd
!= NULL
1036 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
1037 && (! reloc_entry
->howto
->partial_inplace
1038 || reloc_entry
->addend
== 0))
1040 reloc_entry
->address
+= input_section
->output_offset
;
1041 return bfd_reloc_ok
;
1044 return bfd_reloc_continue
;
1047 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
1050 merge_sections_remove_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
1053 BFD_ASSERT (sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
);
1054 sec
->sec_info_type
= ELF_INFO_TYPE_NONE
;
1057 /* Finish SHF_MERGE section merging. */
1060 _bfd_elf_merge_sections (bfd
*abfd
, struct bfd_link_info
*info
)
1065 if (!is_elf_hash_table (info
->hash
))
1068 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1069 if ((ibfd
->flags
& DYNAMIC
) == 0)
1070 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1071 if ((sec
->flags
& SEC_MERGE
) != 0
1072 && !bfd_is_abs_section (sec
->output_section
))
1074 struct bfd_elf_section_data
*secdata
;
1076 secdata
= elf_section_data (sec
);
1077 if (! _bfd_add_merge_section (abfd
,
1078 &elf_hash_table (info
)->merge_info
,
1079 sec
, &secdata
->sec_info
))
1081 else if (secdata
->sec_info
)
1082 sec
->sec_info_type
= ELF_INFO_TYPE_MERGE
;
1085 if (elf_hash_table (info
)->merge_info
!= NULL
)
1086 _bfd_merge_sections (abfd
, info
, elf_hash_table (info
)->merge_info
,
1087 merge_sections_remove_hook
);
1092 _bfd_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
1094 sec
->output_section
= bfd_abs_section_ptr
;
1095 sec
->output_offset
= sec
->vma
;
1096 if (!is_elf_hash_table (info
->hash
))
1099 sec
->sec_info_type
= ELF_INFO_TYPE_JUST_SYMS
;
1102 /* Copy the program header and other data from one object module to
1106 _bfd_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1108 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1109 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1112 BFD_ASSERT (!elf_flags_init (obfd
)
1113 || (elf_elfheader (obfd
)->e_flags
1114 == elf_elfheader (ibfd
)->e_flags
));
1116 elf_gp (obfd
) = elf_gp (ibfd
);
1117 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
1118 elf_flags_init (obfd
) = TRUE
;
1120 /* Copy object attributes. */
1121 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
1127 get_segment_type (unsigned int p_type
)
1132 case PT_NULL
: pt
= "NULL"; break;
1133 case PT_LOAD
: pt
= "LOAD"; break;
1134 case PT_DYNAMIC
: pt
= "DYNAMIC"; break;
1135 case PT_INTERP
: pt
= "INTERP"; break;
1136 case PT_NOTE
: pt
= "NOTE"; break;
1137 case PT_SHLIB
: pt
= "SHLIB"; break;
1138 case PT_PHDR
: pt
= "PHDR"; break;
1139 case PT_TLS
: pt
= "TLS"; break;
1140 case PT_GNU_EH_FRAME
: pt
= "EH_FRAME"; break;
1141 case PT_GNU_STACK
: pt
= "STACK"; break;
1142 case PT_GNU_RELRO
: pt
= "RELRO"; break;
1143 default: pt
= NULL
; break;
1148 /* Print out the program headers. */
1151 _bfd_elf_print_private_bfd_data (bfd
*abfd
, void *farg
)
1154 Elf_Internal_Phdr
*p
;
1156 bfd_byte
*dynbuf
= NULL
;
1158 p
= elf_tdata (abfd
)->phdr
;
1163 fprintf (f
, _("\nProgram Header:\n"));
1164 c
= elf_elfheader (abfd
)->e_phnum
;
1165 for (i
= 0; i
< c
; i
++, p
++)
1167 const char *pt
= get_segment_type (p
->p_type
);
1172 sprintf (buf
, "0x%lx", p
->p_type
);
1175 fprintf (f
, "%8s off 0x", pt
);
1176 bfd_fprintf_vma (abfd
, f
, p
->p_offset
);
1177 fprintf (f
, " vaddr 0x");
1178 bfd_fprintf_vma (abfd
, f
, p
->p_vaddr
);
1179 fprintf (f
, " paddr 0x");
1180 bfd_fprintf_vma (abfd
, f
, p
->p_paddr
);
1181 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
1182 fprintf (f
, " filesz 0x");
1183 bfd_fprintf_vma (abfd
, f
, p
->p_filesz
);
1184 fprintf (f
, " memsz 0x");
1185 bfd_fprintf_vma (abfd
, f
, p
->p_memsz
);
1186 fprintf (f
, " flags %c%c%c",
1187 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
1188 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
1189 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
1190 if ((p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
)) != 0)
1191 fprintf (f
, " %lx", p
->p_flags
&~ (unsigned) (PF_R
| PF_W
| PF_X
));
1196 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1200 unsigned long shlink
;
1201 bfd_byte
*extdyn
, *extdynend
;
1203 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1205 fprintf (f
, _("\nDynamic Section:\n"));
1207 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1210 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1213 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1215 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1216 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1219 extdynend
= extdyn
+ s
->size
;
1220 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1222 Elf_Internal_Dyn dyn
;
1225 bfd_boolean stringp
;
1227 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1229 if (dyn
.d_tag
== DT_NULL
)
1236 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
1240 case DT_NEEDED
: name
= "NEEDED"; stringp
= TRUE
; break;
1241 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
1242 case DT_PLTGOT
: name
= "PLTGOT"; break;
1243 case DT_HASH
: name
= "HASH"; break;
1244 case DT_STRTAB
: name
= "STRTAB"; break;
1245 case DT_SYMTAB
: name
= "SYMTAB"; break;
1246 case DT_RELA
: name
= "RELA"; break;
1247 case DT_RELASZ
: name
= "RELASZ"; break;
1248 case DT_RELAENT
: name
= "RELAENT"; break;
1249 case DT_STRSZ
: name
= "STRSZ"; break;
1250 case DT_SYMENT
: name
= "SYMENT"; break;
1251 case DT_INIT
: name
= "INIT"; break;
1252 case DT_FINI
: name
= "FINI"; break;
1253 case DT_SONAME
: name
= "SONAME"; stringp
= TRUE
; break;
1254 case DT_RPATH
: name
= "RPATH"; stringp
= TRUE
; break;
1255 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
1256 case DT_REL
: name
= "REL"; break;
1257 case DT_RELSZ
: name
= "RELSZ"; break;
1258 case DT_RELENT
: name
= "RELENT"; break;
1259 case DT_PLTREL
: name
= "PLTREL"; break;
1260 case DT_DEBUG
: name
= "DEBUG"; break;
1261 case DT_TEXTREL
: name
= "TEXTREL"; break;
1262 case DT_JMPREL
: name
= "JMPREL"; break;
1263 case DT_BIND_NOW
: name
= "BIND_NOW"; break;
1264 case DT_INIT_ARRAY
: name
= "INIT_ARRAY"; break;
1265 case DT_FINI_ARRAY
: name
= "FINI_ARRAY"; break;
1266 case DT_INIT_ARRAYSZ
: name
= "INIT_ARRAYSZ"; break;
1267 case DT_FINI_ARRAYSZ
: name
= "FINI_ARRAYSZ"; break;
1268 case DT_RUNPATH
: name
= "RUNPATH"; stringp
= TRUE
; break;
1269 case DT_FLAGS
: name
= "FLAGS"; break;
1270 case DT_PREINIT_ARRAY
: name
= "PREINIT_ARRAY"; break;
1271 case DT_PREINIT_ARRAYSZ
: name
= "PREINIT_ARRAYSZ"; break;
1272 case DT_CHECKSUM
: name
= "CHECKSUM"; break;
1273 case DT_PLTPADSZ
: name
= "PLTPADSZ"; break;
1274 case DT_MOVEENT
: name
= "MOVEENT"; break;
1275 case DT_MOVESZ
: name
= "MOVESZ"; break;
1276 case DT_FEATURE
: name
= "FEATURE"; break;
1277 case DT_POSFLAG_1
: name
= "POSFLAG_1"; break;
1278 case DT_SYMINSZ
: name
= "SYMINSZ"; break;
1279 case DT_SYMINENT
: name
= "SYMINENT"; break;
1280 case DT_CONFIG
: name
= "CONFIG"; stringp
= TRUE
; break;
1281 case DT_DEPAUDIT
: name
= "DEPAUDIT"; stringp
= TRUE
; break;
1282 case DT_AUDIT
: name
= "AUDIT"; stringp
= TRUE
; break;
1283 case DT_PLTPAD
: name
= "PLTPAD"; break;
1284 case DT_MOVETAB
: name
= "MOVETAB"; break;
1285 case DT_SYMINFO
: name
= "SYMINFO"; break;
1286 case DT_RELACOUNT
: name
= "RELACOUNT"; break;
1287 case DT_RELCOUNT
: name
= "RELCOUNT"; break;
1288 case DT_FLAGS_1
: name
= "FLAGS_1"; break;
1289 case DT_VERSYM
: name
= "VERSYM"; break;
1290 case DT_VERDEF
: name
= "VERDEF"; break;
1291 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
1292 case DT_VERNEED
: name
= "VERNEED"; break;
1293 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
1294 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= TRUE
; break;
1295 case DT_USED
: name
= "USED"; break;
1296 case DT_FILTER
: name
= "FILTER"; stringp
= TRUE
; break;
1297 case DT_GNU_HASH
: name
= "GNU_HASH"; break;
1300 fprintf (f
, " %-11s ", name
);
1302 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
1306 unsigned int tagv
= dyn
.d_un
.d_val
;
1308 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1311 fprintf (f
, "%s", string
);
1320 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
1321 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
1323 if (! _bfd_elf_slurp_version_tables (abfd
, FALSE
))
1327 if (elf_dynverdef (abfd
) != 0)
1329 Elf_Internal_Verdef
*t
;
1331 fprintf (f
, _("\nVersion definitions:\n"));
1332 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
1334 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
1335 t
->vd_flags
, t
->vd_hash
,
1336 t
->vd_nodename
? t
->vd_nodename
: "<corrupt>");
1337 if (t
->vd_auxptr
!= NULL
&& t
->vd_auxptr
->vda_nextptr
!= NULL
)
1339 Elf_Internal_Verdaux
*a
;
1342 for (a
= t
->vd_auxptr
->vda_nextptr
;
1346 a
->vda_nodename
? a
->vda_nodename
: "<corrupt>");
1352 if (elf_dynverref (abfd
) != 0)
1354 Elf_Internal_Verneed
*t
;
1356 fprintf (f
, _("\nVersion References:\n"));
1357 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
1359 Elf_Internal_Vernaux
*a
;
1361 fprintf (f
, _(" required from %s:\n"),
1362 t
->vn_filename
? t
->vn_filename
: "<corrupt>");
1363 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1364 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
1365 a
->vna_flags
, a
->vna_other
,
1366 a
->vna_nodename
? a
->vna_nodename
: "<corrupt>");
1378 /* Display ELF-specific fields of a symbol. */
1381 bfd_elf_print_symbol (bfd
*abfd
,
1384 bfd_print_symbol_type how
)
1389 case bfd_print_symbol_name
:
1390 fprintf (file
, "%s", symbol
->name
);
1392 case bfd_print_symbol_more
:
1393 fprintf (file
, "elf ");
1394 bfd_fprintf_vma (abfd
, file
, symbol
->value
);
1395 fprintf (file
, " %lx", (long) symbol
->flags
);
1397 case bfd_print_symbol_all
:
1399 const char *section_name
;
1400 const char *name
= NULL
;
1401 const struct elf_backend_data
*bed
;
1402 unsigned char st_other
;
1405 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
1407 bed
= get_elf_backend_data (abfd
);
1408 if (bed
->elf_backend_print_symbol_all
)
1409 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
1413 name
= symbol
->name
;
1414 bfd_print_symbol_vandf (abfd
, file
, symbol
);
1417 fprintf (file
, " %s\t", section_name
);
1418 /* Print the "other" value for a symbol. For common symbols,
1419 we've already printed the size; now print the alignment.
1420 For other symbols, we have no specified alignment, and
1421 we've printed the address; now print the size. */
1422 if (bfd_is_com_section (symbol
->section
))
1423 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
;
1425 val
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
;
1426 bfd_fprintf_vma (abfd
, file
, val
);
1428 /* If we have version information, print it. */
1429 if (elf_tdata (abfd
)->dynversym_section
!= 0
1430 && (elf_tdata (abfd
)->dynverdef_section
!= 0
1431 || elf_tdata (abfd
)->dynverref_section
!= 0))
1433 unsigned int vernum
;
1434 const char *version_string
;
1436 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
1439 version_string
= "";
1440 else if (vernum
== 1)
1441 version_string
= "Base";
1442 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
1444 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
1447 Elf_Internal_Verneed
*t
;
1449 version_string
= "";
1450 for (t
= elf_tdata (abfd
)->verref
;
1454 Elf_Internal_Vernaux
*a
;
1456 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
1458 if (a
->vna_other
== vernum
)
1460 version_string
= a
->vna_nodename
;
1467 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
1468 fprintf (file
, " %-11s", version_string
);
1473 fprintf (file
, " (%s)", version_string
);
1474 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
1479 /* If the st_other field is not zero, print it. */
1480 st_other
= ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
;
1485 case STV_INTERNAL
: fprintf (file
, " .internal"); break;
1486 case STV_HIDDEN
: fprintf (file
, " .hidden"); break;
1487 case STV_PROTECTED
: fprintf (file
, " .protected"); break;
1489 /* Some other non-defined flags are also present, so print
1491 fprintf (file
, " 0x%02x", (unsigned int) st_other
);
1494 fprintf (file
, " %s", name
);
1500 /* Create an entry in an ELF linker hash table. */
1502 struct bfd_hash_entry
*
1503 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1504 struct bfd_hash_table
*table
,
1507 /* Allocate the structure if it has not already been allocated by a
1511 entry
= bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
));
1516 /* Call the allocation method of the superclass. */
1517 entry
= _bfd_link_hash_newfunc (entry
, table
, string
);
1520 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
1521 struct elf_link_hash_table
*htab
= (struct elf_link_hash_table
*) table
;
1523 /* Set local fields. */
1526 ret
->got
= htab
->init_got_refcount
;
1527 ret
->plt
= htab
->init_plt_refcount
;
1528 memset (&ret
->size
, 0, (sizeof (struct elf_link_hash_entry
)
1529 - offsetof (struct elf_link_hash_entry
, size
)));
1530 /* Assume that we have been called by a non-ELF symbol reader.
1531 This flag is then reset by the code which reads an ELF input
1532 file. This ensures that a symbol created by a non-ELF symbol
1533 reader will have the flag set correctly. */
1540 /* Copy data from an indirect symbol to its direct symbol, hiding the
1541 old indirect symbol. Also used for copying flags to a weakdef. */
1544 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info
*info
,
1545 struct elf_link_hash_entry
*dir
,
1546 struct elf_link_hash_entry
*ind
)
1548 struct elf_link_hash_table
*htab
;
1550 /* Copy down any references that we may have already seen to the
1551 symbol which just became indirect. */
1553 dir
->ref_dynamic
|= ind
->ref_dynamic
;
1554 dir
->ref_regular
|= ind
->ref_regular
;
1555 dir
->ref_regular_nonweak
|= ind
->ref_regular_nonweak
;
1556 dir
->non_got_ref
|= ind
->non_got_ref
;
1557 dir
->needs_plt
|= ind
->needs_plt
;
1558 dir
->pointer_equality_needed
|= ind
->pointer_equality_needed
;
1560 if (ind
->root
.type
!= bfd_link_hash_indirect
)
1563 /* Copy over the global and procedure linkage table refcount entries.
1564 These may have been already set up by a check_relocs routine. */
1565 htab
= elf_hash_table (info
);
1566 if (ind
->got
.refcount
> htab
->init_got_refcount
.refcount
)
1568 if (dir
->got
.refcount
< 0)
1569 dir
->got
.refcount
= 0;
1570 dir
->got
.refcount
+= ind
->got
.refcount
;
1571 ind
->got
.refcount
= htab
->init_got_refcount
.refcount
;
1574 if (ind
->plt
.refcount
> htab
->init_plt_refcount
.refcount
)
1576 if (dir
->plt
.refcount
< 0)
1577 dir
->plt
.refcount
= 0;
1578 dir
->plt
.refcount
+= ind
->plt
.refcount
;
1579 ind
->plt
.refcount
= htab
->init_plt_refcount
.refcount
;
1582 if (ind
->dynindx
!= -1)
1584 if (dir
->dynindx
!= -1)
1585 _bfd_elf_strtab_delref (htab
->dynstr
, dir
->dynstr_index
);
1586 dir
->dynindx
= ind
->dynindx
;
1587 dir
->dynstr_index
= ind
->dynstr_index
;
1589 ind
->dynstr_index
= 0;
1594 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info
*info
,
1595 struct elf_link_hash_entry
*h
,
1596 bfd_boolean force_local
)
1598 h
->plt
= elf_hash_table (info
)->init_plt_offset
;
1602 h
->forced_local
= 1;
1603 if (h
->dynindx
!= -1)
1606 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1612 /* Initialize an ELF linker hash table. */
1615 _bfd_elf_link_hash_table_init
1616 (struct elf_link_hash_table
*table
,
1618 struct bfd_hash_entry
*(*newfunc
) (struct bfd_hash_entry
*,
1619 struct bfd_hash_table
*,
1621 unsigned int entsize
)
1624 int can_refcount
= get_elf_backend_data (abfd
)->can_refcount
;
1626 memset (table
, 0, sizeof * table
);
1627 table
->init_got_refcount
.refcount
= can_refcount
- 1;
1628 table
->init_plt_refcount
.refcount
= can_refcount
- 1;
1629 table
->init_got_offset
.offset
= -(bfd_vma
) 1;
1630 table
->init_plt_offset
.offset
= -(bfd_vma
) 1;
1631 /* The first dynamic symbol is a dummy. */
1632 table
->dynsymcount
= 1;
1634 ret
= _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
, entsize
);
1635 table
->root
.type
= bfd_link_elf_hash_table
;
1640 /* Create an ELF linker hash table. */
1642 struct bfd_link_hash_table
*
1643 _bfd_elf_link_hash_table_create (bfd
*abfd
)
1645 struct elf_link_hash_table
*ret
;
1646 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1648 ret
= bfd_malloc (amt
);
1652 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
,
1653 sizeof (struct elf_link_hash_entry
)))
1662 /* This is a hook for the ELF emulation code in the generic linker to
1663 tell the backend linker what file name to use for the DT_NEEDED
1664 entry for a dynamic object. */
1667 bfd_elf_set_dt_needed_name (bfd
*abfd
, const char *name
)
1669 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1670 && bfd_get_format (abfd
) == bfd_object
)
1671 elf_dt_name (abfd
) = name
;
1675 bfd_elf_get_dyn_lib_class (bfd
*abfd
)
1678 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1679 && bfd_get_format (abfd
) == bfd_object
)
1680 lib_class
= elf_dyn_lib_class (abfd
);
1687 bfd_elf_set_dyn_lib_class (bfd
*abfd
, enum dynamic_lib_link_class lib_class
)
1689 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1690 && bfd_get_format (abfd
) == bfd_object
)
1691 elf_dyn_lib_class (abfd
) = lib_class
;
1694 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1695 the linker ELF emulation code. */
1697 struct bfd_link_needed_list
*
1698 bfd_elf_get_needed_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1699 struct bfd_link_info
*info
)
1701 if (! is_elf_hash_table (info
->hash
))
1703 return elf_hash_table (info
)->needed
;
1706 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1707 hook for the linker ELF emulation code. */
1709 struct bfd_link_needed_list
*
1710 bfd_elf_get_runpath_list (bfd
*abfd ATTRIBUTE_UNUSED
,
1711 struct bfd_link_info
*info
)
1713 if (! is_elf_hash_table (info
->hash
))
1715 return elf_hash_table (info
)->runpath
;
1718 /* Get the name actually used for a dynamic object for a link. This
1719 is the SONAME entry if there is one. Otherwise, it is the string
1720 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1723 bfd_elf_get_dt_soname (bfd
*abfd
)
1725 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1726 && bfd_get_format (abfd
) == bfd_object
)
1727 return elf_dt_name (abfd
);
1731 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1732 the ELF linker emulation code. */
1735 bfd_elf_get_bfd_needed_list (bfd
*abfd
,
1736 struct bfd_link_needed_list
**pneeded
)
1739 bfd_byte
*dynbuf
= NULL
;
1741 unsigned long shlink
;
1742 bfd_byte
*extdyn
, *extdynend
;
1744 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
1748 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1749 || bfd_get_format (abfd
) != bfd_object
)
1752 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1753 if (s
== NULL
|| s
->size
== 0)
1756 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
1759 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1763 shlink
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1765 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1766 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1769 extdynend
= extdyn
+ s
->size
;
1770 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1772 Elf_Internal_Dyn dyn
;
1774 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
1776 if (dyn
.d_tag
== DT_NULL
)
1779 if (dyn
.d_tag
== DT_NEEDED
)
1782 struct bfd_link_needed_list
*l
;
1783 unsigned int tagv
= dyn
.d_un
.d_val
;
1786 string
= bfd_elf_string_from_elf_section (abfd
, shlink
, tagv
);
1791 l
= bfd_alloc (abfd
, amt
);
1812 /* Allocate an ELF string table--force the first byte to be zero. */
1814 struct bfd_strtab_hash
*
1815 _bfd_elf_stringtab_init (void)
1817 struct bfd_strtab_hash
*ret
;
1819 ret
= _bfd_stringtab_init ();
1824 loc
= _bfd_stringtab_add (ret
, "", TRUE
, FALSE
);
1825 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1826 if (loc
== (bfd_size_type
) -1)
1828 _bfd_stringtab_free (ret
);
1835 /* ELF .o/exec file reading */
1837 /* Create a new bfd section from an ELF section header. */
1840 bfd_section_from_shdr (bfd
*abfd
, unsigned int shindex
)
1842 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1843 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1844 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1847 name
= bfd_elf_string_from_elf_section (abfd
,
1848 elf_elfheader (abfd
)->e_shstrndx
,
1853 switch (hdr
->sh_type
)
1856 /* Inactive section. Throw it away. */
1859 case SHT_PROGBITS
: /* Normal section with contents. */
1860 case SHT_NOBITS
: /* .bss section. */
1861 case SHT_HASH
: /* .hash section. */
1862 case SHT_NOTE
: /* .note section. */
1863 case SHT_INIT_ARRAY
: /* .init_array section. */
1864 case SHT_FINI_ARRAY
: /* .fini_array section. */
1865 case SHT_PREINIT_ARRAY
: /* .preinit_array section. */
1866 case SHT_GNU_LIBLIST
: /* .gnu.liblist section. */
1867 case SHT_GNU_HASH
: /* .gnu.hash section. */
1868 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1870 case SHT_DYNAMIC
: /* Dynamic linking information. */
1871 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1873 if (hdr
->sh_link
> elf_numsections (abfd
)
1874 || elf_elfsections (abfd
)[hdr
->sh_link
] == NULL
)
1876 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_STRTAB
)
1878 Elf_Internal_Shdr
*dynsymhdr
;
1880 /* The shared libraries distributed with hpux11 have a bogus
1881 sh_link field for the ".dynamic" section. Find the
1882 string table for the ".dynsym" section instead. */
1883 if (elf_dynsymtab (abfd
) != 0)
1885 dynsymhdr
= elf_elfsections (abfd
)[elf_dynsymtab (abfd
)];
1886 hdr
->sh_link
= dynsymhdr
->sh_link
;
1890 unsigned int i
, num_sec
;
1892 num_sec
= elf_numsections (abfd
);
1893 for (i
= 1; i
< num_sec
; i
++)
1895 dynsymhdr
= elf_elfsections (abfd
)[i
];
1896 if (dynsymhdr
->sh_type
== SHT_DYNSYM
)
1898 hdr
->sh_link
= dynsymhdr
->sh_link
;
1906 case SHT_SYMTAB
: /* A symbol table */
1907 if (elf_onesymtab (abfd
) == shindex
)
1910 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1912 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1913 elf_onesymtab (abfd
) = shindex
;
1914 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1915 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1916 abfd
->flags
|= HAS_SYMS
;
1918 /* Sometimes a shared object will map in the symbol table. If
1919 SHF_ALLOC is set, and this is a shared object, then we also
1920 treat this section as a BFD section. We can not base the
1921 decision purely on SHF_ALLOC, because that flag is sometimes
1922 set in a relocatable object file, which would confuse the
1924 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1925 && (abfd
->flags
& DYNAMIC
) != 0
1926 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
1930 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1931 can't read symbols without that section loaded as well. It
1932 is most likely specified by the next section header. */
1933 if (elf_elfsections (abfd
)[elf_symtab_shndx (abfd
)]->sh_link
!= shindex
)
1935 unsigned int i
, num_sec
;
1937 num_sec
= elf_numsections (abfd
);
1938 for (i
= shindex
+ 1; i
< num_sec
; i
++)
1940 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1941 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1942 && hdr2
->sh_link
== shindex
)
1946 for (i
= 1; i
< shindex
; i
++)
1948 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1949 if (hdr2
->sh_type
== SHT_SYMTAB_SHNDX
1950 && hdr2
->sh_link
== shindex
)
1954 return bfd_section_from_shdr (abfd
, i
);
1958 case SHT_DYNSYM
: /* A dynamic symbol table */
1959 if (elf_dynsymtab (abfd
) == shindex
)
1962 if (hdr
->sh_entsize
!= bed
->s
->sizeof_sym
)
1964 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1965 elf_dynsymtab (abfd
) = shindex
;
1966 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1967 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1968 abfd
->flags
|= HAS_SYMS
;
1970 /* Besides being a symbol table, we also treat this as a regular
1971 section, so that objcopy can handle it. */
1972 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
1974 case SHT_SYMTAB_SHNDX
: /* Symbol section indices when >64k sections */
1975 if (elf_symtab_shndx (abfd
) == shindex
)
1978 BFD_ASSERT (elf_symtab_shndx (abfd
) == 0);
1979 elf_symtab_shndx (abfd
) = shindex
;
1980 elf_tdata (abfd
)->symtab_shndx_hdr
= *hdr
;
1981 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_shndx_hdr
;
1984 case SHT_STRTAB
: /* A string table */
1985 if (hdr
->bfd_section
!= NULL
)
1987 if (ehdr
->e_shstrndx
== shindex
)
1989 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1990 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1993 if (elf_elfsections (abfd
)[elf_onesymtab (abfd
)]->sh_link
== shindex
)
1996 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1997 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
2000 if (elf_elfsections (abfd
)[elf_dynsymtab (abfd
)]->sh_link
== shindex
)
2003 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
2004 hdr
= &elf_tdata (abfd
)->dynstrtab_hdr
;
2005 elf_elfsections (abfd
)[shindex
] = hdr
;
2006 /* We also treat this as a regular section, so that objcopy
2008 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2012 /* If the string table isn't one of the above, then treat it as a
2013 regular section. We need to scan all the headers to be sure,
2014 just in case this strtab section appeared before the above. */
2015 if (elf_onesymtab (abfd
) == 0 || elf_dynsymtab (abfd
) == 0)
2017 unsigned int i
, num_sec
;
2019 num_sec
= elf_numsections (abfd
);
2020 for (i
= 1; i
< num_sec
; i
++)
2022 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
2023 if (hdr2
->sh_link
== shindex
)
2025 /* Prevent endless recursion on broken objects. */
2028 if (! bfd_section_from_shdr (abfd
, i
))
2030 if (elf_onesymtab (abfd
) == i
)
2032 if (elf_dynsymtab (abfd
) == i
)
2033 goto dynsymtab_strtab
;
2037 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2041 /* *These* do a lot of work -- but build no sections! */
2043 asection
*target_sect
;
2044 Elf_Internal_Shdr
*hdr2
;
2045 unsigned int num_sec
= elf_numsections (abfd
);
2048 != (bfd_size_type
) (hdr
->sh_type
== SHT_REL
2049 ? bed
->s
->sizeof_rel
: bed
->s
->sizeof_rela
))
2052 /* Check for a bogus link to avoid crashing. */
2053 if ((hdr
->sh_link
>= SHN_LORESERVE
&& hdr
->sh_link
<= SHN_HIRESERVE
)
2054 || hdr
->sh_link
>= num_sec
)
2056 ((*_bfd_error_handler
)
2057 (_("%B: invalid link %lu for reloc section %s (index %u)"),
2058 abfd
, hdr
->sh_link
, name
, shindex
));
2059 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2063 /* For some incomprehensible reason Oracle distributes
2064 libraries for Solaris in which some of the objects have
2065 bogus sh_link fields. It would be nice if we could just
2066 reject them, but, unfortunately, some people need to use
2067 them. We scan through the section headers; if we find only
2068 one suitable symbol table, we clobber the sh_link to point
2069 to it. I hope this doesn't break anything. */
2070 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
2071 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
2077 for (scan
= 1; scan
< num_sec
; scan
++)
2079 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
2080 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
2091 hdr
->sh_link
= found
;
2094 /* Get the symbol table. */
2095 if ((elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
2096 || elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_DYNSYM
)
2097 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
2100 /* If this reloc section does not use the main symbol table we
2101 don't treat it as a reloc section. BFD can't adequately
2102 represent such a section, so at least for now, we don't
2103 try. We just present it as a normal section. We also
2104 can't use it as a reloc section if it points to the null
2105 section, an invalid section, or another reloc section. */
2106 if (hdr
->sh_link
!= elf_onesymtab (abfd
)
2107 || hdr
->sh_info
== SHN_UNDEF
2108 || (hdr
->sh_info
>= SHN_LORESERVE
&& hdr
->sh_info
<= SHN_HIRESERVE
)
2109 || hdr
->sh_info
>= num_sec
2110 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_REL
2111 || elf_elfsections (abfd
)[hdr
->sh_info
]->sh_type
== SHT_RELA
)
2112 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2115 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
2117 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
2118 if (target_sect
== NULL
)
2121 if ((target_sect
->flags
& SEC_RELOC
) == 0
2122 || target_sect
->reloc_count
== 0)
2123 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
2127 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
2128 amt
= sizeof (*hdr2
);
2129 hdr2
= bfd_alloc (abfd
, amt
);
2130 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
2133 elf_elfsections (abfd
)[shindex
] = hdr2
;
2134 target_sect
->reloc_count
+= NUM_SHDR_ENTRIES (hdr
);
2135 target_sect
->flags
|= SEC_RELOC
;
2136 target_sect
->relocation
= NULL
;
2137 target_sect
->rel_filepos
= hdr
->sh_offset
;
2138 /* In the section to which the relocations apply, mark whether
2139 its relocations are of the REL or RELA variety. */
2140 if (hdr
->sh_size
!= 0)
2141 target_sect
->use_rela_p
= hdr
->sh_type
== SHT_RELA
;
2142 abfd
->flags
|= HAS_RELOC
;
2146 case SHT_GNU_verdef
:
2147 elf_dynverdef (abfd
) = shindex
;
2148 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
2149 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2151 case SHT_GNU_versym
:
2152 if (hdr
->sh_entsize
!= sizeof (Elf_External_Versym
))
2154 elf_dynversym (abfd
) = shindex
;
2155 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
2156 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2158 case SHT_GNU_verneed
:
2159 elf_dynverref (abfd
) = shindex
;
2160 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
2161 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2167 /* We need a BFD section for objcopy and relocatable linking,
2168 and it's handy to have the signature available as the section
2170 if (! IS_VALID_GROUP_SECTION_HEADER (hdr
))
2172 name
= group_signature (abfd
, hdr
);
2175 if (!_bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2177 if (hdr
->contents
!= NULL
)
2179 Elf_Internal_Group
*idx
= (Elf_Internal_Group
*) hdr
->contents
;
2180 unsigned int n_elt
= hdr
->sh_size
/ GRP_ENTRY_SIZE
;
2183 if (idx
->flags
& GRP_COMDAT
)
2184 hdr
->bfd_section
->flags
2185 |= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
2187 /* We try to keep the same section order as it comes in. */
2189 while (--n_elt
!= 0)
2193 if (idx
->shdr
!= NULL
2194 && (s
= idx
->shdr
->bfd_section
) != NULL
2195 && elf_next_in_group (s
) != NULL
)
2197 elf_next_in_group (hdr
->bfd_section
) = s
;
2205 /* Possibly an attributes section. */
2206 if (hdr
->sh_type
== SHT_GNU_ATTRIBUTES
2207 || hdr
->sh_type
== bed
->obj_attrs_section_type
)
2209 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2211 _bfd_elf_parse_attributes (abfd
, hdr
);
2215 /* Check for any processor-specific section types. */
2216 if (bed
->elf_backend_section_from_shdr (abfd
, hdr
, name
, shindex
))
2219 if (hdr
->sh_type
>= SHT_LOUSER
&& hdr
->sh_type
<= SHT_HIUSER
)
2221 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2222 /* FIXME: How to properly handle allocated section reserved
2223 for applications? */
2224 (*_bfd_error_handler
)
2225 (_("%B: don't know how to handle allocated, application "
2226 "specific section `%s' [0x%8x]"),
2227 abfd
, name
, hdr
->sh_type
);
2229 /* Allow sections reserved for applications. */
2230 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
,
2233 else if (hdr
->sh_type
>= SHT_LOPROC
2234 && hdr
->sh_type
<= SHT_HIPROC
)
2235 /* FIXME: We should handle this section. */
2236 (*_bfd_error_handler
)
2237 (_("%B: don't know how to handle processor specific section "
2239 abfd
, name
, hdr
->sh_type
);
2240 else if (hdr
->sh_type
>= SHT_LOOS
&& hdr
->sh_type
<= SHT_HIOS
)
2242 /* Unrecognised OS-specific sections. */
2243 if ((hdr
->sh_flags
& SHF_OS_NONCONFORMING
) != 0)
2244 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2245 required to correctly process the section and the file should
2246 be rejected with an error message. */
2247 (*_bfd_error_handler
)
2248 (_("%B: don't know how to handle OS specific section "
2250 abfd
, name
, hdr
->sh_type
);
2252 /* Otherwise it should be processed. */
2253 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
);
2256 /* FIXME: We should handle this section. */
2257 (*_bfd_error_handler
)
2258 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2259 abfd
, name
, hdr
->sh_type
);
2267 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2268 Return SEC for sections that have no elf section, and NULL on error. */
2271 bfd_section_from_r_symndx (bfd
*abfd
,
2272 struct sym_sec_cache
*cache
,
2274 unsigned long r_symndx
)
2276 Elf_Internal_Shdr
*symtab_hdr
;
2277 unsigned char esym
[sizeof (Elf64_External_Sym
)];
2278 Elf_External_Sym_Shndx eshndx
;
2279 Elf_Internal_Sym isym
;
2280 unsigned int ent
= r_symndx
% LOCAL_SYM_CACHE_SIZE
;
2282 if (cache
->abfd
== abfd
&& cache
->indx
[ent
] == r_symndx
)
2283 return cache
->sec
[ent
];
2285 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2286 if (bfd_elf_get_elf_syms (abfd
, symtab_hdr
, 1, r_symndx
,
2287 &isym
, esym
, &eshndx
) == NULL
)
2290 if (cache
->abfd
!= abfd
)
2292 memset (cache
->indx
, -1, sizeof (cache
->indx
));
2295 cache
->indx
[ent
] = r_symndx
;
2296 cache
->sec
[ent
] = sec
;
2297 if ((isym
.st_shndx
!= SHN_UNDEF
&& isym
.st_shndx
< SHN_LORESERVE
)
2298 || isym
.st_shndx
> SHN_HIRESERVE
)
2301 s
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
2303 cache
->sec
[ent
] = s
;
2305 return cache
->sec
[ent
];
2308 /* Given an ELF section number, retrieve the corresponding BFD
2312 bfd_section_from_elf_index (bfd
*abfd
, unsigned int index
)
2314 if (index
>= elf_numsections (abfd
))
2316 return elf_elfsections (abfd
)[index
]->bfd_section
;
2319 static const struct bfd_elf_special_section special_sections_b
[] =
2321 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2322 { NULL
, 0, 0, 0, 0 }
2325 static const struct bfd_elf_special_section special_sections_c
[] =
2327 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS
, 0 },
2328 { NULL
, 0, 0, 0, 0 }
2331 static const struct bfd_elf_special_section special_sections_d
[] =
2333 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2334 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2335 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS
, 0 },
2336 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS
, 0 },
2337 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS
, 0 },
2338 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS
, 0 },
2339 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS
, 0 },
2340 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC
, SHF_ALLOC
},
2341 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB
, SHF_ALLOC
},
2342 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM
, SHF_ALLOC
},
2343 { NULL
, 0, 0, 0, 0 }
2346 static const struct bfd_elf_special_section special_sections_f
[] =
2348 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2349 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2350 { NULL
, 0, 0, 0, 0 }
2353 static const struct bfd_elf_special_section special_sections_g
[] =
2355 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
2356 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2357 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym
, 0 },
2358 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef
, 0 },
2359 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed
, 0 },
2360 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST
, SHF_ALLOC
},
2361 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA
, SHF_ALLOC
},
2362 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH
, SHF_ALLOC
},
2363 { NULL
, 0, 0, 0, 0 }
2366 static const struct bfd_elf_special_section special_sections_h
[] =
2368 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH
, SHF_ALLOC
},
2369 { NULL
, 0, 0, 0, 0 }
2372 static const struct bfd_elf_special_section special_sections_i
[] =
2374 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2375 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2376 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS
, 0 },
2377 { NULL
, 0, 0, 0, 0 }
2380 static const struct bfd_elf_special_section special_sections_l
[] =
2382 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS
, 0 },
2383 { NULL
, 0, 0, 0, 0 }
2386 static const struct bfd_elf_special_section special_sections_n
[] =
2388 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS
, 0 },
2389 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE
, 0 },
2390 { NULL
, 0, 0, 0, 0 }
2393 static const struct bfd_elf_special_section special_sections_p
[] =
2395 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY
, SHF_ALLOC
+ SHF_WRITE
},
2396 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2397 { NULL
, 0, 0, 0, 0 }
2400 static const struct bfd_elf_special_section special_sections_r
[] =
2402 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS
, SHF_ALLOC
},
2403 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS
, SHF_ALLOC
},
2404 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA
, 0 },
2405 { STRING_COMMA_LEN (".rel"), -1, SHT_REL
, 0 },
2406 { NULL
, 0, 0, 0, 0 }
2409 static const struct bfd_elf_special_section special_sections_s
[] =
2411 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB
, 0 },
2412 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB
, 0 },
2413 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB
, 0 },
2414 /* See struct bfd_elf_special_section declaration for the semantics of
2415 this special case where .prefix_length != strlen (.prefix). */
2416 { ".stabstr", 5, 3, SHT_STRTAB
, 0 },
2417 { NULL
, 0, 0, 0, 0 }
2420 static const struct bfd_elf_special_section special_sections_t
[] =
2422 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
2423 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2424 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_TLS
},
2425 { NULL
, 0, 0, 0, 0 }
2428 static const struct bfd_elf_special_section
*special_sections
[] =
2430 special_sections_b
, /* 'b' */
2431 special_sections_c
, /* 'b' */
2432 special_sections_d
, /* 'd' */
2434 special_sections_f
, /* 'f' */
2435 special_sections_g
, /* 'g' */
2436 special_sections_h
, /* 'h' */
2437 special_sections_i
, /* 'i' */
2440 special_sections_l
, /* 'l' */
2442 special_sections_n
, /* 'n' */
2444 special_sections_p
, /* 'p' */
2446 special_sections_r
, /* 'r' */
2447 special_sections_s
, /* 's' */
2448 special_sections_t
, /* 't' */
2451 const struct bfd_elf_special_section
*
2452 _bfd_elf_get_special_section (const char *name
,
2453 const struct bfd_elf_special_section
*spec
,
2459 len
= strlen (name
);
2461 for (i
= 0; spec
[i
].prefix
!= NULL
; i
++)
2464 int prefix_len
= spec
[i
].prefix_length
;
2466 if (len
< prefix_len
)
2468 if (memcmp (name
, spec
[i
].prefix
, prefix_len
) != 0)
2471 suffix_len
= spec
[i
].suffix_length
;
2472 if (suffix_len
<= 0)
2474 if (name
[prefix_len
] != 0)
2476 if (suffix_len
== 0)
2478 if (name
[prefix_len
] != '.'
2479 && (suffix_len
== -2
2480 || (rela
&& spec
[i
].type
== SHT_REL
)))
2486 if (len
< prefix_len
+ suffix_len
)
2488 if (memcmp (name
+ len
- suffix_len
,
2489 spec
[i
].prefix
+ prefix_len
,
2499 const struct bfd_elf_special_section
*
2500 _bfd_elf_get_sec_type_attr (bfd
*abfd
, asection
*sec
)
2503 const struct bfd_elf_special_section
*spec
;
2504 const struct elf_backend_data
*bed
;
2506 /* See if this is one of the special sections. */
2507 if (sec
->name
== NULL
)
2510 bed
= get_elf_backend_data (abfd
);
2511 spec
= bed
->special_sections
;
2514 spec
= _bfd_elf_get_special_section (sec
->name
,
2515 bed
->special_sections
,
2521 if (sec
->name
[0] != '.')
2524 i
= sec
->name
[1] - 'b';
2525 if (i
< 0 || i
> 't' - 'b')
2528 spec
= special_sections
[i
];
2533 return _bfd_elf_get_special_section (sec
->name
, spec
, sec
->use_rela_p
);
2537 _bfd_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2539 struct bfd_elf_section_data
*sdata
;
2540 const struct elf_backend_data
*bed
;
2541 const struct bfd_elf_special_section
*ssect
;
2543 sdata
= (struct bfd_elf_section_data
*) sec
->used_by_bfd
;
2546 sdata
= bfd_zalloc (abfd
, sizeof (*sdata
));
2549 sec
->used_by_bfd
= sdata
;
2552 /* Indicate whether or not this section should use RELA relocations. */
2553 bed
= get_elf_backend_data (abfd
);
2554 sec
->use_rela_p
= bed
->default_use_rela_p
;
2556 /* When we read a file, we don't need to set ELF section type and
2557 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2558 anyway. We will set ELF section type and flags for all linker
2559 created sections. If user specifies BFD section flags, we will
2560 set ELF section type and flags based on BFD section flags in
2561 elf_fake_sections. */
2562 if ((!sec
->flags
&& abfd
->direction
!= read_direction
)
2563 || (sec
->flags
& SEC_LINKER_CREATED
) != 0)
2565 ssect
= (*bed
->get_sec_type_attr
) (abfd
, sec
);
2568 elf_section_type (sec
) = ssect
->type
;
2569 elf_section_flags (sec
) = ssect
->attr
;
2573 return _bfd_generic_new_section_hook (abfd
, sec
);
2576 /* Create a new bfd section from an ELF program header.
2578 Since program segments have no names, we generate a synthetic name
2579 of the form segment<NUM>, where NUM is generally the index in the
2580 program header table. For segments that are split (see below) we
2581 generate the names segment<NUM>a and segment<NUM>b.
2583 Note that some program segments may have a file size that is different than
2584 (less than) the memory size. All this means is that at execution the
2585 system must allocate the amount of memory specified by the memory size,
2586 but only initialize it with the first "file size" bytes read from the
2587 file. This would occur for example, with program segments consisting
2588 of combined data+bss.
2590 To handle the above situation, this routine generates TWO bfd sections
2591 for the single program segment. The first has the length specified by
2592 the file size of the segment, and the second has the length specified
2593 by the difference between the two sizes. In effect, the segment is split
2594 into it's initialized and uninitialized parts.
2599 _bfd_elf_make_section_from_phdr (bfd
*abfd
,
2600 Elf_Internal_Phdr
*hdr
,
2602 const char *typename
)
2610 split
= ((hdr
->p_memsz
> 0)
2611 && (hdr
->p_filesz
> 0)
2612 && (hdr
->p_memsz
> hdr
->p_filesz
));
2613 sprintf (namebuf
, "%s%d%s", typename
, index
, split
? "a" : "");
2614 len
= strlen (namebuf
) + 1;
2615 name
= bfd_alloc (abfd
, len
);
2618 memcpy (name
, namebuf
, len
);
2619 newsect
= bfd_make_section (abfd
, name
);
2620 if (newsect
== NULL
)
2622 newsect
->vma
= hdr
->p_vaddr
;
2623 newsect
->lma
= hdr
->p_paddr
;
2624 newsect
->size
= hdr
->p_filesz
;
2625 newsect
->filepos
= hdr
->p_offset
;
2626 newsect
->flags
|= SEC_HAS_CONTENTS
;
2627 newsect
->alignment_power
= bfd_log2 (hdr
->p_align
);
2628 if (hdr
->p_type
== PT_LOAD
)
2630 newsect
->flags
|= SEC_ALLOC
;
2631 newsect
->flags
|= SEC_LOAD
;
2632 if (hdr
->p_flags
& PF_X
)
2634 /* FIXME: all we known is that it has execute PERMISSION,
2636 newsect
->flags
|= SEC_CODE
;
2639 if (!(hdr
->p_flags
& PF_W
))
2641 newsect
->flags
|= SEC_READONLY
;
2646 sprintf (namebuf
, "%s%db", typename
, index
);
2647 len
= strlen (namebuf
) + 1;
2648 name
= bfd_alloc (abfd
, len
);
2651 memcpy (name
, namebuf
, len
);
2652 newsect
= bfd_make_section (abfd
, name
);
2653 if (newsect
== NULL
)
2655 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
2656 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
2657 newsect
->size
= hdr
->p_memsz
- hdr
->p_filesz
;
2658 if (hdr
->p_type
== PT_LOAD
)
2660 newsect
->flags
|= SEC_ALLOC
;
2661 if (hdr
->p_flags
& PF_X
)
2662 newsect
->flags
|= SEC_CODE
;
2664 if (!(hdr
->p_flags
& PF_W
))
2665 newsect
->flags
|= SEC_READONLY
;
2672 bfd_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
)
2674 const struct elf_backend_data
*bed
;
2676 switch (hdr
->p_type
)
2679 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "null");
2682 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "load");
2685 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "dynamic");
2688 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "interp");
2691 if (! _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "note"))
2693 if (! elfcore_read_notes (abfd
, hdr
->p_offset
, hdr
->p_filesz
))
2698 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "shlib");
2701 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "phdr");
2703 case PT_GNU_EH_FRAME
:
2704 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
,
2708 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "stack");
2711 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, "relro");
2714 /* Check for any processor-specific program segment types. */
2715 bed
= get_elf_backend_data (abfd
);
2716 return bed
->elf_backend_section_from_phdr (abfd
, hdr
, index
, "proc");
2720 /* Initialize REL_HDR, the section-header for new section, containing
2721 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2722 relocations; otherwise, we use REL relocations. */
2725 _bfd_elf_init_reloc_shdr (bfd
*abfd
,
2726 Elf_Internal_Shdr
*rel_hdr
,
2728 bfd_boolean use_rela_p
)
2731 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2732 bfd_size_type amt
= sizeof ".rela" + strlen (asect
->name
);
2734 name
= bfd_alloc (abfd
, amt
);
2737 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
2739 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
), name
,
2741 if (rel_hdr
->sh_name
== (unsigned int) -1)
2743 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
2744 rel_hdr
->sh_entsize
= (use_rela_p
2745 ? bed
->s
->sizeof_rela
2746 : bed
->s
->sizeof_rel
);
2747 rel_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
2748 rel_hdr
->sh_flags
= 0;
2749 rel_hdr
->sh_addr
= 0;
2750 rel_hdr
->sh_size
= 0;
2751 rel_hdr
->sh_offset
= 0;
2756 /* Set up an ELF internal section header for a section. */
2759 elf_fake_sections (bfd
*abfd
, asection
*asect
, void *failedptrarg
)
2761 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2762 bfd_boolean
*failedptr
= failedptrarg
;
2763 Elf_Internal_Shdr
*this_hdr
;
2764 unsigned int sh_type
;
2768 /* We already failed; just get out of the bfd_map_over_sections
2773 this_hdr
= &elf_section_data (asect
)->this_hdr
;
2775 this_hdr
->sh_name
= (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
2776 asect
->name
, FALSE
);
2777 if (this_hdr
->sh_name
== (unsigned int) -1)
2783 /* Don't clear sh_flags. Assembler may set additional bits. */
2785 if ((asect
->flags
& SEC_ALLOC
) != 0
2786 || asect
->user_set_vma
)
2787 this_hdr
->sh_addr
= asect
->vma
;
2789 this_hdr
->sh_addr
= 0;
2791 this_hdr
->sh_offset
= 0;
2792 this_hdr
->sh_size
= asect
->size
;
2793 this_hdr
->sh_link
= 0;
2794 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
2795 /* The sh_entsize and sh_info fields may have been set already by
2796 copy_private_section_data. */
2798 this_hdr
->bfd_section
= asect
;
2799 this_hdr
->contents
= NULL
;
2801 /* If the section type is unspecified, we set it based on
2803 if (this_hdr
->sh_type
== SHT_NULL
)
2805 if ((asect
->flags
& SEC_GROUP
) != 0)
2806 this_hdr
->sh_type
= SHT_GROUP
;
2807 else if ((asect
->flags
& SEC_ALLOC
) != 0
2808 && (((asect
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
2809 || (asect
->flags
& SEC_NEVER_LOAD
) != 0))
2810 this_hdr
->sh_type
= SHT_NOBITS
;
2812 this_hdr
->sh_type
= SHT_PROGBITS
;
2815 switch (this_hdr
->sh_type
)
2821 case SHT_INIT_ARRAY
:
2822 case SHT_FINI_ARRAY
:
2823 case SHT_PREINIT_ARRAY
:
2830 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
2834 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2838 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
2842 if (get_elf_backend_data (abfd
)->may_use_rela_p
)
2843 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
2847 if (get_elf_backend_data (abfd
)->may_use_rel_p
)
2848 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
2851 case SHT_GNU_versym
:
2852 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
2855 case SHT_GNU_verdef
:
2856 this_hdr
->sh_entsize
= 0;
2857 /* objcopy or strip will copy over sh_info, but may not set
2858 cverdefs. The linker will set cverdefs, but sh_info will be
2860 if (this_hdr
->sh_info
== 0)
2861 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
2863 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
2864 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
2867 case SHT_GNU_verneed
:
2868 this_hdr
->sh_entsize
= 0;
2869 /* objcopy or strip will copy over sh_info, but may not set
2870 cverrefs. The linker will set cverrefs, but sh_info will be
2872 if (this_hdr
->sh_info
== 0)
2873 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
2875 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
2876 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
2880 this_hdr
->sh_entsize
= GRP_ENTRY_SIZE
;
2884 this_hdr
->sh_entsize
= bed
->s
->arch_size
== 64 ? 0 : 4;
2888 if ((asect
->flags
& SEC_ALLOC
) != 0)
2889 this_hdr
->sh_flags
|= SHF_ALLOC
;
2890 if ((asect
->flags
& SEC_READONLY
) == 0)
2891 this_hdr
->sh_flags
|= SHF_WRITE
;
2892 if ((asect
->flags
& SEC_CODE
) != 0)
2893 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
2894 if ((asect
->flags
& SEC_MERGE
) != 0)
2896 this_hdr
->sh_flags
|= SHF_MERGE
;
2897 this_hdr
->sh_entsize
= asect
->entsize
;
2898 if ((asect
->flags
& SEC_STRINGS
) != 0)
2899 this_hdr
->sh_flags
|= SHF_STRINGS
;
2901 if ((asect
->flags
& SEC_GROUP
) == 0 && elf_group_name (asect
) != NULL
)
2902 this_hdr
->sh_flags
|= SHF_GROUP
;
2903 if ((asect
->flags
& SEC_THREAD_LOCAL
) != 0)
2905 this_hdr
->sh_flags
|= SHF_TLS
;
2906 if (asect
->size
== 0
2907 && (asect
->flags
& SEC_HAS_CONTENTS
) == 0)
2909 struct bfd_link_order
*o
= asect
->map_tail
.link_order
;
2911 this_hdr
->sh_size
= 0;
2914 this_hdr
->sh_size
= o
->offset
+ o
->size
;
2915 if (this_hdr
->sh_size
!= 0)
2916 this_hdr
->sh_type
= SHT_NOBITS
;
2921 /* Check for processor-specific section types. */
2922 sh_type
= this_hdr
->sh_type
;
2923 if (bed
->elf_backend_fake_sections
2924 && !(*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
))
2927 if (sh_type
== SHT_NOBITS
&& asect
->size
!= 0)
2929 /* Don't change the header type from NOBITS if we are being
2930 called for objcopy --only-keep-debug. */
2931 this_hdr
->sh_type
= sh_type
;
2934 /* If the section has relocs, set up a section header for the
2935 SHT_REL[A] section. If two relocation sections are required for
2936 this section, it is up to the processor-specific back-end to
2937 create the other. */
2938 if ((asect
->flags
& SEC_RELOC
) != 0
2939 && !_bfd_elf_init_reloc_shdr (abfd
,
2940 &elf_section_data (asect
)->rel_hdr
,
2946 /* Fill in the contents of a SHT_GROUP section. */
2949 bfd_elf_set_group_contents (bfd
*abfd
, asection
*sec
, void *failedptrarg
)
2951 bfd_boolean
*failedptr
= failedptrarg
;
2952 unsigned long symindx
;
2953 asection
*elt
, *first
;
2957 /* Ignore linker created group section. See elfNN_ia64_object_p in
2959 if (((sec
->flags
& (SEC_GROUP
| SEC_LINKER_CREATED
)) != SEC_GROUP
)
2964 if (elf_group_id (sec
) != NULL
)
2965 symindx
= elf_group_id (sec
)->udata
.i
;
2969 /* If called from the assembler, swap_out_syms will have set up
2970 elf_section_syms; If called for "ld -r", use target_index. */
2971 if (elf_section_syms (abfd
) != NULL
)
2972 symindx
= elf_section_syms (abfd
)[sec
->index
]->udata
.i
;
2974 symindx
= sec
->target_index
;
2976 elf_section_data (sec
)->this_hdr
.sh_info
= symindx
;
2978 /* The contents won't be allocated for "ld -r" or objcopy. */
2980 if (sec
->contents
== NULL
)
2983 sec
->contents
= bfd_alloc (abfd
, sec
->size
);
2985 /* Arrange for the section to be written out. */
2986 elf_section_data (sec
)->this_hdr
.contents
= sec
->contents
;
2987 if (sec
->contents
== NULL
)
2994 loc
= sec
->contents
+ sec
->size
;
2996 /* Get the pointer to the first section in the group that gas
2997 squirreled away here. objcopy arranges for this to be set to the
2998 start of the input section group. */
2999 first
= elt
= elf_next_in_group (sec
);
3001 /* First element is a flag word. Rest of section is elf section
3002 indices for all the sections of the group. Write them backwards
3003 just to keep the group in the same order as given in .section
3004 directives, not that it matters. */
3013 s
= s
->output_section
;
3016 idx
= elf_section_data (s
)->this_idx
;
3017 H_PUT_32 (abfd
, idx
, loc
);
3018 elt
= elf_next_in_group (elt
);
3023 if ((loc
-= 4) != sec
->contents
)
3026 H_PUT_32 (abfd
, sec
->flags
& SEC_LINK_ONCE
? GRP_COMDAT
: 0, loc
);
3029 /* Assign all ELF section numbers. The dummy first section is handled here
3030 too. The link/info pointers for the standard section types are filled
3031 in here too, while we're at it. */
3034 assign_section_numbers (bfd
*abfd
, struct bfd_link_info
*link_info
)
3036 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
3038 unsigned int section_number
, secn
;
3039 Elf_Internal_Shdr
**i_shdrp
;
3040 struct bfd_elf_section_data
*d
;
3044 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd
));
3046 /* SHT_GROUP sections are in relocatable files only. */
3047 if (link_info
== NULL
|| link_info
->relocatable
)
3049 /* Put SHT_GROUP sections first. */
3050 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3052 d
= elf_section_data (sec
);
3054 if (d
->this_hdr
.sh_type
== SHT_GROUP
)
3056 if (sec
->flags
& SEC_LINKER_CREATED
)
3058 /* Remove the linker created SHT_GROUP sections. */
3059 bfd_section_list_remove (abfd
, sec
);
3060 abfd
->section_count
--;
3064 if (section_number
== SHN_LORESERVE
)
3065 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3066 d
->this_idx
= section_number
++;
3072 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3074 d
= elf_section_data (sec
);
3076 if (d
->this_hdr
.sh_type
!= SHT_GROUP
)
3078 if (section_number
== SHN_LORESERVE
)
3079 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3080 d
->this_idx
= section_number
++;
3082 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->this_hdr
.sh_name
);
3083 if ((sec
->flags
& SEC_RELOC
) == 0)
3087 if (section_number
== SHN_LORESERVE
)
3088 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3089 d
->rel_idx
= section_number
++;
3090 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr
.sh_name
);
3095 if (section_number
== SHN_LORESERVE
)
3096 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3097 d
->rel_idx2
= section_number
++;
3098 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), d
->rel_hdr2
->sh_name
);
3104 if (section_number
== SHN_LORESERVE
)
3105 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3106 t
->shstrtab_section
= section_number
++;
3107 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->shstrtab_hdr
.sh_name
);
3108 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
3110 if (bfd_get_symcount (abfd
) > 0)
3112 if (section_number
== SHN_LORESERVE
)
3113 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3114 t
->symtab_section
= section_number
++;
3115 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->symtab_hdr
.sh_name
);
3116 if (section_number
> SHN_LORESERVE
- 2)
3118 if (section_number
== SHN_LORESERVE
)
3119 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3120 t
->symtab_shndx_section
= section_number
++;
3121 t
->symtab_shndx_hdr
.sh_name
3122 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd
),
3123 ".symtab_shndx", FALSE
);
3124 if (t
->symtab_shndx_hdr
.sh_name
== (unsigned int) -1)
3127 if (section_number
== SHN_LORESERVE
)
3128 section_number
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3129 t
->strtab_section
= section_number
++;
3130 _bfd_elf_strtab_addref (elf_shstrtab (abfd
), t
->strtab_hdr
.sh_name
);
3133 _bfd_elf_strtab_finalize (elf_shstrtab (abfd
));
3134 t
->shstrtab_hdr
.sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3136 elf_numsections (abfd
) = section_number
;
3137 elf_elfheader (abfd
)->e_shnum
= section_number
;
3138 if (section_number
> SHN_LORESERVE
)
3139 elf_elfheader (abfd
)->e_shnum
-= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
3141 /* Set up the list of section header pointers, in agreement with the
3143 i_shdrp
= bfd_zalloc2 (abfd
, section_number
, sizeof (Elf_Internal_Shdr
*));
3144 if (i_shdrp
== NULL
)
3147 i_shdrp
[0] = bfd_zalloc (abfd
, sizeof (Elf_Internal_Shdr
));
3148 if (i_shdrp
[0] == NULL
)
3150 bfd_release (abfd
, i_shdrp
);
3154 elf_elfsections (abfd
) = i_shdrp
;
3156 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
3157 if (bfd_get_symcount (abfd
) > 0)
3159 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
3160 if (elf_numsections (abfd
) > SHN_LORESERVE
)
3162 i_shdrp
[t
->symtab_shndx_section
] = &t
->symtab_shndx_hdr
;
3163 t
->symtab_shndx_hdr
.sh_link
= t
->symtab_section
;
3165 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
3166 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
3169 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
3171 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
3175 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
3176 if (d
->rel_idx
!= 0)
3177 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
3178 if (d
->rel_idx2
!= 0)
3179 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
3181 /* Fill in the sh_link and sh_info fields while we're at it. */
3183 /* sh_link of a reloc section is the section index of the symbol
3184 table. sh_info is the section index of the section to which
3185 the relocation entries apply. */
3186 if (d
->rel_idx
!= 0)
3188 d
->rel_hdr
.sh_link
= t
->symtab_section
;
3189 d
->rel_hdr
.sh_info
= d
->this_idx
;
3191 if (d
->rel_idx2
!= 0)
3193 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
3194 d
->rel_hdr2
->sh_info
= d
->this_idx
;
3197 /* We need to set up sh_link for SHF_LINK_ORDER. */
3198 if ((d
->this_hdr
.sh_flags
& SHF_LINK_ORDER
) != 0)
3200 s
= elf_linked_to_section (sec
);
3203 /* elf_linked_to_section points to the input section. */
3204 if (link_info
!= NULL
)
3206 /* Check discarded linkonce section. */
3207 if (elf_discarded_section (s
))
3210 (*_bfd_error_handler
)
3211 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3212 abfd
, d
->this_hdr
.bfd_section
,
3214 /* Point to the kept section if it has the same
3215 size as the discarded one. */
3216 kept
= _bfd_elf_check_kept_section (s
, link_info
);
3219 bfd_set_error (bfd_error_bad_value
);
3225 s
= s
->output_section
;
3226 BFD_ASSERT (s
!= NULL
);
3230 /* Handle objcopy. */
3231 if (s
->output_section
== NULL
)
3233 (*_bfd_error_handler
)
3234 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3235 abfd
, d
->this_hdr
.bfd_section
, s
, s
->owner
);
3236 bfd_set_error (bfd_error_bad_value
);
3239 s
= s
->output_section
;
3241 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3246 The Intel C compiler generates SHT_IA_64_UNWIND with
3247 SHF_LINK_ORDER. But it doesn't set the sh_link or
3248 sh_info fields. Hence we could get the situation
3250 const struct elf_backend_data
*bed
3251 = get_elf_backend_data (abfd
);
3252 if (bed
->link_order_error_handler
)
3253 bed
->link_order_error_handler
3254 (_("%B: warning: sh_link not set for section `%A'"),
3259 switch (d
->this_hdr
.sh_type
)
3263 /* A reloc section which we are treating as a normal BFD
3264 section. sh_link is the section index of the symbol
3265 table. sh_info is the section index of the section to
3266 which the relocation entries apply. We assume that an
3267 allocated reloc section uses the dynamic symbol table.
3268 FIXME: How can we be sure? */
3269 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3271 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3273 /* We look up the section the relocs apply to by name. */
3275 if (d
->this_hdr
.sh_type
== SHT_REL
)
3279 s
= bfd_get_section_by_name (abfd
, name
);
3281 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
3285 /* We assume that a section named .stab*str is a stabs
3286 string section. We look for a section with the same name
3287 but without the trailing ``str'', and set its sh_link
3288 field to point to this section. */
3289 if (CONST_STRNEQ (sec
->name
, ".stab")
3290 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
3295 len
= strlen (sec
->name
);
3296 alc
= bfd_malloc (len
- 2);
3299 memcpy (alc
, sec
->name
, len
- 3);
3300 alc
[len
- 3] = '\0';
3301 s
= bfd_get_section_by_name (abfd
, alc
);
3305 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
3307 /* This is a .stab section. */
3308 if (elf_section_data (s
)->this_hdr
.sh_entsize
== 0)
3309 elf_section_data (s
)->this_hdr
.sh_entsize
3310 = 4 + 2 * bfd_get_arch_size (abfd
) / 8;
3317 case SHT_GNU_verneed
:
3318 case SHT_GNU_verdef
:
3319 /* sh_link is the section header index of the string table
3320 used for the dynamic entries, or the symbol table, or the
3322 s
= bfd_get_section_by_name (abfd
, ".dynstr");
3324 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3327 case SHT_GNU_LIBLIST
:
3328 /* sh_link is the section header index of the prelink library
3329 list used for the dynamic entries, or the symbol table, or
3330 the version strings. */
3331 s
= bfd_get_section_by_name (abfd
, (sec
->flags
& SEC_ALLOC
)
3332 ? ".dynstr" : ".gnu.libstr");
3334 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3339 case SHT_GNU_versym
:
3340 /* sh_link is the section header index of the symbol table
3341 this hash table or version table is for. */
3342 s
= bfd_get_section_by_name (abfd
, ".dynsym");
3344 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
3348 d
->this_hdr
.sh_link
= t
->symtab_section
;
3352 for (secn
= 1; secn
< section_number
; ++secn
)
3353 if (i_shdrp
[secn
] == NULL
)
3354 i_shdrp
[secn
] = i_shdrp
[0];
3356 i_shdrp
[secn
]->sh_name
= _bfd_elf_strtab_offset (elf_shstrtab (abfd
),
3357 i_shdrp
[secn
]->sh_name
);
3361 /* Map symbol from it's internal number to the external number, moving
3362 all local symbols to be at the head of the list. */
3365 sym_is_global (bfd
*abfd
, asymbol
*sym
)
3367 /* If the backend has a special mapping, use it. */
3368 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3369 if (bed
->elf_backend_sym_is_global
)
3370 return (*bed
->elf_backend_sym_is_global
) (abfd
, sym
);
3372 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
3373 || bfd_is_und_section (bfd_get_section (sym
))
3374 || bfd_is_com_section (bfd_get_section (sym
)));
3377 /* Don't output section symbols for sections that are not going to be
3378 output. Also, don't output section symbols for reloc and other
3379 special sections. */
3382 ignore_section_sym (bfd
*abfd
, asymbol
*sym
)
3384 return ((sym
->flags
& BSF_SECTION_SYM
) != 0
3386 || (sym
->section
->owner
!= abfd
3387 && (sym
->section
->output_section
->owner
!= abfd
3388 || sym
->section
->output_offset
!= 0))));
3392 elf_map_symbols (bfd
*abfd
)
3394 unsigned int symcount
= bfd_get_symcount (abfd
);
3395 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3396 asymbol
**sect_syms
;
3397 unsigned int num_locals
= 0;
3398 unsigned int num_globals
= 0;
3399 unsigned int num_locals2
= 0;
3400 unsigned int num_globals2
= 0;
3407 fprintf (stderr
, "elf_map_symbols\n");
3411 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3413 if (max_index
< asect
->index
)
3414 max_index
= asect
->index
;
3418 sect_syms
= bfd_zalloc2 (abfd
, max_index
, sizeof (asymbol
*));
3419 if (sect_syms
== NULL
)
3421 elf_section_syms (abfd
) = sect_syms
;
3422 elf_num_section_syms (abfd
) = max_index
;
3424 /* Init sect_syms entries for any section symbols we have already
3425 decided to output. */
3426 for (idx
= 0; idx
< symcount
; idx
++)
3428 asymbol
*sym
= syms
[idx
];
3430 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
3431 && !ignore_section_sym (abfd
, sym
))
3433 asection
*sec
= sym
->section
;
3435 if (sec
->owner
!= abfd
)
3436 sec
= sec
->output_section
;
3438 sect_syms
[sec
->index
] = syms
[idx
];
3442 /* Classify all of the symbols. */
3443 for (idx
= 0; idx
< symcount
; idx
++)
3445 if (ignore_section_sym (abfd
, syms
[idx
]))
3447 if (!sym_is_global (abfd
, syms
[idx
]))
3453 /* We will be adding a section symbol for each normal BFD section. Most
3454 sections will already have a section symbol in outsymbols, but
3455 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3456 at least in that case. */
3457 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3459 if (sect_syms
[asect
->index
] == NULL
)
3461 if (!sym_is_global (abfd
, asect
->symbol
))
3468 /* Now sort the symbols so the local symbols are first. */
3469 new_syms
= bfd_alloc2 (abfd
, num_locals
+ num_globals
, sizeof (asymbol
*));
3471 if (new_syms
== NULL
)
3474 for (idx
= 0; idx
< symcount
; idx
++)
3476 asymbol
*sym
= syms
[idx
];
3479 if (ignore_section_sym (abfd
, sym
))
3481 if (!sym_is_global (abfd
, sym
))
3484 i
= num_locals
+ num_globals2
++;
3486 sym
->udata
.i
= i
+ 1;
3488 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
3490 if (sect_syms
[asect
->index
] == NULL
)
3492 asymbol
*sym
= asect
->symbol
;
3495 sect_syms
[asect
->index
] = sym
;
3496 if (!sym_is_global (abfd
, sym
))
3499 i
= num_locals
+ num_globals2
++;
3501 sym
->udata
.i
= i
+ 1;
3505 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
3507 elf_num_locals (abfd
) = num_locals
;
3508 elf_num_globals (abfd
) = num_globals
;
3512 /* Align to the maximum file alignment that could be required for any
3513 ELF data structure. */
3515 static inline file_ptr
3516 align_file_position (file_ptr off
, int align
)
3518 return (off
+ align
- 1) & ~(align
- 1);
3521 /* Assign a file position to a section, optionally aligning to the
3522 required section alignment. */
3525 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr
*i_shdrp
,
3533 al
= i_shdrp
->sh_addralign
;
3535 offset
= BFD_ALIGN (offset
, al
);
3537 i_shdrp
->sh_offset
= offset
;
3538 if (i_shdrp
->bfd_section
!= NULL
)
3539 i_shdrp
->bfd_section
->filepos
= offset
;
3540 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
3541 offset
+= i_shdrp
->sh_size
;
3545 /* Compute the file positions we are going to put the sections at, and
3546 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3547 is not NULL, this is being called by the ELF backend linker. */
3550 _bfd_elf_compute_section_file_positions (bfd
*abfd
,
3551 struct bfd_link_info
*link_info
)
3553 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3555 struct bfd_strtab_hash
*strtab
= NULL
;
3556 Elf_Internal_Shdr
*shstrtab_hdr
;
3558 if (abfd
->output_has_begun
)
3561 /* Do any elf backend specific processing first. */
3562 if (bed
->elf_backend_begin_write_processing
)
3563 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
3565 if (! prep_headers (abfd
))
3568 /* Post process the headers if necessary. */
3569 if (bed
->elf_backend_post_process_headers
)
3570 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
3573 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
3577 if (!assign_section_numbers (abfd
, link_info
))
3580 /* The backend linker builds symbol table information itself. */
3581 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3583 /* Non-zero if doing a relocatable link. */
3584 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
3586 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
3590 if (link_info
== NULL
)
3592 bfd_map_over_sections (abfd
, bfd_elf_set_group_contents
, &failed
);
3597 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
3598 /* sh_name was set in prep_headers. */
3599 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
3600 shstrtab_hdr
->sh_flags
= 0;
3601 shstrtab_hdr
->sh_addr
= 0;
3602 shstrtab_hdr
->sh_size
= _bfd_elf_strtab_size (elf_shstrtab (abfd
));
3603 shstrtab_hdr
->sh_entsize
= 0;
3604 shstrtab_hdr
->sh_link
= 0;
3605 shstrtab_hdr
->sh_info
= 0;
3606 /* sh_offset is set in assign_file_positions_except_relocs. */
3607 shstrtab_hdr
->sh_addralign
= 1;
3609 if (!assign_file_positions_except_relocs (abfd
, link_info
))
3612 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
3615 Elf_Internal_Shdr
*hdr
;
3617 off
= elf_tdata (abfd
)->next_file_pos
;
3619 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3620 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3622 hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
3623 if (hdr
->sh_size
!= 0)
3624 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3626 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3627 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
3629 elf_tdata (abfd
)->next_file_pos
= off
;
3631 /* Now that we know where the .strtab section goes, write it
3633 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
3634 || ! _bfd_stringtab_emit (abfd
, strtab
))
3636 _bfd_stringtab_free (strtab
);
3639 abfd
->output_has_begun
= TRUE
;
3644 /* Make an initial estimate of the size of the program header. If we
3645 get the number wrong here, we'll redo section placement. */
3647 static bfd_size_type
3648 get_program_header_size (bfd
*abfd
, struct bfd_link_info
*info
)
3652 const struct elf_backend_data
*bed
;
3654 /* Assume we will need exactly two PT_LOAD segments: one for text
3655 and one for data. */
3658 s
= bfd_get_section_by_name (abfd
, ".interp");
3659 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3661 /* If we have a loadable interpreter section, we need a
3662 PT_INTERP segment. In this case, assume we also need a
3663 PT_PHDR segment, although that may not be true for all
3668 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
3670 /* We need a PT_DYNAMIC segment. */
3673 if (elf_tdata (abfd
)->relro
)
3675 /* We need a PT_GNU_RELRO segment only when there is a
3676 PT_DYNAMIC segment. */
3681 if (elf_tdata (abfd
)->eh_frame_hdr
)
3683 /* We need a PT_GNU_EH_FRAME segment. */
3687 if (elf_tdata (abfd
)->stack_flags
)
3689 /* We need a PT_GNU_STACK segment. */
3693 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3695 if ((s
->flags
& SEC_LOAD
) != 0
3696 && CONST_STRNEQ (s
->name
, ".note"))
3698 /* We need a PT_NOTE segment. */
3703 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3705 if (s
->flags
& SEC_THREAD_LOCAL
)
3707 /* We need a PT_TLS segment. */
3713 /* Let the backend count up any program headers it might need. */
3714 bed
= get_elf_backend_data (abfd
);
3715 if (bed
->elf_backend_additional_program_headers
)
3719 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
, info
);
3725 return segs
* bed
->s
->sizeof_phdr
;
3728 /* Create a mapping from a set of sections to a program segment. */
3730 static struct elf_segment_map
*
3731 make_mapping (bfd
*abfd
,
3732 asection
**sections
,
3737 struct elf_segment_map
*m
;
3742 amt
= sizeof (struct elf_segment_map
);
3743 amt
+= (to
- from
- 1) * sizeof (asection
*);
3744 m
= bfd_zalloc (abfd
, amt
);
3748 m
->p_type
= PT_LOAD
;
3749 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
3750 m
->sections
[i
- from
] = *hdrpp
;
3751 m
->count
= to
- from
;
3753 if (from
== 0 && phdr
)
3755 /* Include the headers in the first PT_LOAD segment. */
3756 m
->includes_filehdr
= 1;
3757 m
->includes_phdrs
= 1;
3763 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3766 struct elf_segment_map
*
3767 _bfd_elf_make_dynamic_segment (bfd
*abfd
, asection
*dynsec
)
3769 struct elf_segment_map
*m
;
3771 m
= bfd_zalloc (abfd
, sizeof (struct elf_segment_map
));
3775 m
->p_type
= PT_DYNAMIC
;
3777 m
->sections
[0] = dynsec
;
3782 /* Possibly add or remove segments from the segment map. */
3785 elf_modify_segment_map (bfd
*abfd
, struct bfd_link_info
*info
)
3787 struct elf_segment_map
**m
;
3788 const struct elf_backend_data
*bed
;
3790 /* The placement algorithm assumes that non allocated sections are
3791 not in PT_LOAD segments. We ensure this here by removing such
3792 sections from the segment map. We also remove excluded
3793 sections. Finally, any PT_LOAD segment without sections is
3795 m
= &elf_tdata (abfd
)->segment_map
;
3798 unsigned int i
, new_count
;
3800 for (new_count
= 0, i
= 0; i
< (*m
)->count
; i
++)
3802 if (((*m
)->sections
[i
]->flags
& SEC_EXCLUDE
) == 0
3803 && (((*m
)->sections
[i
]->flags
& SEC_ALLOC
) != 0
3804 || (*m
)->p_type
!= PT_LOAD
))
3806 (*m
)->sections
[new_count
] = (*m
)->sections
[i
];
3810 (*m
)->count
= new_count
;
3812 if ((*m
)->p_type
== PT_LOAD
&& (*m
)->count
== 0)
3818 bed
= get_elf_backend_data (abfd
);
3819 if (bed
->elf_backend_modify_segment_map
!= NULL
)
3821 if (!(*bed
->elf_backend_modify_segment_map
) (abfd
, info
))
3828 /* Set up a mapping from BFD sections to program segments. */
3831 _bfd_elf_map_sections_to_segments (bfd
*abfd
, struct bfd_link_info
*info
)
3834 struct elf_segment_map
*m
;
3835 asection
**sections
= NULL
;
3836 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3838 if (elf_tdata (abfd
)->segment_map
== NULL
3839 && bfd_count_sections (abfd
) != 0)
3843 struct elf_segment_map
*mfirst
;
3844 struct elf_segment_map
**pm
;
3847 unsigned int phdr_index
;
3848 bfd_vma maxpagesize
;
3850 bfd_boolean phdr_in_segment
= TRUE
;
3851 bfd_boolean writable
;
3853 asection
*first_tls
= NULL
;
3854 asection
*dynsec
, *eh_frame_hdr
;
3857 /* Select the allocated sections, and sort them. */
3859 sections
= bfd_malloc2 (bfd_count_sections (abfd
), sizeof (asection
*));
3860 if (sections
== NULL
)
3864 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
3866 if ((s
->flags
& SEC_ALLOC
) != 0)
3872 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
3875 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
3877 /* Build the mapping. */
3882 /* If we have a .interp section, then create a PT_PHDR segment for
3883 the program headers and a PT_INTERP segment for the .interp
3885 s
= bfd_get_section_by_name (abfd
, ".interp");
3886 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
3888 amt
= sizeof (struct elf_segment_map
);
3889 m
= bfd_zalloc (abfd
, amt
);
3893 m
->p_type
= PT_PHDR
;
3894 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3895 m
->p_flags
= PF_R
| PF_X
;
3896 m
->p_flags_valid
= 1;
3897 m
->includes_phdrs
= 1;
3902 amt
= sizeof (struct elf_segment_map
);
3903 m
= bfd_zalloc (abfd
, amt
);
3907 m
->p_type
= PT_INTERP
;
3915 /* Look through the sections. We put sections in the same program
3916 segment when the start of the second section can be placed within
3917 a few bytes of the end of the first section. */
3921 maxpagesize
= bed
->maxpagesize
;
3923 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
3925 && (dynsec
->flags
& SEC_LOAD
) == 0)
3928 /* Deal with -Ttext or something similar such that the first section
3929 is not adjacent to the program headers. This is an
3930 approximation, since at this point we don't know exactly how many
3931 program headers we will need. */
3934 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
3936 if (phdr_size
== (bfd_size_type
) -1)
3937 phdr_size
= get_program_header_size (abfd
, info
);
3938 if ((abfd
->flags
& D_PAGED
) == 0
3939 || sections
[0]->lma
< phdr_size
3940 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
3941 phdr_in_segment
= FALSE
;
3944 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
3947 bfd_boolean new_segment
;
3951 /* See if this section and the last one will fit in the same
3954 if (last_hdr
== NULL
)
3956 /* If we don't have a segment yet, then we don't need a new
3957 one (we build the last one after this loop). */
3958 new_segment
= FALSE
;
3960 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
3962 /* If this section has a different relation between the
3963 virtual address and the load address, then we need a new
3967 else if (BFD_ALIGN (last_hdr
->lma
+ last_size
, maxpagesize
)
3968 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
3970 /* If putting this section in this segment would force us to
3971 skip a page in the segment, then we need a new segment. */
3974 else if ((last_hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) == 0
3975 && (hdr
->flags
& (SEC_LOAD
| SEC_THREAD_LOCAL
)) != 0)
3977 /* We don't want to put a loadable section after a
3978 nonloadable section in the same segment.
3979 Consider .tbss sections as loadable for this purpose. */
3982 else if ((abfd
->flags
& D_PAGED
) == 0)
3984 /* If the file is not demand paged, which means that we
3985 don't require the sections to be correctly aligned in the
3986 file, then there is no other reason for a new segment. */
3987 new_segment
= FALSE
;
3990 && (hdr
->flags
& SEC_READONLY
) == 0
3991 && (((last_hdr
->lma
+ last_size
- 1)
3992 & ~(maxpagesize
- 1))
3993 != (hdr
->lma
& ~(maxpagesize
- 1))))
3995 /* We don't want to put a writable section in a read only
3996 segment, unless they are on the same page in memory
3997 anyhow. We already know that the last section does not
3998 bring us past the current section on the page, so the
3999 only case in which the new section is not on the same
4000 page as the previous section is when the previous section
4001 ends precisely on a page boundary. */
4006 /* Otherwise, we can use the same segment. */
4007 new_segment
= FALSE
;
4010 /* Allow interested parties a chance to override our decision. */
4011 if (last_hdr
&& info
->callbacks
->override_segment_assignment
)
4012 new_segment
= info
->callbacks
->override_segment_assignment (info
, abfd
, hdr
, last_hdr
, new_segment
);
4016 if ((hdr
->flags
& SEC_READONLY
) == 0)
4019 /* .tbss sections effectively have zero size. */
4020 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
))
4021 != SEC_THREAD_LOCAL
)
4022 last_size
= hdr
->size
;
4028 /* We need a new program segment. We must create a new program
4029 header holding all the sections from phdr_index until hdr. */
4031 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4038 if ((hdr
->flags
& SEC_READONLY
) == 0)
4044 /* .tbss sections effectively have zero size. */
4045 if ((hdr
->flags
& (SEC_THREAD_LOCAL
| SEC_LOAD
)) != SEC_THREAD_LOCAL
)
4046 last_size
= hdr
->size
;
4050 phdr_in_segment
= FALSE
;
4053 /* Create a final PT_LOAD program segment. */
4054 if (last_hdr
!= NULL
)
4056 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
4064 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4067 m
= _bfd_elf_make_dynamic_segment (abfd
, dynsec
);
4074 /* For each loadable .note section, add a PT_NOTE segment. We don't
4075 use bfd_get_section_by_name, because if we link together
4076 nonloadable .note sections and loadable .note sections, we will
4077 generate two .note sections in the output file. FIXME: Using
4078 names for section types is bogus anyhow. */
4079 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4081 if ((s
->flags
& SEC_LOAD
) != 0
4082 && CONST_STRNEQ (s
->name
, ".note"))
4084 amt
= sizeof (struct elf_segment_map
);
4085 m
= bfd_zalloc (abfd
, amt
);
4089 m
->p_type
= PT_NOTE
;
4096 if (s
->flags
& SEC_THREAD_LOCAL
)
4104 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4109 amt
= sizeof (struct elf_segment_map
);
4110 amt
+= (tls_count
- 1) * sizeof (asection
*);
4111 m
= bfd_zalloc (abfd
, amt
);
4116 m
->count
= tls_count
;
4117 /* Mandated PF_R. */
4119 m
->p_flags_valid
= 1;
4120 for (i
= 0; i
< tls_count
; ++i
)
4122 BFD_ASSERT (first_tls
->flags
& SEC_THREAD_LOCAL
);
4123 m
->sections
[i
] = first_tls
;
4124 first_tls
= first_tls
->next
;
4131 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4133 eh_frame_hdr
= elf_tdata (abfd
)->eh_frame_hdr
;
4134 if (eh_frame_hdr
!= NULL
4135 && (eh_frame_hdr
->output_section
->flags
& SEC_LOAD
) != 0)
4137 amt
= sizeof (struct elf_segment_map
);
4138 m
= bfd_zalloc (abfd
, amt
);
4142 m
->p_type
= PT_GNU_EH_FRAME
;
4144 m
->sections
[0] = eh_frame_hdr
->output_section
;
4150 if (elf_tdata (abfd
)->stack_flags
)
4152 amt
= sizeof (struct elf_segment_map
);
4153 m
= bfd_zalloc (abfd
, amt
);
4157 m
->p_type
= PT_GNU_STACK
;
4158 m
->p_flags
= elf_tdata (abfd
)->stack_flags
;
4159 m
->p_flags_valid
= 1;
4165 if (dynsec
!= NULL
&& elf_tdata (abfd
)->relro
)
4167 /* We make a PT_GNU_RELRO segment only when there is a
4168 PT_DYNAMIC segment. */
4169 amt
= sizeof (struct elf_segment_map
);
4170 m
= bfd_zalloc (abfd
, amt
);
4174 m
->p_type
= PT_GNU_RELRO
;
4176 m
->p_flags_valid
= 1;
4183 elf_tdata (abfd
)->segment_map
= mfirst
;
4186 if (!elf_modify_segment_map (abfd
, info
))
4189 for (count
= 0, m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4191 elf_tdata (abfd
)->program_header_size
= count
* bed
->s
->sizeof_phdr
;
4196 if (sections
!= NULL
)
4201 /* Sort sections by address. */
4204 elf_sort_sections (const void *arg1
, const void *arg2
)
4206 const asection
*sec1
= *(const asection
**) arg1
;
4207 const asection
*sec2
= *(const asection
**) arg2
;
4208 bfd_size_type size1
, size2
;
4210 /* Sort by LMA first, since this is the address used to
4211 place the section into a segment. */
4212 if (sec1
->lma
< sec2
->lma
)
4214 else if (sec1
->lma
> sec2
->lma
)
4217 /* Then sort by VMA. Normally the LMA and the VMA will be
4218 the same, and this will do nothing. */
4219 if (sec1
->vma
< sec2
->vma
)
4221 else if (sec1
->vma
> sec2
->vma
)
4224 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4226 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4232 /* If the indicies are the same, do not return 0
4233 here, but continue to try the next comparison. */
4234 if (sec1
->target_index
- sec2
->target_index
!= 0)
4235 return sec1
->target_index
- sec2
->target_index
;
4240 else if (TOEND (sec2
))
4245 /* Sort by size, to put zero sized sections
4246 before others at the same address. */
4248 size1
= (sec1
->flags
& SEC_LOAD
) ? sec1
->size
: 0;
4249 size2
= (sec2
->flags
& SEC_LOAD
) ? sec2
->size
: 0;
4256 return sec1
->target_index
- sec2
->target_index
;
4259 /* Ian Lance Taylor writes:
4261 We shouldn't be using % with a negative signed number. That's just
4262 not good. We have to make sure either that the number is not
4263 negative, or that the number has an unsigned type. When the types
4264 are all the same size they wind up as unsigned. When file_ptr is a
4265 larger signed type, the arithmetic winds up as signed long long,
4268 What we're trying to say here is something like ``increase OFF by
4269 the least amount that will cause it to be equal to the VMA modulo
4271 /* In other words, something like:
4273 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4274 off_offset = off % bed->maxpagesize;
4275 if (vma_offset < off_offset)
4276 adjustment = vma_offset + bed->maxpagesize - off_offset;
4278 adjustment = vma_offset - off_offset;
4280 which can can be collapsed into the expression below. */
4283 vma_page_aligned_bias (bfd_vma vma
, ufile_ptr off
, bfd_vma maxpagesize
)
4285 return ((vma
- off
) % maxpagesize
);
4288 /* Assign file positions to the sections based on the mapping from
4289 sections to segments. This function also sets up some fields in
4293 assign_file_positions_for_load_sections (bfd
*abfd
,
4294 struct bfd_link_info
*link_info
)
4296 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4297 struct elf_segment_map
*m
;
4298 Elf_Internal_Phdr
*phdrs
;
4299 Elf_Internal_Phdr
*p
;
4301 bfd_size_type maxpagesize
;
4305 if (link_info
== NULL
4306 && !elf_modify_segment_map (abfd
, link_info
))
4310 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
4313 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
4314 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
4315 elf_elfheader (abfd
)->e_phnum
= alloc
;
4317 if (elf_tdata (abfd
)->program_header_size
== (bfd_size_type
) -1)
4318 elf_tdata (abfd
)->program_header_size
= alloc
* bed
->s
->sizeof_phdr
;
4320 BFD_ASSERT (elf_tdata (abfd
)->program_header_size
4321 >= alloc
* bed
->s
->sizeof_phdr
);
4325 elf_tdata (abfd
)->next_file_pos
= bed
->s
->sizeof_ehdr
;
4329 phdrs
= bfd_alloc2 (abfd
, alloc
, sizeof (Elf_Internal_Phdr
));
4330 elf_tdata (abfd
)->phdr
= phdrs
;
4335 if ((abfd
->flags
& D_PAGED
) != 0)
4336 maxpagesize
= bed
->maxpagesize
;
4338 off
= bed
->s
->sizeof_ehdr
;
4339 off
+= alloc
* bed
->s
->sizeof_phdr
;
4341 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
, j
= 0;
4343 m
= m
->next
, p
++, j
++)
4347 bfd_boolean no_contents
;
4349 /* If elf_segment_map is not from map_sections_to_segments, the
4350 sections may not be correctly ordered. NOTE: sorting should
4351 not be done to the PT_NOTE section of a corefile, which may
4352 contain several pseudo-sections artificially created by bfd.
4353 Sorting these pseudo-sections breaks things badly. */
4355 && !(elf_elfheader (abfd
)->e_type
== ET_CORE
4356 && m
->p_type
== PT_NOTE
))
4357 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
4360 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4361 number of sections with contents contributing to both p_filesz
4362 and p_memsz, followed by a number of sections with no contents
4363 that just contribute to p_memsz. In this loop, OFF tracks next
4364 available file offset for PT_LOAD and PT_NOTE segments. */
4365 p
->p_type
= m
->p_type
;
4366 p
->p_flags
= m
->p_flags
;
4371 p
->p_vaddr
= m
->sections
[0]->vma
- m
->p_vaddr_offset
;
4373 if (m
->p_paddr_valid
)
4374 p
->p_paddr
= m
->p_paddr
;
4375 else if (m
->count
== 0)
4378 p
->p_paddr
= m
->sections
[0]->lma
- m
->p_vaddr_offset
;
4380 if (p
->p_type
== PT_LOAD
4381 && (abfd
->flags
& D_PAGED
) != 0)
4383 /* p_align in demand paged PT_LOAD segments effectively stores
4384 the maximum page size. When copying an executable with
4385 objcopy, we set m->p_align from the input file. Use this
4386 value for maxpagesize rather than bed->maxpagesize, which
4387 may be different. Note that we use maxpagesize for PT_TLS
4388 segment alignment later in this function, so we are relying
4389 on at least one PT_LOAD segment appearing before a PT_TLS
4391 if (m
->p_align_valid
)
4392 maxpagesize
= m
->p_align
;
4394 p
->p_align
= maxpagesize
;
4396 else if (m
->count
== 0)
4397 p
->p_align
= 1 << bed
->s
->log_file_align
;
4398 else if (m
->p_align_valid
)
4399 p
->p_align
= m
->p_align
;
4403 no_contents
= FALSE
;
4405 if (p
->p_type
== PT_LOAD
4408 bfd_size_type align
;
4409 unsigned int align_power
= 0;
4411 if (m
->p_align_valid
)
4415 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4417 unsigned int secalign
;
4419 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
4420 if (secalign
> align_power
)
4421 align_power
= secalign
;
4423 align
= (bfd_size_type
) 1 << align_power
;
4424 if (align
< maxpagesize
)
4425 align
= maxpagesize
;
4428 for (i
= 0; i
< m
->count
; i
++)
4429 if ((m
->sections
[i
]->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
4430 /* If we aren't making room for this section, then
4431 it must be SHT_NOBITS regardless of what we've
4432 set via struct bfd_elf_special_section. */
4433 elf_section_type (m
->sections
[i
]) = SHT_NOBITS
;
4435 /* Find out whether this segment contains any loadable
4436 sections. If the first section isn't loadable, the same
4437 holds for any other sections. */
4439 while (elf_section_type (m
->sections
[i
]) == SHT_NOBITS
)
4441 /* If a segment starts with .tbss, we need to look
4442 at the next section to decide whether the segment
4443 has any loadable sections. */
4444 if ((elf_section_flags (m
->sections
[i
]) & SHF_TLS
) == 0
4452 off_adjust
= vma_page_aligned_bias (m
->sections
[0]->vma
, off
, align
);
4456 /* We shouldn't need to align the segment on disk since
4457 the segment doesn't need file space, but the gABI
4458 arguably requires the alignment and glibc ld.so
4459 checks it. So to comply with the alignment
4460 requirement but not waste file space, we adjust
4461 p_offset for just this segment. (OFF_ADJUST is
4462 subtracted from OFF later.) This may put p_offset
4463 past the end of file, but that shouldn't matter. */
4468 /* Make sure the .dynamic section is the first section in the
4469 PT_DYNAMIC segment. */
4470 else if (p
->p_type
== PT_DYNAMIC
4472 && strcmp (m
->sections
[0]->name
, ".dynamic") != 0)
4475 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4477 bfd_set_error (bfd_error_bad_value
);
4485 if (m
->includes_filehdr
)
4487 if (!m
->p_flags_valid
)
4489 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
4490 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
4493 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4495 if (p
->p_vaddr
< (bfd_vma
) off
)
4497 (*_bfd_error_handler
)
4498 (_("%B: Not enough room for program headers, try linking with -N"),
4500 bfd_set_error (bfd_error_bad_value
);
4505 if (!m
->p_paddr_valid
)
4510 if (m
->includes_phdrs
)
4512 if (!m
->p_flags_valid
)
4515 if (!m
->includes_filehdr
)
4517 p
->p_offset
= bed
->s
->sizeof_ehdr
;
4521 BFD_ASSERT (p
->p_type
== PT_LOAD
);
4522 p
->p_vaddr
-= off
- p
->p_offset
;
4523 if (!m
->p_paddr_valid
)
4524 p
->p_paddr
-= off
- p
->p_offset
;
4528 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
4529 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
4532 if (p
->p_type
== PT_LOAD
4533 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
4535 if (!m
->includes_filehdr
&& !m
->includes_phdrs
)
4541 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
4543 p
->p_filesz
+= adjust
;
4544 p
->p_memsz
+= adjust
;
4548 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4549 maps. Set filepos for sections in PT_LOAD segments, and in
4550 core files, for sections in PT_NOTE segments.
4551 assign_file_positions_for_non_load_sections will set filepos
4552 for other sections and update p_filesz for other segments. */
4553 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4556 bfd_size_type align
;
4557 Elf_Internal_Shdr
*this_hdr
;
4560 this_hdr
= &elf_section_data (sec
)->this_hdr
;
4561 align
= (bfd_size_type
) 1 << bfd_get_section_alignment (abfd
, sec
);
4563 if (p
->p_type
== PT_LOAD
4564 || p
->p_type
== PT_TLS
)
4566 bfd_signed_vma adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
4568 if (this_hdr
->sh_type
!= SHT_NOBITS
4569 || ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0
4570 && ((this_hdr
->sh_flags
& SHF_TLS
) == 0
4571 || p
->p_type
== PT_TLS
)))
4575 (*_bfd_error_handler
)
4576 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4577 abfd
, sec
, (unsigned long) sec
->lma
);
4580 p
->p_memsz
+= adjust
;
4582 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4585 p
->p_filesz
+= adjust
;
4590 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
4592 /* The section at i == 0 is the one that actually contains
4596 this_hdr
->sh_offset
= sec
->filepos
= off
;
4597 off
+= this_hdr
->sh_size
;
4598 p
->p_filesz
= this_hdr
->sh_size
;
4604 /* The rest are fake sections that shouldn't be written. */
4613 if (p
->p_type
== PT_LOAD
)
4615 this_hdr
->sh_offset
= sec
->filepos
= off
;
4616 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4617 off
+= this_hdr
->sh_size
;
4620 if (this_hdr
->sh_type
!= SHT_NOBITS
)
4622 p
->p_filesz
+= this_hdr
->sh_size
;
4623 /* A load section without SHF_ALLOC is something like
4624 a note section in a PT_NOTE segment. These take
4625 file space but are not loaded into memory. */
4626 if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4627 p
->p_memsz
+= this_hdr
->sh_size
;
4629 else if ((this_hdr
->sh_flags
& SHF_ALLOC
) != 0)
4631 if (p
->p_type
== PT_TLS
)
4632 p
->p_memsz
+= this_hdr
->sh_size
;
4634 /* .tbss is special. It doesn't contribute to p_memsz of
4636 else if ((this_hdr
->sh_flags
& SHF_TLS
) == 0)
4637 p
->p_memsz
+= this_hdr
->sh_size
;
4640 if (p
->p_type
== PT_GNU_RELRO
)
4642 else if (align
> p
->p_align
4643 && !m
->p_align_valid
4644 && (p
->p_type
!= PT_LOAD
4645 || (abfd
->flags
& D_PAGED
) == 0))
4649 if (!m
->p_flags_valid
)
4652 if ((this_hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
4654 if ((this_hdr
->sh_flags
& SHF_WRITE
) != 0)
4660 /* Check that all sections are in a PT_LOAD segment.
4661 Don't check funky gdb generated core files. */
4662 if (p
->p_type
== PT_LOAD
&& bfd_get_format (abfd
) != bfd_core
)
4663 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
4665 Elf_Internal_Shdr
*this_hdr
;
4669 this_hdr
= &(elf_section_data(sec
)->this_hdr
);
4670 if (this_hdr
->sh_size
!= 0
4671 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, p
))
4673 (*_bfd_error_handler
)
4674 (_("%B: section `%A' can't be allocated in segment %d"),
4676 bfd_set_error (bfd_error_bad_value
);
4682 elf_tdata (abfd
)->next_file_pos
= off
;
4686 /* Assign file positions for the other sections. */
4689 assign_file_positions_for_non_load_sections (bfd
*abfd
,
4690 struct bfd_link_info
*link_info
)
4692 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4693 Elf_Internal_Shdr
**i_shdrpp
;
4694 Elf_Internal_Shdr
**hdrpp
;
4695 Elf_Internal_Phdr
*phdrs
;
4696 Elf_Internal_Phdr
*p
;
4697 struct elf_segment_map
*m
;
4698 bfd_vma filehdr_vaddr
, filehdr_paddr
;
4699 bfd_vma phdrs_vaddr
, phdrs_paddr
;
4701 unsigned int num_sec
;
4705 i_shdrpp
= elf_elfsections (abfd
);
4706 num_sec
= elf_numsections (abfd
);
4707 off
= elf_tdata (abfd
)->next_file_pos
;
4708 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4710 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4711 Elf_Internal_Shdr
*hdr
;
4714 if (hdr
->bfd_section
!= NULL
4715 && (hdr
->bfd_section
->filepos
!= 0
4716 || (hdr
->sh_type
== SHT_NOBITS
4717 && hdr
->contents
== NULL
)))
4718 BFD_ASSERT (hdr
->sh_offset
== hdr
->bfd_section
->filepos
);
4719 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
4721 if (hdr
->sh_size
!= 0)
4722 ((*_bfd_error_handler
)
4723 (_("%B: warning: allocated section `%s' not in segment"),
4725 (hdr
->bfd_section
== NULL
4727 : hdr
->bfd_section
->name
)));
4728 /* We don't need to page align empty sections. */
4729 if ((abfd
->flags
& D_PAGED
) != 0 && hdr
->sh_size
!= 0)
4730 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4733 off
+= vma_page_aligned_bias (hdr
->sh_addr
, off
,
4735 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
4738 else if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4739 && hdr
->bfd_section
== NULL
)
4740 || hdr
== i_shdrpp
[tdata
->symtab_section
]
4741 || hdr
== i_shdrpp
[tdata
->symtab_shndx_section
]
4742 || hdr
== i_shdrpp
[tdata
->strtab_section
])
4743 hdr
->sh_offset
= -1;
4745 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4747 if (i
== SHN_LORESERVE
- 1)
4749 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4750 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4754 /* Now that we have set the section file positions, we can set up
4755 the file positions for the non PT_LOAD segments. */
4759 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
4761 phdrs
= elf_tdata (abfd
)->phdr
;
4762 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4767 if (p
->p_type
!= PT_LOAD
)
4770 if (m
->includes_filehdr
)
4772 filehdr_vaddr
= p
->p_vaddr
;
4773 filehdr_paddr
= p
->p_paddr
;
4775 if (m
->includes_phdrs
)
4777 phdrs_vaddr
= p
->p_vaddr
;
4778 phdrs_paddr
= p
->p_paddr
;
4779 if (m
->includes_filehdr
)
4781 phdrs_vaddr
+= bed
->s
->sizeof_ehdr
;
4782 phdrs_paddr
+= bed
->s
->sizeof_ehdr
;
4787 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
4793 if (p
->p_type
!= PT_LOAD
4794 && (p
->p_type
!= PT_NOTE
|| bfd_get_format (abfd
) != bfd_core
))
4796 Elf_Internal_Shdr
*hdr
;
4797 BFD_ASSERT (!m
->includes_filehdr
&& !m
->includes_phdrs
);
4799 hdr
= &elf_section_data (m
->sections
[m
->count
- 1])->this_hdr
;
4800 p
->p_filesz
= (m
->sections
[m
->count
- 1]->filepos
4801 - m
->sections
[0]->filepos
);
4802 if (hdr
->sh_type
!= SHT_NOBITS
)
4803 p
->p_filesz
+= hdr
->sh_size
;
4805 p
->p_offset
= m
->sections
[0]->filepos
;
4810 if (m
->includes_filehdr
)
4812 p
->p_vaddr
= filehdr_vaddr
;
4813 if (! m
->p_paddr_valid
)
4814 p
->p_paddr
= filehdr_paddr
;
4816 else if (m
->includes_phdrs
)
4818 p
->p_vaddr
= phdrs_vaddr
;
4819 if (! m
->p_paddr_valid
)
4820 p
->p_paddr
= phdrs_paddr
;
4822 else if (p
->p_type
== PT_GNU_RELRO
)
4824 Elf_Internal_Phdr
*lp
;
4826 for (lp
= phdrs
; lp
< phdrs
+ count
; ++lp
)
4828 if (lp
->p_type
== PT_LOAD
4829 && lp
->p_vaddr
<= link_info
->relro_end
4830 && lp
->p_vaddr
>= link_info
->relro_start
4831 && (lp
->p_vaddr
+ lp
->p_filesz
4832 >= link_info
->relro_end
))
4836 if (lp
< phdrs
+ count
4837 && link_info
->relro_end
> lp
->p_vaddr
)
4839 p
->p_vaddr
= lp
->p_vaddr
;
4840 p
->p_paddr
= lp
->p_paddr
;
4841 p
->p_offset
= lp
->p_offset
;
4842 p
->p_filesz
= link_info
->relro_end
- lp
->p_vaddr
;
4843 p
->p_memsz
= p
->p_filesz
;
4845 p
->p_flags
= (lp
->p_flags
& ~PF_W
);
4849 memset (p
, 0, sizeof *p
);
4850 p
->p_type
= PT_NULL
;
4856 elf_tdata (abfd
)->next_file_pos
= off
;
4861 /* Work out the file positions of all the sections. This is called by
4862 _bfd_elf_compute_section_file_positions. All the section sizes and
4863 VMAs must be known before this is called.
4865 Reloc sections come in two flavours: Those processed specially as
4866 "side-channel" data attached to a section to which they apply, and
4867 those that bfd doesn't process as relocations. The latter sort are
4868 stored in a normal bfd section by bfd_section_from_shdr. We don't
4869 consider the former sort here, unless they form part of the loadable
4870 image. Reloc sections not assigned here will be handled later by
4871 assign_file_positions_for_relocs.
4873 We also don't set the positions of the .symtab and .strtab here. */
4876 assign_file_positions_except_relocs (bfd
*abfd
,
4877 struct bfd_link_info
*link_info
)
4879 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
4880 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4882 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4884 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
4885 && bfd_get_format (abfd
) != bfd_core
)
4887 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
4888 unsigned int num_sec
= elf_numsections (abfd
);
4889 Elf_Internal_Shdr
**hdrpp
;
4892 /* Start after the ELF header. */
4893 off
= i_ehdrp
->e_ehsize
;
4895 /* We are not creating an executable, which means that we are
4896 not creating a program header, and that the actual order of
4897 the sections in the file is unimportant. */
4898 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< num_sec
; i
++, hdrpp
++)
4900 Elf_Internal_Shdr
*hdr
;
4903 if (((hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
4904 && hdr
->bfd_section
== NULL
)
4905 || i
== tdata
->symtab_section
4906 || i
== tdata
->symtab_shndx_section
4907 || i
== tdata
->strtab_section
)
4909 hdr
->sh_offset
= -1;
4912 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, TRUE
);
4914 if (i
== SHN_LORESERVE
- 1)
4916 i
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4917 hdrpp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
4925 /* Assign file positions for the loaded sections based on the
4926 assignment of sections to segments. */
4927 if (!assign_file_positions_for_load_sections (abfd
, link_info
))
4930 /* And for non-load sections. */
4931 if (!assign_file_positions_for_non_load_sections (abfd
, link_info
))
4934 if (bed
->elf_backend_modify_program_headers
!= NULL
)
4936 if (!(*bed
->elf_backend_modify_program_headers
) (abfd
, link_info
))
4940 /* Write out the program headers. */
4941 alloc
= tdata
->program_header_size
/ bed
->s
->sizeof_phdr
;
4942 if (bfd_seek (abfd
, (bfd_signed_vma
) bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
4943 || bed
->s
->write_out_phdrs (abfd
, tdata
->phdr
, alloc
) != 0)
4946 off
= tdata
->next_file_pos
;
4949 /* Place the section headers. */
4950 off
= align_file_position (off
, 1 << bed
->s
->log_file_align
);
4951 i_ehdrp
->e_shoff
= off
;
4952 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
4954 tdata
->next_file_pos
= off
;
4960 prep_headers (bfd
*abfd
)
4962 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
4963 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
4964 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
4965 struct elf_strtab_hash
*shstrtab
;
4966 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4968 i_ehdrp
= elf_elfheader (abfd
);
4969 i_shdrp
= elf_elfsections (abfd
);
4971 shstrtab
= _bfd_elf_strtab_init ();
4972 if (shstrtab
== NULL
)
4975 elf_shstrtab (abfd
) = shstrtab
;
4977 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
4978 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
4979 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
4980 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
4982 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
4983 i_ehdrp
->e_ident
[EI_DATA
] =
4984 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
4985 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
4987 if ((abfd
->flags
& DYNAMIC
) != 0)
4988 i_ehdrp
->e_type
= ET_DYN
;
4989 else if ((abfd
->flags
& EXEC_P
) != 0)
4990 i_ehdrp
->e_type
= ET_EXEC
;
4991 else if (bfd_get_format (abfd
) == bfd_core
)
4992 i_ehdrp
->e_type
= ET_CORE
;
4994 i_ehdrp
->e_type
= ET_REL
;
4996 switch (bfd_get_arch (abfd
))
4998 case bfd_arch_unknown
:
4999 i_ehdrp
->e_machine
= EM_NONE
;
5002 /* There used to be a long list of cases here, each one setting
5003 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5004 in the corresponding bfd definition. To avoid duplication,
5005 the switch was removed. Machines that need special handling
5006 can generally do it in elf_backend_final_write_processing(),
5007 unless they need the information earlier than the final write.
5008 Such need can generally be supplied by replacing the tests for
5009 e_machine with the conditions used to determine it. */
5011 i_ehdrp
->e_machine
= bed
->elf_machine_code
;
5014 i_ehdrp
->e_version
= bed
->s
->ev_current
;
5015 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
5017 /* No program header, for now. */
5018 i_ehdrp
->e_phoff
= 0;
5019 i_ehdrp
->e_phentsize
= 0;
5020 i_ehdrp
->e_phnum
= 0;
5022 /* Each bfd section is section header entry. */
5023 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
5024 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
5026 /* If we're building an executable, we'll need a program header table. */
5027 if (abfd
->flags
& EXEC_P
)
5028 /* It all happens later. */
5032 i_ehdrp
->e_phentsize
= 0;
5034 i_ehdrp
->e_phoff
= 0;
5037 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
5038 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".symtab", FALSE
);
5039 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
5040 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".strtab", FALSE
);
5041 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
5042 (unsigned int) _bfd_elf_strtab_add (shstrtab
, ".shstrtab", FALSE
);
5043 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5044 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
5045 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
5051 /* Assign file positions for all the reloc sections which are not part
5052 of the loadable file image. */
5055 _bfd_elf_assign_file_positions_for_relocs (bfd
*abfd
)
5058 unsigned int i
, num_sec
;
5059 Elf_Internal_Shdr
**shdrpp
;
5061 off
= elf_tdata (abfd
)->next_file_pos
;
5063 num_sec
= elf_numsections (abfd
);
5064 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1; i
< num_sec
; i
++, shdrpp
++)
5066 Elf_Internal_Shdr
*shdrp
;
5069 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
5070 && shdrp
->sh_offset
== -1)
5071 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, TRUE
);
5074 elf_tdata (abfd
)->next_file_pos
= off
;
5078 _bfd_elf_write_object_contents (bfd
*abfd
)
5080 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
5081 Elf_Internal_Ehdr
*i_ehdrp
;
5082 Elf_Internal_Shdr
**i_shdrp
;
5084 unsigned int count
, num_sec
;
5086 if (! abfd
->output_has_begun
5087 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
5090 i_shdrp
= elf_elfsections (abfd
);
5091 i_ehdrp
= elf_elfheader (abfd
);
5094 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
5098 _bfd_elf_assign_file_positions_for_relocs (abfd
);
5100 /* After writing the headers, we need to write the sections too... */
5101 num_sec
= elf_numsections (abfd
);
5102 for (count
= 1; count
< num_sec
; count
++)
5104 if (bed
->elf_backend_section_processing
)
5105 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
5106 if (i_shdrp
[count
]->contents
)
5108 bfd_size_type amt
= i_shdrp
[count
]->sh_size
;
5110 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
5111 || bfd_bwrite (i_shdrp
[count
]->contents
, amt
, abfd
) != amt
)
5114 if (count
== SHN_LORESERVE
- 1)
5115 count
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
5118 /* Write out the section header names. */
5119 if (elf_shstrtab (abfd
) != NULL
5120 && (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
5121 || !_bfd_elf_strtab_emit (abfd
, elf_shstrtab (abfd
))))
5124 if (bed
->elf_backend_final_write_processing
)
5125 (*bed
->elf_backend_final_write_processing
) (abfd
,
5126 elf_tdata (abfd
)->linker
);
5128 if (!bed
->s
->write_shdrs_and_ehdr (abfd
))
5131 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5132 if (elf_tdata (abfd
)->after_write_object_contents
)
5133 return (*elf_tdata (abfd
)->after_write_object_contents
) (abfd
);
5139 _bfd_elf_write_corefile_contents (bfd
*abfd
)
5141 /* Hopefully this can be done just like an object file. */
5142 return _bfd_elf_write_object_contents (abfd
);
5145 /* Given a section, search the header to find them. */
5148 _bfd_elf_section_from_bfd_section (bfd
*abfd
, struct bfd_section
*asect
)
5150 const struct elf_backend_data
*bed
;
5153 if (elf_section_data (asect
) != NULL
5154 && elf_section_data (asect
)->this_idx
!= 0)
5155 return elf_section_data (asect
)->this_idx
;
5157 if (bfd_is_abs_section (asect
))
5159 else if (bfd_is_com_section (asect
))
5161 else if (bfd_is_und_section (asect
))
5166 bed
= get_elf_backend_data (abfd
);
5167 if (bed
->elf_backend_section_from_bfd_section
)
5171 if ((*bed
->elf_backend_section_from_bfd_section
) (abfd
, asect
, &retval
))
5176 bfd_set_error (bfd_error_nonrepresentable_section
);
5181 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5185 _bfd_elf_symbol_from_bfd_symbol (bfd
*abfd
, asymbol
**asym_ptr_ptr
)
5187 asymbol
*asym_ptr
= *asym_ptr_ptr
;
5189 flagword flags
= asym_ptr
->flags
;
5191 /* When gas creates relocations against local labels, it creates its
5192 own symbol for the section, but does put the symbol into the
5193 symbol chain, so udata is 0. When the linker is generating
5194 relocatable output, this section symbol may be for one of the
5195 input sections rather than the output section. */
5196 if (asym_ptr
->udata
.i
== 0
5197 && (flags
& BSF_SECTION_SYM
)
5198 && asym_ptr
->section
)
5203 sec
= asym_ptr
->section
;
5204 if (sec
->owner
!= abfd
&& sec
->output_section
!= NULL
)
5205 sec
= sec
->output_section
;
5206 if (sec
->owner
== abfd
5207 && (indx
= sec
->index
) < elf_num_section_syms (abfd
)
5208 && elf_section_syms (abfd
)[indx
] != NULL
)
5209 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
5212 idx
= asym_ptr
->udata
.i
;
5216 /* This case can occur when using --strip-symbol on a symbol
5217 which is used in a relocation entry. */
5218 (*_bfd_error_handler
)
5219 (_("%B: symbol `%s' required but not present"),
5220 abfd
, bfd_asymbol_name (asym_ptr
));
5221 bfd_set_error (bfd_error_no_symbols
);
5228 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5229 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
5230 elf_symbol_flags (flags
));
5238 /* Rewrite program header information. */
5241 rewrite_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5243 Elf_Internal_Ehdr
*iehdr
;
5244 struct elf_segment_map
*map
;
5245 struct elf_segment_map
*map_first
;
5246 struct elf_segment_map
**pointer_to_map
;
5247 Elf_Internal_Phdr
*segment
;
5250 unsigned int num_segments
;
5251 bfd_boolean phdr_included
= FALSE
;
5252 bfd_vma maxpagesize
;
5253 struct elf_segment_map
*phdr_adjust_seg
= NULL
;
5254 unsigned int phdr_adjust_num
= 0;
5255 const struct elf_backend_data
*bed
;
5257 bed
= get_elf_backend_data (ibfd
);
5258 iehdr
= elf_elfheader (ibfd
);
5261 pointer_to_map
= &map_first
;
5263 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5264 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
5266 /* Returns the end address of the segment + 1. */
5267 #define SEGMENT_END(segment, start) \
5268 (start + (segment->p_memsz > segment->p_filesz \
5269 ? segment->p_memsz : segment->p_filesz))
5271 #define SECTION_SIZE(section, segment) \
5272 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5273 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5274 ? section->size : 0)
5276 /* Returns TRUE if the given section is contained within
5277 the given segment. VMA addresses are compared. */
5278 #define IS_CONTAINED_BY_VMA(section, segment) \
5279 (section->vma >= segment->p_vaddr \
5280 && (section->vma + SECTION_SIZE (section, segment) \
5281 <= (SEGMENT_END (segment, segment->p_vaddr))))
5283 /* Returns TRUE if the given section is contained within
5284 the given segment. LMA addresses are compared. */
5285 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5286 (section->lma >= base \
5287 && (section->lma + SECTION_SIZE (section, segment) \
5288 <= SEGMENT_END (segment, base)))
5290 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5291 #define IS_COREFILE_NOTE(p, s) \
5292 (p->p_type == PT_NOTE \
5293 && bfd_get_format (ibfd) == bfd_core \
5294 && s->vma == 0 && s->lma == 0 \
5295 && (bfd_vma) s->filepos >= p->p_offset \
5296 && ((bfd_vma) s->filepos + s->size \
5297 <= p->p_offset + p->p_filesz))
5299 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5300 linker, which generates a PT_INTERP section with p_vaddr and
5301 p_memsz set to 0. */
5302 #define IS_SOLARIS_PT_INTERP(p, s) \
5304 && p->p_paddr == 0 \
5305 && p->p_memsz == 0 \
5306 && p->p_filesz > 0 \
5307 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5309 && (bfd_vma) s->filepos >= p->p_offset \
5310 && ((bfd_vma) s->filepos + s->size \
5311 <= p->p_offset + p->p_filesz))
5313 /* Decide if the given section should be included in the given segment.
5314 A section will be included if:
5315 1. It is within the address space of the segment -- we use the LMA
5316 if that is set for the segment and the VMA otherwise,
5317 2. It is an allocated segment,
5318 3. There is an output section associated with it,
5319 4. The section has not already been allocated to a previous segment.
5320 5. PT_GNU_STACK segments do not include any sections.
5321 6. PT_TLS segment includes only SHF_TLS sections.
5322 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5323 8. PT_DYNAMIC should not contain empty sections at the beginning
5324 (with the possible exception of .dynamic). */
5325 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5326 ((((segment->p_paddr \
5327 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5328 : IS_CONTAINED_BY_VMA (section, segment)) \
5329 && (section->flags & SEC_ALLOC) != 0) \
5330 || IS_COREFILE_NOTE (segment, section)) \
5331 && segment->p_type != PT_GNU_STACK \
5332 && (segment->p_type != PT_TLS \
5333 || (section->flags & SEC_THREAD_LOCAL)) \
5334 && (segment->p_type == PT_LOAD \
5335 || segment->p_type == PT_TLS \
5336 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5337 && (segment->p_type != PT_DYNAMIC \
5338 || SECTION_SIZE (section, segment) > 0 \
5339 || (segment->p_paddr \
5340 ? segment->p_paddr != section->lma \
5341 : segment->p_vaddr != section->vma) \
5342 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5344 && ! section->segment_mark)
5346 /* If the output section of a section in the input segment is NULL,
5347 it is removed from the corresponding output segment. */
5348 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5349 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5350 && section->output_section != NULL)
5352 /* Returns TRUE iff seg1 starts after the end of seg2. */
5353 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5354 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5356 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5357 their VMA address ranges and their LMA address ranges overlap.
5358 It is possible to have overlapping VMA ranges without overlapping LMA
5359 ranges. RedBoot images for example can have both .data and .bss mapped
5360 to the same VMA range, but with the .data section mapped to a different
5362 #define SEGMENT_OVERLAPS(seg1, seg2) \
5363 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5364 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5365 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5366 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5368 /* Initialise the segment mark field. */
5369 for (section
= ibfd
->sections
; section
!= NULL
; section
= section
->next
)
5370 section
->segment_mark
= FALSE
;
5372 /* Scan through the segments specified in the program header
5373 of the input BFD. For this first scan we look for overlaps
5374 in the loadable segments. These can be created by weird
5375 parameters to objcopy. Also, fix some solaris weirdness. */
5376 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5381 Elf_Internal_Phdr
*segment2
;
5383 if (segment
->p_type
== PT_INTERP
)
5384 for (section
= ibfd
->sections
; section
; section
= section
->next
)
5385 if (IS_SOLARIS_PT_INTERP (segment
, section
))
5387 /* Mininal change so that the normal section to segment
5388 assignment code will work. */
5389 segment
->p_vaddr
= section
->vma
;
5393 if (segment
->p_type
!= PT_LOAD
)
5396 /* Determine if this segment overlaps any previous segments. */
5397 for (j
= 0, segment2
= elf_tdata (ibfd
)->phdr
; j
< i
; j
++, segment2
++)
5399 bfd_signed_vma extra_length
;
5401 if (segment2
->p_type
!= PT_LOAD
5402 || ! SEGMENT_OVERLAPS (segment
, segment2
))
5405 /* Merge the two segments together. */
5406 if (segment2
->p_vaddr
< segment
->p_vaddr
)
5408 /* Extend SEGMENT2 to include SEGMENT and then delete
5411 SEGMENT_END (segment
, segment
->p_vaddr
)
5412 - SEGMENT_END (segment2
, segment2
->p_vaddr
);
5414 if (extra_length
> 0)
5416 segment2
->p_memsz
+= extra_length
;
5417 segment2
->p_filesz
+= extra_length
;
5420 segment
->p_type
= PT_NULL
;
5422 /* Since we have deleted P we must restart the outer loop. */
5424 segment
= elf_tdata (ibfd
)->phdr
;
5429 /* Extend SEGMENT to include SEGMENT2 and then delete
5432 SEGMENT_END (segment2
, segment2
->p_vaddr
)
5433 - SEGMENT_END (segment
, segment
->p_vaddr
);
5435 if (extra_length
> 0)
5437 segment
->p_memsz
+= extra_length
;
5438 segment
->p_filesz
+= extra_length
;
5441 segment2
->p_type
= PT_NULL
;
5446 /* The second scan attempts to assign sections to segments. */
5447 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5451 unsigned int section_count
;
5452 asection
** sections
;
5453 asection
* output_section
;
5455 bfd_vma matching_lma
;
5456 bfd_vma suggested_lma
;
5459 asection
* first_section
;
5461 if (segment
->p_type
== PT_NULL
)
5464 first_section
= NULL
;
5465 /* Compute how many sections might be placed into this segment. */
5466 for (section
= ibfd
->sections
, section_count
= 0;
5468 section
= section
->next
)
5470 /* Find the first section in the input segment, which may be
5471 removed from the corresponding output segment. */
5472 if (IS_SECTION_IN_INPUT_SEGMENT (section
, segment
, bed
))
5474 if (first_section
== NULL
)
5475 first_section
= section
;
5476 if (section
->output_section
!= NULL
)
5481 /* Allocate a segment map big enough to contain
5482 all of the sections we have selected. */
5483 amt
= sizeof (struct elf_segment_map
);
5484 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5485 map
= bfd_zalloc (obfd
, amt
);
5489 /* Initialise the fields of the segment map. Default to
5490 using the physical address of the segment in the input BFD. */
5492 map
->p_type
= segment
->p_type
;
5493 map
->p_flags
= segment
->p_flags
;
5494 map
->p_flags_valid
= 1;
5496 /* If the first section in the input segment is removed, there is
5497 no need to preserve segment physical address in the corresponding
5499 if (!first_section
|| first_section
->output_section
!= NULL
)
5501 map
->p_paddr
= segment
->p_paddr
;
5502 map
->p_paddr_valid
= 1;
5505 /* Determine if this segment contains the ELF file header
5506 and if it contains the program headers themselves. */
5507 map
->includes_filehdr
= (segment
->p_offset
== 0
5508 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5510 map
->includes_phdrs
= 0;
5512 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5514 map
->includes_phdrs
=
5515 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5516 && (segment
->p_offset
+ segment
->p_filesz
5517 >= ((bfd_vma
) iehdr
->e_phoff
5518 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5520 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5521 phdr_included
= TRUE
;
5524 if (section_count
== 0)
5526 /* Special segments, such as the PT_PHDR segment, may contain
5527 no sections, but ordinary, loadable segments should contain
5528 something. They are allowed by the ELF spec however, so only
5529 a warning is produced. */
5530 if (segment
->p_type
== PT_LOAD
)
5531 (*_bfd_error_handler
)
5532 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5536 *pointer_to_map
= map
;
5537 pointer_to_map
= &map
->next
;
5542 /* Now scan the sections in the input BFD again and attempt
5543 to add their corresponding output sections to the segment map.
5544 The problem here is how to handle an output section which has
5545 been moved (ie had its LMA changed). There are four possibilities:
5547 1. None of the sections have been moved.
5548 In this case we can continue to use the segment LMA from the
5551 2. All of the sections have been moved by the same amount.
5552 In this case we can change the segment's LMA to match the LMA
5553 of the first section.
5555 3. Some of the sections have been moved, others have not.
5556 In this case those sections which have not been moved can be
5557 placed in the current segment which will have to have its size,
5558 and possibly its LMA changed, and a new segment or segments will
5559 have to be created to contain the other sections.
5561 4. The sections have been moved, but not by the same amount.
5562 In this case we can change the segment's LMA to match the LMA
5563 of the first section and we will have to create a new segment
5564 or segments to contain the other sections.
5566 In order to save time, we allocate an array to hold the section
5567 pointers that we are interested in. As these sections get assigned
5568 to a segment, they are removed from this array. */
5570 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5571 to work around this long long bug. */
5572 sections
= bfd_malloc2 (section_count
, sizeof (asection
*));
5573 if (sections
== NULL
)
5576 /* Step One: Scan for segment vs section LMA conflicts.
5577 Also add the sections to the section array allocated above.
5578 Also add the sections to the current segment. In the common
5579 case, where the sections have not been moved, this means that
5580 we have completely filled the segment, and there is nothing
5586 for (j
= 0, section
= ibfd
->sections
;
5588 section
= section
->next
)
5590 if (INCLUDE_SECTION_IN_SEGMENT (section
, segment
, bed
))
5592 output_section
= section
->output_section
;
5594 sections
[j
++] = section
;
5596 /* The Solaris native linker always sets p_paddr to 0.
5597 We try to catch that case here, and set it to the
5598 correct value. Note - some backends require that
5599 p_paddr be left as zero. */
5600 if (segment
->p_paddr
== 0
5601 && segment
->p_vaddr
!= 0
5602 && (! bed
->want_p_paddr_set_to_zero
)
5604 && output_section
->lma
!= 0
5605 && (output_section
->vma
== (segment
->p_vaddr
5606 + (map
->includes_filehdr
5609 + (map
->includes_phdrs
5611 * iehdr
->e_phentsize
)
5613 map
->p_paddr
= segment
->p_vaddr
;
5615 /* Match up the physical address of the segment with the
5616 LMA address of the output section. */
5617 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5618 || IS_COREFILE_NOTE (segment
, section
)
5619 || (bed
->want_p_paddr_set_to_zero
&&
5620 IS_CONTAINED_BY_VMA (output_section
, segment
)))
5622 if (matching_lma
== 0)
5623 matching_lma
= output_section
->lma
;
5625 /* We assume that if the section fits within the segment
5626 then it does not overlap any other section within that
5628 map
->sections
[isec
++] = output_section
;
5630 else if (suggested_lma
== 0)
5631 suggested_lma
= output_section
->lma
;
5635 BFD_ASSERT (j
== section_count
);
5637 /* Step Two: Adjust the physical address of the current segment,
5639 if (isec
== section_count
)
5641 /* All of the sections fitted within the segment as currently
5642 specified. This is the default case. Add the segment to
5643 the list of built segments and carry on to process the next
5644 program header in the input BFD. */
5645 map
->count
= section_count
;
5646 *pointer_to_map
= map
;
5647 pointer_to_map
= &map
->next
;
5649 if (matching_lma
!= map
->p_paddr
5650 && !map
->includes_filehdr
&& !map
->includes_phdrs
)
5651 /* There is some padding before the first section in the
5652 segment. So, we must account for that in the output
5654 map
->p_vaddr_offset
= matching_lma
- map
->p_paddr
;
5661 if (matching_lma
!= 0)
5663 /* At least one section fits inside the current segment.
5664 Keep it, but modify its physical address to match the
5665 LMA of the first section that fitted. */
5666 map
->p_paddr
= matching_lma
;
5670 /* None of the sections fitted inside the current segment.
5671 Change the current segment's physical address to match
5672 the LMA of the first section. */
5673 map
->p_paddr
= suggested_lma
;
5676 /* Offset the segment physical address from the lma
5677 to allow for space taken up by elf headers. */
5678 if (map
->includes_filehdr
)
5679 map
->p_paddr
-= iehdr
->e_ehsize
;
5681 if (map
->includes_phdrs
)
5683 map
->p_paddr
-= iehdr
->e_phnum
* iehdr
->e_phentsize
;
5685 /* iehdr->e_phnum is just an estimate of the number
5686 of program headers that we will need. Make a note
5687 here of the number we used and the segment we chose
5688 to hold these headers, so that we can adjust the
5689 offset when we know the correct value. */
5690 phdr_adjust_num
= iehdr
->e_phnum
;
5691 phdr_adjust_seg
= map
;
5695 /* Step Three: Loop over the sections again, this time assigning
5696 those that fit to the current segment and removing them from the
5697 sections array; but making sure not to leave large gaps. Once all
5698 possible sections have been assigned to the current segment it is
5699 added to the list of built segments and if sections still remain
5700 to be assigned, a new segment is constructed before repeating
5708 /* Fill the current segment with sections that fit. */
5709 for (j
= 0; j
< section_count
; j
++)
5711 section
= sections
[j
];
5713 if (section
== NULL
)
5716 output_section
= section
->output_section
;
5718 BFD_ASSERT (output_section
!= NULL
);
5720 if (IS_CONTAINED_BY_LMA (output_section
, segment
, map
->p_paddr
)
5721 || IS_COREFILE_NOTE (segment
, section
))
5723 if (map
->count
== 0)
5725 /* If the first section in a segment does not start at
5726 the beginning of the segment, then something is
5728 if (output_section
->lma
!=
5730 + (map
->includes_filehdr
? iehdr
->e_ehsize
: 0)
5731 + (map
->includes_phdrs
5732 ? iehdr
->e_phnum
* iehdr
->e_phentsize
5738 asection
* prev_sec
;
5740 prev_sec
= map
->sections
[map
->count
- 1];
5742 /* If the gap between the end of the previous section
5743 and the start of this section is more than
5744 maxpagesize then we need to start a new segment. */
5745 if ((BFD_ALIGN (prev_sec
->lma
+ prev_sec
->size
,
5747 < BFD_ALIGN (output_section
->lma
, maxpagesize
))
5748 || ((prev_sec
->lma
+ prev_sec
->size
)
5749 > output_section
->lma
))
5751 if (suggested_lma
== 0)
5752 suggested_lma
= output_section
->lma
;
5758 map
->sections
[map
->count
++] = output_section
;
5761 section
->segment_mark
= TRUE
;
5763 else if (suggested_lma
== 0)
5764 suggested_lma
= output_section
->lma
;
5767 BFD_ASSERT (map
->count
> 0);
5769 /* Add the current segment to the list of built segments. */
5770 *pointer_to_map
= map
;
5771 pointer_to_map
= &map
->next
;
5773 if (isec
< section_count
)
5775 /* We still have not allocated all of the sections to
5776 segments. Create a new segment here, initialise it
5777 and carry on looping. */
5778 amt
= sizeof (struct elf_segment_map
);
5779 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5780 map
= bfd_alloc (obfd
, amt
);
5787 /* Initialise the fields of the segment map. Set the physical
5788 physical address to the LMA of the first section that has
5789 not yet been assigned. */
5791 map
->p_type
= segment
->p_type
;
5792 map
->p_flags
= segment
->p_flags
;
5793 map
->p_flags_valid
= 1;
5794 map
->p_paddr
= suggested_lma
;
5795 map
->p_paddr_valid
= 1;
5796 map
->includes_filehdr
= 0;
5797 map
->includes_phdrs
= 0;
5800 while (isec
< section_count
);
5805 /* The Solaris linker creates program headers in which all the
5806 p_paddr fields are zero. When we try to objcopy or strip such a
5807 file, we get confused. Check for this case, and if we find it
5808 reset the p_paddr_valid fields. */
5809 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5810 if (map
->p_paddr
!= 0)
5813 for (map
= map_first
; map
!= NULL
; map
= map
->next
)
5814 map
->p_paddr_valid
= 0;
5816 elf_tdata (obfd
)->segment_map
= map_first
;
5818 /* If we had to estimate the number of program headers that were
5819 going to be needed, then check our estimate now and adjust
5820 the offset if necessary. */
5821 if (phdr_adjust_seg
!= NULL
)
5825 for (count
= 0, map
= map_first
; map
!= NULL
; map
= map
->next
)
5828 if (count
> phdr_adjust_num
)
5829 phdr_adjust_seg
->p_paddr
5830 -= (count
- phdr_adjust_num
) * iehdr
->e_phentsize
;
5835 #undef IS_CONTAINED_BY_VMA
5836 #undef IS_CONTAINED_BY_LMA
5837 #undef IS_COREFILE_NOTE
5838 #undef IS_SOLARIS_PT_INTERP
5839 #undef IS_SECTION_IN_INPUT_SEGMENT
5840 #undef INCLUDE_SECTION_IN_SEGMENT
5841 #undef SEGMENT_AFTER_SEGMENT
5842 #undef SEGMENT_OVERLAPS
5846 /* Copy ELF program header information. */
5849 copy_elf_program_header (bfd
*ibfd
, bfd
*obfd
)
5851 Elf_Internal_Ehdr
*iehdr
;
5852 struct elf_segment_map
*map
;
5853 struct elf_segment_map
*map_first
;
5854 struct elf_segment_map
**pointer_to_map
;
5855 Elf_Internal_Phdr
*segment
;
5857 unsigned int num_segments
;
5858 bfd_boolean phdr_included
= FALSE
;
5860 iehdr
= elf_elfheader (ibfd
);
5863 pointer_to_map
= &map_first
;
5865 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5866 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5871 unsigned int section_count
;
5873 Elf_Internal_Shdr
*this_hdr
;
5874 asection
*first_section
= NULL
;
5876 /* FIXME: Do we need to copy PT_NULL segment? */
5877 if (segment
->p_type
== PT_NULL
)
5880 /* Compute how many sections are in this segment. */
5881 for (section
= ibfd
->sections
, section_count
= 0;
5883 section
= section
->next
)
5885 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5886 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5889 first_section
= section
;
5894 /* Allocate a segment map big enough to contain
5895 all of the sections we have selected. */
5896 amt
= sizeof (struct elf_segment_map
);
5897 if (section_count
!= 0)
5898 amt
+= ((bfd_size_type
) section_count
- 1) * sizeof (asection
*);
5899 map
= bfd_zalloc (obfd
, amt
);
5903 /* Initialize the fields of the output segment map with the
5906 map
->p_type
= segment
->p_type
;
5907 map
->p_flags
= segment
->p_flags
;
5908 map
->p_flags_valid
= 1;
5909 map
->p_paddr
= segment
->p_paddr
;
5910 map
->p_paddr_valid
= 1;
5911 map
->p_align
= segment
->p_align
;
5912 map
->p_align_valid
= 1;
5913 map
->p_vaddr_offset
= 0;
5915 /* Determine if this segment contains the ELF file header
5916 and if it contains the program headers themselves. */
5917 map
->includes_filehdr
= (segment
->p_offset
== 0
5918 && segment
->p_filesz
>= iehdr
->e_ehsize
);
5920 map
->includes_phdrs
= 0;
5921 if (! phdr_included
|| segment
->p_type
!= PT_LOAD
)
5923 map
->includes_phdrs
=
5924 (segment
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
5925 && (segment
->p_offset
+ segment
->p_filesz
5926 >= ((bfd_vma
) iehdr
->e_phoff
5927 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
5929 if (segment
->p_type
== PT_LOAD
&& map
->includes_phdrs
)
5930 phdr_included
= TRUE
;
5933 if (!map
->includes_phdrs
&& !map
->includes_filehdr
)
5934 /* There is some other padding before the first section. */
5935 map
->p_vaddr_offset
= ((first_section
? first_section
->lma
: 0)
5936 - segment
->p_paddr
);
5938 if (section_count
!= 0)
5940 unsigned int isec
= 0;
5942 for (section
= first_section
;
5944 section
= section
->next
)
5946 this_hdr
= &(elf_section_data(section
)->this_hdr
);
5947 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
5949 map
->sections
[isec
++] = section
->output_section
;
5950 if (isec
== section_count
)
5956 map
->count
= section_count
;
5957 *pointer_to_map
= map
;
5958 pointer_to_map
= &map
->next
;
5961 elf_tdata (obfd
)->segment_map
= map_first
;
5965 /* Copy private BFD data. This copies or rewrites ELF program header
5969 copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5971 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5972 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5975 if (elf_tdata (ibfd
)->phdr
== NULL
)
5978 if (ibfd
->xvec
== obfd
->xvec
)
5980 /* Check to see if any sections in the input BFD
5981 covered by ELF program header have changed. */
5982 Elf_Internal_Phdr
*segment
;
5983 asection
*section
, *osec
;
5984 unsigned int i
, num_segments
;
5985 Elf_Internal_Shdr
*this_hdr
;
5987 /* Initialize the segment mark field. */
5988 for (section
= obfd
->sections
; section
!= NULL
;
5989 section
= section
->next
)
5990 section
->segment_mark
= FALSE
;
5992 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
5993 for (i
= 0, segment
= elf_tdata (ibfd
)->phdr
;
5997 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5998 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5999 which severly confuses things, so always regenerate the segment
6000 map in this case. */
6001 if (segment
->p_paddr
== 0
6002 && segment
->p_memsz
== 0
6003 && (segment
->p_type
== PT_INTERP
|| segment
->p_type
== PT_DYNAMIC
))
6006 for (section
= ibfd
->sections
;
6007 section
!= NULL
; section
= section
->next
)
6009 /* We mark the output section so that we know it comes
6010 from the input BFD. */
6011 osec
= section
->output_section
;
6013 osec
->segment_mark
= TRUE
;
6015 /* Check if this section is covered by the segment. */
6016 this_hdr
= &(elf_section_data(section
)->this_hdr
);
6017 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr
, segment
))
6019 /* FIXME: Check if its output section is changed or
6020 removed. What else do we need to check? */
6022 || section
->flags
!= osec
->flags
6023 || section
->lma
!= osec
->lma
6024 || section
->vma
!= osec
->vma
6025 || section
->size
!= osec
->size
6026 || section
->rawsize
!= osec
->rawsize
6027 || section
->alignment_power
!= osec
->alignment_power
)
6033 /* Check to see if any output section do not come from the
6035 for (section
= obfd
->sections
; section
!= NULL
;
6036 section
= section
->next
)
6038 if (section
->segment_mark
== FALSE
)
6041 section
->segment_mark
= FALSE
;
6044 return copy_elf_program_header (ibfd
, obfd
);
6048 return rewrite_elf_program_header (ibfd
, obfd
);
6051 /* Initialize private output section information from input section. */
6054 _bfd_elf_init_private_section_data (bfd
*ibfd
,
6058 struct bfd_link_info
*link_info
)
6061 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6062 bfd_boolean need_group
= link_info
== NULL
|| link_info
->relocatable
;
6064 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6065 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6068 /* Don't copy the output ELF section type from input if the
6069 output BFD section flags have been set to something different.
6070 elf_fake_sections will set ELF section type based on BFD
6072 if (elf_section_type (osec
) == SHT_NULL
6073 && (osec
->flags
== isec
->flags
|| !osec
->flags
))
6074 elf_section_type (osec
) = elf_section_type (isec
);
6076 /* FIXME: Is this correct for all OS/PROC specific flags? */
6077 elf_section_flags (osec
) |= (elf_section_flags (isec
)
6078 & (SHF_MASKOS
| SHF_MASKPROC
));
6080 /* Set things up for objcopy and relocatable link. The output
6081 SHT_GROUP section will have its elf_next_in_group pointing back
6082 to the input group members. Ignore linker created group section.
6083 See elfNN_ia64_object_p in elfxx-ia64.c. */
6086 if (elf_sec_group (isec
) == NULL
6087 || (elf_sec_group (isec
)->flags
& SEC_LINKER_CREATED
) == 0)
6089 if (elf_section_flags (isec
) & SHF_GROUP
)
6090 elf_section_flags (osec
) |= SHF_GROUP
;
6091 elf_next_in_group (osec
) = elf_next_in_group (isec
);
6092 elf_group_name (osec
) = elf_group_name (isec
);
6096 ihdr
= &elf_section_data (isec
)->this_hdr
;
6098 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6099 don't use the output section of the linked-to section since it
6100 may be NULL at this point. */
6101 if ((ihdr
->sh_flags
& SHF_LINK_ORDER
) != 0)
6103 ohdr
= &elf_section_data (osec
)->this_hdr
;
6104 ohdr
->sh_flags
|= SHF_LINK_ORDER
;
6105 elf_linked_to_section (osec
) = elf_linked_to_section (isec
);
6108 osec
->use_rela_p
= isec
->use_rela_p
;
6113 /* Copy private section information. This copies over the entsize
6114 field, and sometimes the info field. */
6117 _bfd_elf_copy_private_section_data (bfd
*ibfd
,
6122 Elf_Internal_Shdr
*ihdr
, *ohdr
;
6124 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
6125 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
6128 ihdr
= &elf_section_data (isec
)->this_hdr
;
6129 ohdr
= &elf_section_data (osec
)->this_hdr
;
6131 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
6133 if (ihdr
->sh_type
== SHT_SYMTAB
6134 || ihdr
->sh_type
== SHT_DYNSYM
6135 || ihdr
->sh_type
== SHT_GNU_verneed
6136 || ihdr
->sh_type
== SHT_GNU_verdef
)
6137 ohdr
->sh_info
= ihdr
->sh_info
;
6139 return _bfd_elf_init_private_section_data (ibfd
, isec
, obfd
, osec
,
6143 /* Copy private header information. */
6146 _bfd_elf_copy_private_header_data (bfd
*ibfd
, bfd
*obfd
)
6150 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6151 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6154 /* Copy over private BFD data if it has not already been copied.
6155 This must be done here, rather than in the copy_private_bfd_data
6156 entry point, because the latter is called after the section
6157 contents have been set, which means that the program headers have
6158 already been worked out. */
6159 if (elf_tdata (obfd
)->segment_map
== NULL
&& elf_tdata (ibfd
)->phdr
!= NULL
)
6161 if (! copy_private_bfd_data (ibfd
, obfd
))
6165 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6166 but this might be wrong if we deleted the group section. */
6167 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
6168 if (elf_section_type (isec
) == SHT_GROUP
6169 && isec
->output_section
== NULL
)
6171 asection
*first
= elf_next_in_group (isec
);
6172 asection
*s
= first
;
6175 if (s
->output_section
!= NULL
)
6177 elf_section_flags (s
->output_section
) &= ~SHF_GROUP
;
6178 elf_group_name (s
->output_section
) = NULL
;
6180 s
= elf_next_in_group (s
);
6189 /* Copy private symbol information. If this symbol is in a section
6190 which we did not map into a BFD section, try to map the section
6191 index correctly. We use special macro definitions for the mapped
6192 section indices; these definitions are interpreted by the
6193 swap_out_syms function. */
6195 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6196 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6197 #define MAP_STRTAB (SHN_HIOS + 3)
6198 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6199 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6202 _bfd_elf_copy_private_symbol_data (bfd
*ibfd
,
6207 elf_symbol_type
*isym
, *osym
;
6209 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
6210 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
6213 isym
= elf_symbol_from (ibfd
, isymarg
);
6214 osym
= elf_symbol_from (obfd
, osymarg
);
6218 && bfd_is_abs_section (isym
->symbol
.section
))
6222 shndx
= isym
->internal_elf_sym
.st_shndx
;
6223 if (shndx
== elf_onesymtab (ibfd
))
6224 shndx
= MAP_ONESYMTAB
;
6225 else if (shndx
== elf_dynsymtab (ibfd
))
6226 shndx
= MAP_DYNSYMTAB
;
6227 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
6229 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
6230 shndx
= MAP_SHSTRTAB
;
6231 else if (shndx
== elf_tdata (ibfd
)->symtab_shndx_section
)
6232 shndx
= MAP_SYM_SHNDX
;
6233 osym
->internal_elf_sym
.st_shndx
= shndx
;
6239 /* Swap out the symbols. */
6242 swap_out_syms (bfd
*abfd
,
6243 struct bfd_strtab_hash
**sttp
,
6246 const struct elf_backend_data
*bed
;
6249 struct bfd_strtab_hash
*stt
;
6250 Elf_Internal_Shdr
*symtab_hdr
;
6251 Elf_Internal_Shdr
*symtab_shndx_hdr
;
6252 Elf_Internal_Shdr
*symstrtab_hdr
;
6253 bfd_byte
*outbound_syms
;
6254 bfd_byte
*outbound_shndx
;
6257 bfd_boolean name_local_sections
;
6259 if (!elf_map_symbols (abfd
))
6262 /* Dump out the symtabs. */
6263 stt
= _bfd_elf_stringtab_init ();
6267 bed
= get_elf_backend_data (abfd
);
6268 symcount
= bfd_get_symcount (abfd
);
6269 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6270 symtab_hdr
->sh_type
= SHT_SYMTAB
;
6271 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
6272 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
6273 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
6274 symtab_hdr
->sh_addralign
= 1 << bed
->s
->log_file_align
;
6276 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
6277 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6279 outbound_syms
= bfd_alloc2 (abfd
, 1 + symcount
, bed
->s
->sizeof_sym
);
6280 if (outbound_syms
== NULL
)
6282 _bfd_stringtab_free (stt
);
6285 symtab_hdr
->contents
= outbound_syms
;
6287 outbound_shndx
= NULL
;
6288 symtab_shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
6289 if (symtab_shndx_hdr
->sh_name
!= 0)
6291 amt
= (bfd_size_type
) (1 + symcount
) * sizeof (Elf_External_Sym_Shndx
);
6292 outbound_shndx
= bfd_zalloc2 (abfd
, 1 + symcount
,
6293 sizeof (Elf_External_Sym_Shndx
));
6294 if (outbound_shndx
== NULL
)
6296 _bfd_stringtab_free (stt
);
6300 symtab_shndx_hdr
->contents
= outbound_shndx
;
6301 symtab_shndx_hdr
->sh_type
= SHT_SYMTAB_SHNDX
;
6302 symtab_shndx_hdr
->sh_size
= amt
;
6303 symtab_shndx_hdr
->sh_addralign
= sizeof (Elf_External_Sym_Shndx
);
6304 symtab_shndx_hdr
->sh_entsize
= sizeof (Elf_External_Sym_Shndx
);
6307 /* Now generate the data (for "contents"). */
6309 /* Fill in zeroth symbol and swap it out. */
6310 Elf_Internal_Sym sym
;
6316 sym
.st_shndx
= SHN_UNDEF
;
6317 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6318 outbound_syms
+= bed
->s
->sizeof_sym
;
6319 if (outbound_shndx
!= NULL
)
6320 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6324 = (bed
->elf_backend_name_local_section_symbols
6325 && bed
->elf_backend_name_local_section_symbols (abfd
));
6327 syms
= bfd_get_outsymbols (abfd
);
6328 for (idx
= 0; idx
< symcount
; idx
++)
6330 Elf_Internal_Sym sym
;
6331 bfd_vma value
= syms
[idx
]->value
;
6332 elf_symbol_type
*type_ptr
;
6333 flagword flags
= syms
[idx
]->flags
;
6336 if (!name_local_sections
6337 && (flags
& (BSF_SECTION_SYM
| BSF_GLOBAL
)) == BSF_SECTION_SYM
)
6339 /* Local section symbols have no name. */
6344 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
6347 if (sym
.st_name
== (unsigned long) -1)
6349 _bfd_stringtab_free (stt
);
6354 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
6356 if ((flags
& BSF_SECTION_SYM
) == 0
6357 && bfd_is_com_section (syms
[idx
]->section
))
6359 /* ELF common symbols put the alignment into the `value' field,
6360 and the size into the `size' field. This is backwards from
6361 how BFD handles it, so reverse it here. */
6362 sym
.st_size
= value
;
6363 if (type_ptr
== NULL
6364 || type_ptr
->internal_elf_sym
.st_value
== 0)
6365 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
6367 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
6368 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
6369 (abfd
, syms
[idx
]->section
);
6373 asection
*sec
= syms
[idx
]->section
;
6376 if (sec
->output_section
)
6378 value
+= sec
->output_offset
;
6379 sec
= sec
->output_section
;
6382 /* Don't add in the section vma for relocatable output. */
6383 if (! relocatable_p
)
6385 sym
.st_value
= value
;
6386 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
6388 if (bfd_is_abs_section (sec
)
6390 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
6392 /* This symbol is in a real ELF section which we did
6393 not create as a BFD section. Undo the mapping done
6394 by copy_private_symbol_data. */
6395 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
6399 shndx
= elf_onesymtab (abfd
);
6402 shndx
= elf_dynsymtab (abfd
);
6405 shndx
= elf_tdata (abfd
)->strtab_section
;
6408 shndx
= elf_tdata (abfd
)->shstrtab_section
;
6411 shndx
= elf_tdata (abfd
)->symtab_shndx_section
;
6419 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
6425 /* Writing this would be a hell of a lot easier if
6426 we had some decent documentation on bfd, and
6427 knew what to expect of the library, and what to
6428 demand of applications. For example, it
6429 appears that `objcopy' might not set the
6430 section of a symbol to be a section that is
6431 actually in the output file. */
6432 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
6435 _bfd_error_handler (_("\
6436 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6437 syms
[idx
]->name
? syms
[idx
]->name
: "<Local sym>",
6439 bfd_set_error (bfd_error_invalid_operation
);
6440 _bfd_stringtab_free (stt
);
6444 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
6445 BFD_ASSERT (shndx
!= -1);
6449 sym
.st_shndx
= shndx
;
6452 if ((flags
& BSF_THREAD_LOCAL
) != 0)
6454 else if ((flags
& BSF_FUNCTION
) != 0)
6456 else if ((flags
& BSF_OBJECT
) != 0)
6458 else if ((flags
& BSF_RELC
) != 0)
6460 else if ((flags
& BSF_SRELC
) != 0)
6465 if (syms
[idx
]->section
->flags
& SEC_THREAD_LOCAL
)
6468 /* Processor-specific types. */
6469 if (type_ptr
!= NULL
6470 && bed
->elf_backend_get_symbol_type
)
6471 type
= ((*bed
->elf_backend_get_symbol_type
)
6472 (&type_ptr
->internal_elf_sym
, type
));
6474 if (flags
& BSF_SECTION_SYM
)
6476 if (flags
& BSF_GLOBAL
)
6477 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
6479 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
6481 else if (bfd_is_com_section (syms
[idx
]->section
))
6482 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
6483 else if (bfd_is_und_section (syms
[idx
]->section
))
6484 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
6488 else if (flags
& BSF_FILE
)
6489 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
6492 int bind
= STB_LOCAL
;
6494 if (flags
& BSF_LOCAL
)
6496 else if (flags
& BSF_WEAK
)
6498 else if (flags
& BSF_GLOBAL
)
6501 sym
.st_info
= ELF_ST_INFO (bind
, type
);
6504 if (type_ptr
!= NULL
)
6505 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
6509 bed
->s
->swap_symbol_out (abfd
, &sym
, outbound_syms
, outbound_shndx
);
6510 outbound_syms
+= bed
->s
->sizeof_sym
;
6511 if (outbound_shndx
!= NULL
)
6512 outbound_shndx
+= sizeof (Elf_External_Sym_Shndx
);
6516 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
6517 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
6519 symstrtab_hdr
->sh_flags
= 0;
6520 symstrtab_hdr
->sh_addr
= 0;
6521 symstrtab_hdr
->sh_entsize
= 0;
6522 symstrtab_hdr
->sh_link
= 0;
6523 symstrtab_hdr
->sh_info
= 0;
6524 symstrtab_hdr
->sh_addralign
= 1;
6529 /* Return the number of bytes required to hold the symtab vector.
6531 Note that we base it on the count plus 1, since we will null terminate
6532 the vector allocated based on this size. However, the ELF symbol table
6533 always has a dummy entry as symbol #0, so it ends up even. */
6536 _bfd_elf_get_symtab_upper_bound (bfd
*abfd
)
6540 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6542 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6543 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6545 symtab_size
-= sizeof (asymbol
*);
6551 _bfd_elf_get_dynamic_symtab_upper_bound (bfd
*abfd
)
6555 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
6557 if (elf_dynsymtab (abfd
) == 0)
6559 bfd_set_error (bfd_error_invalid_operation
);
6563 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
6564 symtab_size
= (symcount
+ 1) * (sizeof (asymbol
*));
6566 symtab_size
-= sizeof (asymbol
*);
6572 _bfd_elf_get_reloc_upper_bound (bfd
*abfd ATTRIBUTE_UNUSED
,
6575 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
6578 /* Canonicalize the relocs. */
6581 _bfd_elf_canonicalize_reloc (bfd
*abfd
,
6588 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6590 if (! bed
->s
->slurp_reloc_table (abfd
, section
, symbols
, FALSE
))
6593 tblptr
= section
->relocation
;
6594 for (i
= 0; i
< section
->reloc_count
; i
++)
6595 *relptr
++ = tblptr
++;
6599 return section
->reloc_count
;
6603 _bfd_elf_canonicalize_symtab (bfd
*abfd
, asymbol
**allocation
)
6605 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6606 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, FALSE
);
6609 bfd_get_symcount (abfd
) = symcount
;
6614 _bfd_elf_canonicalize_dynamic_symtab (bfd
*abfd
,
6615 asymbol
**allocation
)
6617 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
6618 long symcount
= bed
->s
->slurp_symbol_table (abfd
, allocation
, TRUE
);
6621 bfd_get_dynamic_symcount (abfd
) = symcount
;
6625 /* Return the size required for the dynamic reloc entries. Any loadable
6626 section that was actually installed in the BFD, and has type SHT_REL
6627 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6628 dynamic reloc section. */
6631 _bfd_elf_get_dynamic_reloc_upper_bound (bfd
*abfd
)
6636 if (elf_dynsymtab (abfd
) == 0)
6638 bfd_set_error (bfd_error_invalid_operation
);
6642 ret
= sizeof (arelent
*);
6643 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6644 if ((s
->flags
& SEC_LOAD
) != 0
6645 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6646 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6647 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6648 ret
+= ((s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
6649 * sizeof (arelent
*));
6654 /* Canonicalize the dynamic relocation entries. Note that we return the
6655 dynamic relocations as a single block, although they are actually
6656 associated with particular sections; the interface, which was
6657 designed for SunOS style shared libraries, expects that there is only
6658 one set of dynamic relocs. Any loadable section that was actually
6659 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6660 dynamic symbol table, is considered to be a dynamic reloc section. */
6663 _bfd_elf_canonicalize_dynamic_reloc (bfd
*abfd
,
6667 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
6671 if (elf_dynsymtab (abfd
) == 0)
6673 bfd_set_error (bfd_error_invalid_operation
);
6677 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
6679 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6681 if ((s
->flags
& SEC_LOAD
) != 0
6682 && elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
6683 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
6684 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
6689 if (! (*slurp_relocs
) (abfd
, s
, syms
, TRUE
))
6691 count
= s
->size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
6693 for (i
= 0; i
< count
; i
++)
6704 /* Read in the version information. */
6707 _bfd_elf_slurp_version_tables (bfd
*abfd
, bfd_boolean default_imported_symver
)
6709 bfd_byte
*contents
= NULL
;
6710 unsigned int freeidx
= 0;
6712 if (elf_dynverref (abfd
) != 0)
6714 Elf_Internal_Shdr
*hdr
;
6715 Elf_External_Verneed
*everneed
;
6716 Elf_Internal_Verneed
*iverneed
;
6718 bfd_byte
*contents_end
;
6720 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
6722 elf_tdata (abfd
)->verref
= bfd_zalloc2 (abfd
, hdr
->sh_info
,
6723 sizeof (Elf_Internal_Verneed
));
6724 if (elf_tdata (abfd
)->verref
== NULL
)
6727 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
6729 contents
= bfd_malloc (hdr
->sh_size
);
6730 if (contents
== NULL
)
6732 error_return_verref
:
6733 elf_tdata (abfd
)->verref
= NULL
;
6734 elf_tdata (abfd
)->cverrefs
= 0;
6737 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6738 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6739 goto error_return_verref
;
6741 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verneed
))
6742 goto error_return_verref
;
6744 BFD_ASSERT (sizeof (Elf_External_Verneed
)
6745 == sizeof (Elf_External_Vernaux
));
6746 contents_end
= contents
+ hdr
->sh_size
- sizeof (Elf_External_Verneed
);
6747 everneed
= (Elf_External_Verneed
*) contents
;
6748 iverneed
= elf_tdata (abfd
)->verref
;
6749 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
6751 Elf_External_Vernaux
*evernaux
;
6752 Elf_Internal_Vernaux
*ivernaux
;
6755 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
6757 iverneed
->vn_bfd
= abfd
;
6759 iverneed
->vn_filename
=
6760 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6762 if (iverneed
->vn_filename
== NULL
)
6763 goto error_return_verref
;
6765 if (iverneed
->vn_cnt
== 0)
6766 iverneed
->vn_auxptr
= NULL
;
6769 iverneed
->vn_auxptr
= bfd_alloc2 (abfd
, iverneed
->vn_cnt
,
6770 sizeof (Elf_Internal_Vernaux
));
6771 if (iverneed
->vn_auxptr
== NULL
)
6772 goto error_return_verref
;
6775 if (iverneed
->vn_aux
6776 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6777 goto error_return_verref
;
6779 evernaux
= ((Elf_External_Vernaux
*)
6780 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
6781 ivernaux
= iverneed
->vn_auxptr
;
6782 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
6784 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
6786 ivernaux
->vna_nodename
=
6787 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6788 ivernaux
->vna_name
);
6789 if (ivernaux
->vna_nodename
== NULL
)
6790 goto error_return_verref
;
6792 if (j
+ 1 < iverneed
->vn_cnt
)
6793 ivernaux
->vna_nextptr
= ivernaux
+ 1;
6795 ivernaux
->vna_nextptr
= NULL
;
6797 if (ivernaux
->vna_next
6798 > (size_t) (contents_end
- (bfd_byte
*) evernaux
))
6799 goto error_return_verref
;
6801 evernaux
= ((Elf_External_Vernaux
*)
6802 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
6804 if (ivernaux
->vna_other
> freeidx
)
6805 freeidx
= ivernaux
->vna_other
;
6808 if (i
+ 1 < hdr
->sh_info
)
6809 iverneed
->vn_nextref
= iverneed
+ 1;
6811 iverneed
->vn_nextref
= NULL
;
6813 if (iverneed
->vn_next
6814 > (size_t) (contents_end
- (bfd_byte
*) everneed
))
6815 goto error_return_verref
;
6817 everneed
= ((Elf_External_Verneed
*)
6818 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
6825 if (elf_dynverdef (abfd
) != 0)
6827 Elf_Internal_Shdr
*hdr
;
6828 Elf_External_Verdef
*everdef
;
6829 Elf_Internal_Verdef
*iverdef
;
6830 Elf_Internal_Verdef
*iverdefarr
;
6831 Elf_Internal_Verdef iverdefmem
;
6833 unsigned int maxidx
;
6834 bfd_byte
*contents_end_def
, *contents_end_aux
;
6836 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
6838 contents
= bfd_malloc (hdr
->sh_size
);
6839 if (contents
== NULL
)
6841 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
6842 || bfd_bread (contents
, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
6845 if (hdr
->sh_info
&& hdr
->sh_size
< sizeof (Elf_External_Verdef
))
6848 BFD_ASSERT (sizeof (Elf_External_Verdef
)
6849 >= sizeof (Elf_External_Verdaux
));
6850 contents_end_def
= contents
+ hdr
->sh_size
6851 - sizeof (Elf_External_Verdef
);
6852 contents_end_aux
= contents
+ hdr
->sh_size
6853 - sizeof (Elf_External_Verdaux
);
6855 /* We know the number of entries in the section but not the maximum
6856 index. Therefore we have to run through all entries and find
6858 everdef
= (Elf_External_Verdef
*) contents
;
6860 for (i
= 0; i
< hdr
->sh_info
; ++i
)
6862 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6864 if ((iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
)) > maxidx
)
6865 maxidx
= iverdefmem
.vd_ndx
& ((unsigned) VERSYM_VERSION
);
6867 if (iverdefmem
.vd_next
6868 > (size_t) (contents_end_def
- (bfd_byte
*) everdef
))
6871 everdef
= ((Elf_External_Verdef
*)
6872 ((bfd_byte
*) everdef
+ iverdefmem
.vd_next
));
6875 if (default_imported_symver
)
6877 if (freeidx
> maxidx
)
6882 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, maxidx
,
6883 sizeof (Elf_Internal_Verdef
));
6884 if (elf_tdata (abfd
)->verdef
== NULL
)
6887 elf_tdata (abfd
)->cverdefs
= maxidx
;
6889 everdef
= (Elf_External_Verdef
*) contents
;
6890 iverdefarr
= elf_tdata (abfd
)->verdef
;
6891 for (i
= 0; i
< hdr
->sh_info
; i
++)
6893 Elf_External_Verdaux
*everdaux
;
6894 Elf_Internal_Verdaux
*iverdaux
;
6897 _bfd_elf_swap_verdef_in (abfd
, everdef
, &iverdefmem
);
6899 if ((iverdefmem
.vd_ndx
& VERSYM_VERSION
) == 0)
6901 error_return_verdef
:
6902 elf_tdata (abfd
)->verdef
= NULL
;
6903 elf_tdata (abfd
)->cverdefs
= 0;
6907 iverdef
= &iverdefarr
[(iverdefmem
.vd_ndx
& VERSYM_VERSION
) - 1];
6908 memcpy (iverdef
, &iverdefmem
, sizeof (Elf_Internal_Verdef
));
6910 iverdef
->vd_bfd
= abfd
;
6912 if (iverdef
->vd_cnt
== 0)
6913 iverdef
->vd_auxptr
= NULL
;
6916 iverdef
->vd_auxptr
= bfd_alloc2 (abfd
, iverdef
->vd_cnt
,
6917 sizeof (Elf_Internal_Verdaux
));
6918 if (iverdef
->vd_auxptr
== NULL
)
6919 goto error_return_verdef
;
6923 > (size_t) (contents_end_aux
- (bfd_byte
*) everdef
))
6924 goto error_return_verdef
;
6926 everdaux
= ((Elf_External_Verdaux
*)
6927 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
6928 iverdaux
= iverdef
->vd_auxptr
;
6929 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
6931 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
6933 iverdaux
->vda_nodename
=
6934 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
6935 iverdaux
->vda_name
);
6936 if (iverdaux
->vda_nodename
== NULL
)
6937 goto error_return_verdef
;
6939 if (j
+ 1 < iverdef
->vd_cnt
)
6940 iverdaux
->vda_nextptr
= iverdaux
+ 1;
6942 iverdaux
->vda_nextptr
= NULL
;
6944 if (iverdaux
->vda_next
6945 > (size_t) (contents_end_aux
- (bfd_byte
*) everdaux
))
6946 goto error_return_verdef
;
6948 everdaux
= ((Elf_External_Verdaux
*)
6949 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
6952 if (iverdef
->vd_cnt
)
6953 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
6955 if ((size_t) (iverdef
- iverdefarr
) + 1 < maxidx
)
6956 iverdef
->vd_nextdef
= iverdef
+ 1;
6958 iverdef
->vd_nextdef
= NULL
;
6960 everdef
= ((Elf_External_Verdef
*)
6961 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
6967 else if (default_imported_symver
)
6974 elf_tdata (abfd
)->verdef
= bfd_zalloc2 (abfd
, freeidx
,
6975 sizeof (Elf_Internal_Verdef
));
6976 if (elf_tdata (abfd
)->verdef
== NULL
)
6979 elf_tdata (abfd
)->cverdefs
= freeidx
;
6982 /* Create a default version based on the soname. */
6983 if (default_imported_symver
)
6985 Elf_Internal_Verdef
*iverdef
;
6986 Elf_Internal_Verdaux
*iverdaux
;
6988 iverdef
= &elf_tdata (abfd
)->verdef
[freeidx
- 1];;
6990 iverdef
->vd_version
= VER_DEF_CURRENT
;
6991 iverdef
->vd_flags
= 0;
6992 iverdef
->vd_ndx
= freeidx
;
6993 iverdef
->vd_cnt
= 1;
6995 iverdef
->vd_bfd
= abfd
;
6997 iverdef
->vd_nodename
= bfd_elf_get_dt_soname (abfd
);
6998 if (iverdef
->vd_nodename
== NULL
)
6999 goto error_return_verdef
;
7000 iverdef
->vd_nextdef
= NULL
;
7001 iverdef
->vd_auxptr
= bfd_alloc (abfd
, sizeof (Elf_Internal_Verdaux
));
7002 if (iverdef
->vd_auxptr
== NULL
)
7003 goto error_return_verdef
;
7005 iverdaux
= iverdef
->vd_auxptr
;
7006 iverdaux
->vda_nodename
= iverdef
->vd_nodename
;
7007 iverdaux
->vda_nextptr
= NULL
;
7013 if (contents
!= NULL
)
7019 _bfd_elf_make_empty_symbol (bfd
*abfd
)
7021 elf_symbol_type
*newsym
;
7022 bfd_size_type amt
= sizeof (elf_symbol_type
);
7024 newsym
= bfd_zalloc (abfd
, amt
);
7029 newsym
->symbol
.the_bfd
= abfd
;
7030 return &newsym
->symbol
;
7035 _bfd_elf_get_symbol_info (bfd
*abfd ATTRIBUTE_UNUSED
,
7039 bfd_symbol_info (symbol
, ret
);
7042 /* Return whether a symbol name implies a local symbol. Most targets
7043 use this function for the is_local_label_name entry point, but some
7047 _bfd_elf_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
7050 /* Normal local symbols start with ``.L''. */
7051 if (name
[0] == '.' && name
[1] == 'L')
7054 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7055 DWARF debugging symbols starting with ``..''. */
7056 if (name
[0] == '.' && name
[1] == '.')
7059 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7060 emitting DWARF debugging output. I suspect this is actually a
7061 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7062 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7063 underscore to be emitted on some ELF targets). For ease of use,
7064 we treat such symbols as local. */
7065 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
7072 _bfd_elf_get_lineno (bfd
*abfd ATTRIBUTE_UNUSED
,
7073 asymbol
*symbol ATTRIBUTE_UNUSED
)
7080 _bfd_elf_set_arch_mach (bfd
*abfd
,
7081 enum bfd_architecture arch
,
7082 unsigned long machine
)
7084 /* If this isn't the right architecture for this backend, and this
7085 isn't the generic backend, fail. */
7086 if (arch
!= get_elf_backend_data (abfd
)->arch
7087 && arch
!= bfd_arch_unknown
7088 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
7091 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
7094 /* Find the function to a particular section and offset,
7095 for error reporting. */
7098 elf_find_function (bfd
*abfd ATTRIBUTE_UNUSED
,
7102 const char **filename_ptr
,
7103 const char **functionname_ptr
)
7105 const char *filename
;
7106 asymbol
*func
, *file
;
7109 /* ??? Given multiple file symbols, it is impossible to reliably
7110 choose the right file name for global symbols. File symbols are
7111 local symbols, and thus all file symbols must sort before any
7112 global symbols. The ELF spec may be interpreted to say that a
7113 file symbol must sort before other local symbols, but currently
7114 ld -r doesn't do this. So, for ld -r output, it is possible to
7115 make a better choice of file name for local symbols by ignoring
7116 file symbols appearing after a given local symbol. */
7117 enum { nothing_seen
, symbol_seen
, file_after_symbol_seen
} state
;
7123 state
= nothing_seen
;
7125 for (p
= symbols
; *p
!= NULL
; p
++)
7129 q
= (elf_symbol_type
*) *p
;
7131 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
7137 if (state
== symbol_seen
)
7138 state
= file_after_symbol_seen
;
7142 if (bfd_get_section (&q
->symbol
) == section
7143 && q
->symbol
.value
>= low_func
7144 && q
->symbol
.value
<= offset
)
7146 func
= (asymbol
*) q
;
7147 low_func
= q
->symbol
.value
;
7150 && (ELF_ST_BIND (q
->internal_elf_sym
.st_info
) == STB_LOCAL
7151 || state
!= file_after_symbol_seen
))
7152 filename
= bfd_asymbol_name (file
);
7156 if (state
== nothing_seen
)
7157 state
= symbol_seen
;
7164 *filename_ptr
= filename
;
7165 if (functionname_ptr
)
7166 *functionname_ptr
= bfd_asymbol_name (func
);
7171 /* Find the nearest line to a particular section and offset,
7172 for error reporting. */
7175 _bfd_elf_find_nearest_line (bfd
*abfd
,
7179 const char **filename_ptr
,
7180 const char **functionname_ptr
,
7181 unsigned int *line_ptr
)
7185 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
7186 filename_ptr
, functionname_ptr
,
7189 if (!*functionname_ptr
)
7190 elf_find_function (abfd
, section
, symbols
, offset
,
7191 *filename_ptr
? NULL
: filename_ptr
,
7197 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
7198 filename_ptr
, functionname_ptr
,
7200 &elf_tdata (abfd
)->dwarf2_find_line_info
))
7202 if (!*functionname_ptr
)
7203 elf_find_function (abfd
, section
, symbols
, offset
,
7204 *filename_ptr
? NULL
: filename_ptr
,
7210 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
7211 &found
, filename_ptr
,
7212 functionname_ptr
, line_ptr
,
7213 &elf_tdata (abfd
)->line_info
))
7215 if (found
&& (*functionname_ptr
|| *line_ptr
))
7218 if (symbols
== NULL
)
7221 if (! elf_find_function (abfd
, section
, symbols
, offset
,
7222 filename_ptr
, functionname_ptr
))
7229 /* Find the line for a symbol. */
7232 _bfd_elf_find_line (bfd
*abfd
, asymbol
**symbols
, asymbol
*symbol
,
7233 const char **filename_ptr
, unsigned int *line_ptr
)
7235 return _bfd_dwarf2_find_line (abfd
, symbols
, symbol
,
7236 filename_ptr
, line_ptr
, 0,
7237 &elf_tdata (abfd
)->dwarf2_find_line_info
);
7240 /* After a call to bfd_find_nearest_line, successive calls to
7241 bfd_find_inliner_info can be used to get source information about
7242 each level of function inlining that terminated at the address
7243 passed to bfd_find_nearest_line. Currently this is only supported
7244 for DWARF2 with appropriate DWARF3 extensions. */
7247 _bfd_elf_find_inliner_info (bfd
*abfd
,
7248 const char **filename_ptr
,
7249 const char **functionname_ptr
,
7250 unsigned int *line_ptr
)
7253 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
7254 functionname_ptr
, line_ptr
,
7255 & elf_tdata (abfd
)->dwarf2_find_line_info
);
7260 _bfd_elf_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
7262 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7263 int ret
= bed
->s
->sizeof_ehdr
;
7265 if (!info
->relocatable
)
7267 bfd_size_type phdr_size
= elf_tdata (abfd
)->program_header_size
;
7269 if (phdr_size
== (bfd_size_type
) -1)
7271 struct elf_segment_map
*m
;
7274 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
7275 phdr_size
+= bed
->s
->sizeof_phdr
;
7278 phdr_size
= get_program_header_size (abfd
, info
);
7281 elf_tdata (abfd
)->program_header_size
= phdr_size
;
7289 _bfd_elf_set_section_contents (bfd
*abfd
,
7291 const void *location
,
7293 bfd_size_type count
)
7295 Elf_Internal_Shdr
*hdr
;
7298 if (! abfd
->output_has_begun
7299 && ! _bfd_elf_compute_section_file_positions (abfd
, NULL
))
7302 hdr
= &elf_section_data (section
)->this_hdr
;
7303 pos
= hdr
->sh_offset
+ offset
;
7304 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0
7305 || bfd_bwrite (location
, count
, abfd
) != count
)
7312 _bfd_elf_no_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
7313 arelent
*cache_ptr ATTRIBUTE_UNUSED
,
7314 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
)
7319 /* Try to convert a non-ELF reloc into an ELF one. */
7322 _bfd_elf_validate_reloc (bfd
*abfd
, arelent
*areloc
)
7324 /* Check whether we really have an ELF howto. */
7326 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
7328 bfd_reloc_code_real_type code
;
7329 reloc_howto_type
*howto
;
7331 /* Alien reloc: Try to determine its type to replace it with an
7332 equivalent ELF reloc. */
7334 if (areloc
->howto
->pc_relative
)
7336 switch (areloc
->howto
->bitsize
)
7339 code
= BFD_RELOC_8_PCREL
;
7342 code
= BFD_RELOC_12_PCREL
;
7345 code
= BFD_RELOC_16_PCREL
;
7348 code
= BFD_RELOC_24_PCREL
;
7351 code
= BFD_RELOC_32_PCREL
;
7354 code
= BFD_RELOC_64_PCREL
;
7360 howto
= bfd_reloc_type_lookup (abfd
, code
);
7362 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
7364 if (howto
->pcrel_offset
)
7365 areloc
->addend
+= areloc
->address
;
7367 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
7372 switch (areloc
->howto
->bitsize
)
7378 code
= BFD_RELOC_14
;
7381 code
= BFD_RELOC_16
;
7384 code
= BFD_RELOC_26
;
7387 code
= BFD_RELOC_32
;
7390 code
= BFD_RELOC_64
;
7396 howto
= bfd_reloc_type_lookup (abfd
, code
);
7400 areloc
->howto
= howto
;
7408 (*_bfd_error_handler
)
7409 (_("%B: unsupported relocation type %s"),
7410 abfd
, areloc
->howto
->name
);
7411 bfd_set_error (bfd_error_bad_value
);
7416 _bfd_elf_close_and_cleanup (bfd
*abfd
)
7418 if (bfd_get_format (abfd
) == bfd_object
)
7420 if (elf_tdata (abfd
) != NULL
&& elf_shstrtab (abfd
) != NULL
)
7421 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
7422 _bfd_dwarf2_cleanup_debug_info (abfd
);
7425 return _bfd_generic_close_and_cleanup (abfd
);
7428 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7429 in the relocation's offset. Thus we cannot allow any sort of sanity
7430 range-checking to interfere. There is nothing else to do in processing
7433 bfd_reloc_status_type
7434 _bfd_elf_rel_vtable_reloc_fn
7435 (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*re ATTRIBUTE_UNUSED
,
7436 struct bfd_symbol
*symbol ATTRIBUTE_UNUSED
,
7437 void *data ATTRIBUTE_UNUSED
, asection
*is ATTRIBUTE_UNUSED
,
7438 bfd
*obfd ATTRIBUTE_UNUSED
, char **errmsg ATTRIBUTE_UNUSED
)
7440 return bfd_reloc_ok
;
7443 /* Elf core file support. Much of this only works on native
7444 toolchains, since we rely on knowing the
7445 machine-dependent procfs structure in order to pick
7446 out details about the corefile. */
7448 #ifdef HAVE_SYS_PROCFS_H
7449 # include <sys/procfs.h>
7452 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7455 elfcore_make_pid (bfd
*abfd
)
7457 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
7458 + (elf_tdata (abfd
)->core_pid
));
7461 /* If there isn't a section called NAME, make one, using
7462 data from SECT. Note, this function will generate a
7463 reference to NAME, so you shouldn't deallocate or
7467 elfcore_maybe_make_sect (bfd
*abfd
, char *name
, asection
*sect
)
7471 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
7474 sect2
= bfd_make_section_with_flags (abfd
, name
, sect
->flags
);
7478 sect2
->size
= sect
->size
;
7479 sect2
->filepos
= sect
->filepos
;
7480 sect2
->alignment_power
= sect
->alignment_power
;
7484 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7485 actually creates up to two pseudosections:
7486 - For the single-threaded case, a section named NAME, unless
7487 such a section already exists.
7488 - For the multi-threaded case, a section named "NAME/PID", where
7489 PID is elfcore_make_pid (abfd).
7490 Both pseudosections have identical contents. */
7492 _bfd_elfcore_make_pseudosection (bfd
*abfd
,
7498 char *threaded_name
;
7502 /* Build the section name. */
7504 sprintf (buf
, "%s/%d", name
, elfcore_make_pid (abfd
));
7505 len
= strlen (buf
) + 1;
7506 threaded_name
= bfd_alloc (abfd
, len
);
7507 if (threaded_name
== NULL
)
7509 memcpy (threaded_name
, buf
, len
);
7511 sect
= bfd_make_section_anyway_with_flags (abfd
, threaded_name
,
7516 sect
->filepos
= filepos
;
7517 sect
->alignment_power
= 2;
7519 return elfcore_maybe_make_sect (abfd
, name
, sect
);
7522 /* prstatus_t exists on:
7524 linux 2.[01] + glibc
7528 #if defined (HAVE_PRSTATUS_T)
7531 elfcore_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7536 if (note
->descsz
== sizeof (prstatus_t
))
7540 size
= sizeof (prstat
.pr_reg
);
7541 offset
= offsetof (prstatus_t
, pr_reg
);
7542 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7544 /* Do not overwrite the core signal if it
7545 has already been set by another thread. */
7546 if (elf_tdata (abfd
)->core_signal
== 0)
7547 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7548 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7550 /* pr_who exists on:
7553 pr_who doesn't exist on:
7556 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7557 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7560 #if defined (HAVE_PRSTATUS32_T)
7561 else if (note
->descsz
== sizeof (prstatus32_t
))
7563 /* 64-bit host, 32-bit corefile */
7564 prstatus32_t prstat
;
7566 size
= sizeof (prstat
.pr_reg
);
7567 offset
= offsetof (prstatus32_t
, pr_reg
);
7568 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
7570 /* Do not overwrite the core signal if it
7571 has already been set by another thread. */
7572 if (elf_tdata (abfd
)->core_signal
== 0)
7573 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
7574 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
7576 /* pr_who exists on:
7579 pr_who doesn't exist on:
7582 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7583 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
7586 #endif /* HAVE_PRSTATUS32_T */
7589 /* Fail - we don't know how to handle any other
7590 note size (ie. data object type). */
7594 /* Make a ".reg/999" section and a ".reg" section. */
7595 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
7596 size
, note
->descpos
+ offset
);
7598 #endif /* defined (HAVE_PRSTATUS_T) */
7600 /* Create a pseudosection containing the exact contents of NOTE. */
7602 elfcore_make_note_pseudosection (bfd
*abfd
,
7604 Elf_Internal_Note
*note
)
7606 return _bfd_elfcore_make_pseudosection (abfd
, name
,
7607 note
->descsz
, note
->descpos
);
7610 /* There isn't a consistent prfpregset_t across platforms,
7611 but it doesn't matter, because we don't have to pick this
7612 data structure apart. */
7615 elfcore_grok_prfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7617 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
7620 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7621 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7625 elfcore_grok_prxfpreg (bfd
*abfd
, Elf_Internal_Note
*note
)
7627 return elfcore_make_note_pseudosection (abfd
, ".reg-xfp", note
);
7630 #if defined (HAVE_PRPSINFO_T)
7631 typedef prpsinfo_t elfcore_psinfo_t
;
7632 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7633 typedef prpsinfo32_t elfcore_psinfo32_t
;
7637 #if defined (HAVE_PSINFO_T)
7638 typedef psinfo_t elfcore_psinfo_t
;
7639 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7640 typedef psinfo32_t elfcore_psinfo32_t
;
7644 /* return a malloc'ed copy of a string at START which is at
7645 most MAX bytes long, possibly without a terminating '\0'.
7646 the copy will always have a terminating '\0'. */
7649 _bfd_elfcore_strndup (bfd
*abfd
, char *start
, size_t max
)
7652 char *end
= memchr (start
, '\0', max
);
7660 dups
= bfd_alloc (abfd
, len
+ 1);
7664 memcpy (dups
, start
, len
);
7670 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7672 elfcore_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
7674 if (note
->descsz
== sizeof (elfcore_psinfo_t
))
7676 elfcore_psinfo_t psinfo
;
7678 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7680 elf_tdata (abfd
)->core_program
7681 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7682 sizeof (psinfo
.pr_fname
));
7684 elf_tdata (abfd
)->core_command
7685 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7686 sizeof (psinfo
.pr_psargs
));
7688 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7689 else if (note
->descsz
== sizeof (elfcore_psinfo32_t
))
7691 /* 64-bit host, 32-bit corefile */
7692 elfcore_psinfo32_t psinfo
;
7694 memcpy (&psinfo
, note
->descdata
, sizeof (psinfo
));
7696 elf_tdata (abfd
)->core_program
7697 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_fname
,
7698 sizeof (psinfo
.pr_fname
));
7700 elf_tdata (abfd
)->core_command
7701 = _bfd_elfcore_strndup (abfd
, psinfo
.pr_psargs
,
7702 sizeof (psinfo
.pr_psargs
));
7708 /* Fail - we don't know how to handle any other
7709 note size (ie. data object type). */
7713 /* Note that for some reason, a spurious space is tacked
7714 onto the end of the args in some (at least one anyway)
7715 implementations, so strip it off if it exists. */
7718 char *command
= elf_tdata (abfd
)->core_command
;
7719 int n
= strlen (command
);
7721 if (0 < n
&& command
[n
- 1] == ' ')
7722 command
[n
- 1] = '\0';
7727 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7729 #if defined (HAVE_PSTATUS_T)
7731 elfcore_grok_pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7733 if (note
->descsz
== sizeof (pstatus_t
)
7734 #if defined (HAVE_PXSTATUS_T)
7735 || note
->descsz
== sizeof (pxstatus_t
)
7741 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7743 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7745 #if defined (HAVE_PSTATUS32_T)
7746 else if (note
->descsz
== sizeof (pstatus32_t
))
7748 /* 64-bit host, 32-bit corefile */
7751 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
7753 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
7756 /* Could grab some more details from the "representative"
7757 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7758 NT_LWPSTATUS note, presumably. */
7762 #endif /* defined (HAVE_PSTATUS_T) */
7764 #if defined (HAVE_LWPSTATUS_T)
7766 elfcore_grok_lwpstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7768 lwpstatus_t lwpstat
;
7774 if (note
->descsz
!= sizeof (lwpstat
)
7775 #if defined (HAVE_LWPXSTATUS_T)
7776 && note
->descsz
!= sizeof (lwpxstatus_t
)
7781 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
7783 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
7784 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
7786 /* Make a ".reg/999" section. */
7788 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
7789 len
= strlen (buf
) + 1;
7790 name
= bfd_alloc (abfd
, len
);
7793 memcpy (name
, buf
, len
);
7795 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7799 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7800 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
7801 sect
->filepos
= note
->descpos
7802 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
7805 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7806 sect
->size
= sizeof (lwpstat
.pr_reg
);
7807 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
7810 sect
->alignment_power
= 2;
7812 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7815 /* Make a ".reg2/999" section */
7817 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
7818 len
= strlen (buf
) + 1;
7819 name
= bfd_alloc (abfd
, len
);
7822 memcpy (name
, buf
, len
);
7824 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7828 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7829 sect
->size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
7830 sect
->filepos
= note
->descpos
7831 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
7834 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7835 sect
->size
= sizeof (lwpstat
.pr_fpreg
);
7836 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
7839 sect
->alignment_power
= 2;
7841 return elfcore_maybe_make_sect (abfd
, ".reg2", sect
);
7843 #endif /* defined (HAVE_LWPSTATUS_T) */
7845 #if defined (HAVE_WIN32_PSTATUS_T)
7847 elfcore_grok_win32pstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
7853 win32_pstatus_t pstatus
;
7855 if (note
->descsz
< sizeof (pstatus
))
7858 memcpy (&pstatus
, note
->descdata
, sizeof (pstatus
));
7860 switch (pstatus
.data_type
)
7862 case NOTE_INFO_PROCESS
:
7863 /* FIXME: need to add ->core_command. */
7864 elf_tdata (abfd
)->core_signal
= pstatus
.data
.process_info
.signal
;
7865 elf_tdata (abfd
)->core_pid
= pstatus
.data
.process_info
.pid
;
7868 case NOTE_INFO_THREAD
:
7869 /* Make a ".reg/999" section. */
7870 sprintf (buf
, ".reg/%ld", (long) pstatus
.data
.thread_info
.tid
);
7872 len
= strlen (buf
) + 1;
7873 name
= bfd_alloc (abfd
, len
);
7877 memcpy (name
, buf
, len
);
7879 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7883 sect
->size
= sizeof (pstatus
.data
.thread_info
.thread_context
);
7884 sect
->filepos
= (note
->descpos
7885 + offsetof (struct win32_pstatus
,
7886 data
.thread_info
.thread_context
));
7887 sect
->alignment_power
= 2;
7889 if (pstatus
.data
.thread_info
.is_active_thread
)
7890 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
7894 case NOTE_INFO_MODULE
:
7895 /* Make a ".module/xxxxxxxx" section. */
7896 sprintf (buf
, ".module/%08lx",
7897 (long) pstatus
.data
.module_info
.base_address
);
7899 len
= strlen (buf
) + 1;
7900 name
= bfd_alloc (abfd
, len
);
7904 memcpy (name
, buf
, len
);
7906 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
7911 sect
->size
= note
->descsz
;
7912 sect
->filepos
= note
->descpos
;
7913 sect
->alignment_power
= 2;
7922 #endif /* HAVE_WIN32_PSTATUS_T */
7925 elfcore_grok_note (bfd
*abfd
, Elf_Internal_Note
*note
)
7927 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
7935 if (bed
->elf_backend_grok_prstatus
)
7936 if ((*bed
->elf_backend_grok_prstatus
) (abfd
, note
))
7938 #if defined (HAVE_PRSTATUS_T)
7939 return elfcore_grok_prstatus (abfd
, note
);
7944 #if defined (HAVE_PSTATUS_T)
7946 return elfcore_grok_pstatus (abfd
, note
);
7949 #if defined (HAVE_LWPSTATUS_T)
7951 return elfcore_grok_lwpstatus (abfd
, note
);
7954 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
7955 return elfcore_grok_prfpreg (abfd
, note
);
7957 #if defined (HAVE_WIN32_PSTATUS_T)
7958 case NT_WIN32PSTATUS
:
7959 return elfcore_grok_win32pstatus (abfd
, note
);
7962 case NT_PRXFPREG
: /* Linux SSE extension */
7963 if (note
->namesz
== 6
7964 && strcmp (note
->namedata
, "LINUX") == 0)
7965 return elfcore_grok_prxfpreg (abfd
, note
);
7971 if (bed
->elf_backend_grok_psinfo
)
7972 if ((*bed
->elf_backend_grok_psinfo
) (abfd
, note
))
7974 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7975 return elfcore_grok_psinfo (abfd
, note
);
7982 asection
*sect
= bfd_make_section_anyway_with_flags (abfd
, ".auxv",
7987 sect
->size
= note
->descsz
;
7988 sect
->filepos
= note
->descpos
;
7989 sect
->alignment_power
= 1 + bfd_get_arch_size (abfd
) / 32;
7997 elfcore_netbsd_get_lwpid (Elf_Internal_Note
*note
, int *lwpidp
)
8001 cp
= strchr (note
->namedata
, '@');
8004 *lwpidp
= atoi(cp
+ 1);
8011 elfcore_grok_netbsd_procinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
8013 /* Signal number at offset 0x08. */
8014 elf_tdata (abfd
)->core_signal
8015 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x08);
8017 /* Process ID at offset 0x50. */
8018 elf_tdata (abfd
)->core_pid
8019 = bfd_h_get_32 (abfd
, (bfd_byte
*) note
->descdata
+ 0x50);
8021 /* Command name at 0x7c (max 32 bytes, including nul). */
8022 elf_tdata (abfd
)->core_command
8023 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 0x7c, 31);
8025 return elfcore_make_note_pseudosection (abfd
, ".note.netbsdcore.procinfo",
8030 elfcore_grok_netbsd_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8034 if (elfcore_netbsd_get_lwpid (note
, &lwp
))
8035 elf_tdata (abfd
)->core_lwpid
= lwp
;
8037 if (note
->type
== NT_NETBSDCORE_PROCINFO
)
8039 /* NetBSD-specific core "procinfo". Note that we expect to
8040 find this note before any of the others, which is fine,
8041 since the kernel writes this note out first when it
8042 creates a core file. */
8044 return elfcore_grok_netbsd_procinfo (abfd
, note
);
8047 /* As of Jan 2002 there are no other machine-independent notes
8048 defined for NetBSD core files. If the note type is less
8049 than the start of the machine-dependent note types, we don't
8052 if (note
->type
< NT_NETBSDCORE_FIRSTMACH
)
8056 switch (bfd_get_arch (abfd
))
8058 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8059 PT_GETFPREGS == mach+2. */
8061 case bfd_arch_alpha
:
8062 case bfd_arch_sparc
:
8065 case NT_NETBSDCORE_FIRSTMACH
+0:
8066 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8068 case NT_NETBSDCORE_FIRSTMACH
+2:
8069 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8075 /* On all other arch's, PT_GETREGS == mach+1 and
8076 PT_GETFPREGS == mach+3. */
8081 case NT_NETBSDCORE_FIRSTMACH
+1:
8082 return elfcore_make_note_pseudosection (abfd
, ".reg", note
);
8084 case NT_NETBSDCORE_FIRSTMACH
+3:
8085 return elfcore_make_note_pseudosection (abfd
, ".reg2", note
);
8095 elfcore_grok_nto_status (bfd
*abfd
, Elf_Internal_Note
*note
, long *tid
)
8097 void *ddata
= note
->descdata
;
8104 /* nto_procfs_status 'pid' field is at offset 0. */
8105 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
);
8107 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8108 *tid
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 4);
8110 /* nto_procfs_status 'flags' field is at offset 8. */
8111 flags
= bfd_get_32 (abfd
, (bfd_byte
*) ddata
+ 8);
8113 /* nto_procfs_status 'what' field is at offset 14. */
8114 if ((sig
= bfd_get_16 (abfd
, (bfd_byte
*) ddata
+ 14)) > 0)
8116 elf_tdata (abfd
)->core_signal
= sig
;
8117 elf_tdata (abfd
)->core_lwpid
= *tid
;
8120 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8121 do not come from signals so we make sure we set the current
8122 thread just in case. */
8123 if (flags
& 0x00000080)
8124 elf_tdata (abfd
)->core_lwpid
= *tid
;
8126 /* Make a ".qnx_core_status/%d" section. */
8127 sprintf (buf
, ".qnx_core_status/%ld", *tid
);
8129 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8134 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8138 sect
->size
= note
->descsz
;
8139 sect
->filepos
= note
->descpos
;
8140 sect
->alignment_power
= 2;
8142 return (elfcore_maybe_make_sect (abfd
, ".qnx_core_status", sect
));
8146 elfcore_grok_nto_regs (bfd
*abfd
,
8147 Elf_Internal_Note
*note
,
8155 /* Make a "(base)/%d" section. */
8156 sprintf (buf
, "%s/%ld", base
, tid
);
8158 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
8163 sect
= bfd_make_section_anyway_with_flags (abfd
, name
, SEC_HAS_CONTENTS
);
8167 sect
->size
= note
->descsz
;
8168 sect
->filepos
= note
->descpos
;
8169 sect
->alignment_power
= 2;
8171 /* This is the current thread. */
8172 if (elf_tdata (abfd
)->core_lwpid
== tid
)
8173 return elfcore_maybe_make_sect (abfd
, base
, sect
);
8178 #define BFD_QNT_CORE_INFO 7
8179 #define BFD_QNT_CORE_STATUS 8
8180 #define BFD_QNT_CORE_GREG 9
8181 #define BFD_QNT_CORE_FPREG 10
8184 elfcore_grok_nto_note (bfd
*abfd
, Elf_Internal_Note
*note
)
8186 /* Every GREG section has a STATUS section before it. Store the
8187 tid from the previous call to pass down to the next gregs
8189 static long tid
= 1;
8193 case BFD_QNT_CORE_INFO
:
8194 return elfcore_make_note_pseudosection (abfd
, ".qnx_core_info", note
);
8195 case BFD_QNT_CORE_STATUS
:
8196 return elfcore_grok_nto_status (abfd
, note
, &tid
);
8197 case BFD_QNT_CORE_GREG
:
8198 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg");
8199 case BFD_QNT_CORE_FPREG
:
8200 return elfcore_grok_nto_regs (abfd
, note
, tid
, ".reg2");
8206 /* Function: elfcore_write_note
8209 buffer to hold note, and current size of buffer
8213 size of data for note
8215 Writes note to end of buffer. ELF64 notes are written exactly as
8216 for ELF32, despite the current (as of 2006) ELF gabi specifying
8217 that they ought to have 8-byte namesz and descsz field, and have
8218 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8221 Pointer to realloc'd buffer, *BUFSIZ updated. */
8224 elfcore_write_note (bfd
*abfd
,
8232 Elf_External_Note
*xnp
;
8239 namesz
= strlen (name
) + 1;
8241 newspace
= 12 + ((namesz
+ 3) & -4) + ((size
+ 3) & -4);
8243 buf
= realloc (buf
, *bufsiz
+ newspace
);
8244 dest
= buf
+ *bufsiz
;
8245 *bufsiz
+= newspace
;
8246 xnp
= (Elf_External_Note
*) dest
;
8247 H_PUT_32 (abfd
, namesz
, xnp
->namesz
);
8248 H_PUT_32 (abfd
, size
, xnp
->descsz
);
8249 H_PUT_32 (abfd
, type
, xnp
->type
);
8253 memcpy (dest
, name
, namesz
);
8261 memcpy (dest
, input
, size
);
8271 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8273 elfcore_write_prpsinfo (bfd
*abfd
,
8279 const char *note_name
= "CORE";
8280 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8282 if (bed
->elf_backend_write_core_note
!= NULL
)
8285 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8286 NT_PRPSINFO
, fname
, psargs
);
8291 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8292 if (bed
->s
->elfclass
== ELFCLASS32
)
8294 #if defined (HAVE_PSINFO32_T)
8296 int note_type
= NT_PSINFO
;
8299 int note_type
= NT_PRPSINFO
;
8302 memset (&data
, 0, sizeof (data
));
8303 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8304 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8305 return elfcore_write_note (abfd
, buf
, bufsiz
,
8306 note_name
, note_type
, &data
, sizeof (data
));
8311 #if defined (HAVE_PSINFO_T)
8313 int note_type
= NT_PSINFO
;
8316 int note_type
= NT_PRPSINFO
;
8319 memset (&data
, 0, sizeof (data
));
8320 strncpy (data
.pr_fname
, fname
, sizeof (data
.pr_fname
));
8321 strncpy (data
.pr_psargs
, psargs
, sizeof (data
.pr_psargs
));
8322 return elfcore_write_note (abfd
, buf
, bufsiz
,
8323 note_name
, note_type
, &data
, sizeof (data
));
8326 #endif /* PSINFO_T or PRPSINFO_T */
8328 #if defined (HAVE_PRSTATUS_T)
8330 elfcore_write_prstatus (bfd
*abfd
,
8337 const char *note_name
= "CORE";
8338 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8340 if (bed
->elf_backend_write_core_note
!= NULL
)
8343 ret
= (*bed
->elf_backend_write_core_note
) (abfd
, buf
, bufsiz
,
8345 pid
, cursig
, gregs
);
8350 #if defined (HAVE_PRSTATUS32_T)
8351 if (bed
->s
->elfclass
== ELFCLASS32
)
8353 prstatus32_t prstat
;
8355 memset (&prstat
, 0, sizeof (prstat
));
8356 prstat
.pr_pid
= pid
;
8357 prstat
.pr_cursig
= cursig
;
8358 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8359 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8360 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8367 memset (&prstat
, 0, sizeof (prstat
));
8368 prstat
.pr_pid
= pid
;
8369 prstat
.pr_cursig
= cursig
;
8370 memcpy (&prstat
.pr_reg
, gregs
, sizeof (prstat
.pr_reg
));
8371 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8372 NT_PRSTATUS
, &prstat
, sizeof (prstat
));
8375 #endif /* HAVE_PRSTATUS_T */
8377 #if defined (HAVE_LWPSTATUS_T)
8379 elfcore_write_lwpstatus (bfd
*abfd
,
8386 lwpstatus_t lwpstat
;
8387 const char *note_name
= "CORE";
8389 memset (&lwpstat
, 0, sizeof (lwpstat
));
8390 lwpstat
.pr_lwpid
= pid
>> 16;
8391 lwpstat
.pr_cursig
= cursig
;
8392 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8393 memcpy (lwpstat
.pr_reg
, gregs
, sizeof (lwpstat
.pr_reg
));
8394 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8396 memcpy (lwpstat
.pr_context
.uc_mcontext
.gregs
,
8397 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
));
8399 memcpy (lwpstat
.pr_context
.uc_mcontext
.__gregs
,
8400 gregs
, sizeof (lwpstat
.pr_context
.uc_mcontext
.__gregs
));
8403 return elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8404 NT_LWPSTATUS
, &lwpstat
, sizeof (lwpstat
));
8406 #endif /* HAVE_LWPSTATUS_T */
8408 #if defined (HAVE_PSTATUS_T)
8410 elfcore_write_pstatus (bfd
*abfd
,
8414 int cursig ATTRIBUTE_UNUSED
,
8415 const void *gregs ATTRIBUTE_UNUSED
)
8417 const char *note_name
= "CORE";
8418 #if defined (HAVE_PSTATUS32_T)
8419 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8421 if (bed
->s
->elfclass
== ELFCLASS32
)
8425 memset (&pstat
, 0, sizeof (pstat
));
8426 pstat
.pr_pid
= pid
& 0xffff;
8427 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8428 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8436 memset (&pstat
, 0, sizeof (pstat
));
8437 pstat
.pr_pid
= pid
& 0xffff;
8438 buf
= elfcore_write_note (abfd
, buf
, bufsiz
, note_name
,
8439 NT_PSTATUS
, &pstat
, sizeof (pstat
));
8443 #endif /* HAVE_PSTATUS_T */
8446 elfcore_write_prfpreg (bfd
*abfd
,
8452 const char *note_name
= "CORE";
8453 return elfcore_write_note (abfd
, buf
, bufsiz
,
8454 note_name
, NT_FPREGSET
, fpregs
, size
);
8458 elfcore_write_prxfpreg (bfd
*abfd
,
8461 const void *xfpregs
,
8464 char *note_name
= "LINUX";
8465 return elfcore_write_note (abfd
, buf
, bufsiz
,
8466 note_name
, NT_PRXFPREG
, xfpregs
, size
);
8470 elfcore_read_notes (bfd
*abfd
, file_ptr offset
, bfd_size_type size
)
8478 if (bfd_seek (abfd
, offset
, SEEK_SET
) != 0)
8481 buf
= bfd_malloc (size
);
8485 if (bfd_bread (buf
, size
, abfd
) != size
)
8493 while (p
< buf
+ size
)
8495 /* FIXME: bad alignment assumption. */
8496 Elf_External_Note
*xnp
= (Elf_External_Note
*) p
;
8497 Elf_Internal_Note in
;
8499 in
.type
= H_GET_32 (abfd
, xnp
->type
);
8501 in
.namesz
= H_GET_32 (abfd
, xnp
->namesz
);
8502 in
.namedata
= xnp
->name
;
8504 in
.descsz
= H_GET_32 (abfd
, xnp
->descsz
);
8505 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
8506 in
.descpos
= offset
+ (in
.descdata
- buf
);
8508 if (CONST_STRNEQ (in
.namedata
, "NetBSD-CORE"))
8510 if (! elfcore_grok_netbsd_note (abfd
, &in
))
8513 else if (CONST_STRNEQ (in
.namedata
, "QNX"))
8515 if (! elfcore_grok_nto_note (abfd
, &in
))
8520 if (! elfcore_grok_note (abfd
, &in
))
8524 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
8531 /* Providing external access to the ELF program header table. */
8533 /* Return an upper bound on the number of bytes required to store a
8534 copy of ABFD's program header table entries. Return -1 if an error
8535 occurs; bfd_get_error will return an appropriate code. */
8538 bfd_get_elf_phdr_upper_bound (bfd
*abfd
)
8540 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8542 bfd_set_error (bfd_error_wrong_format
);
8546 return elf_elfheader (abfd
)->e_phnum
* sizeof (Elf_Internal_Phdr
);
8549 /* Copy ABFD's program header table entries to *PHDRS. The entries
8550 will be stored as an array of Elf_Internal_Phdr structures, as
8551 defined in include/elf/internal.h. To find out how large the
8552 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8554 Return the number of program header table entries read, or -1 if an
8555 error occurs; bfd_get_error will return an appropriate code. */
8558 bfd_get_elf_phdrs (bfd
*abfd
, void *phdrs
)
8562 if (abfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
8564 bfd_set_error (bfd_error_wrong_format
);
8568 num_phdrs
= elf_elfheader (abfd
)->e_phnum
;
8569 memcpy (phdrs
, elf_tdata (abfd
)->phdr
,
8570 num_phdrs
* sizeof (Elf_Internal_Phdr
));
8576 _bfd_elf_sprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, char *buf
, bfd_vma value
)
8579 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
8581 i_ehdrp
= elf_elfheader (abfd
);
8582 if (i_ehdrp
== NULL
)
8583 sprintf_vma (buf
, value
);
8586 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
8588 #if BFD_HOST_64BIT_LONG
8589 sprintf (buf
, "%016lx", value
);
8591 sprintf (buf
, "%08lx%08lx", _bfd_int64_high (value
),
8592 _bfd_int64_low (value
));
8596 sprintf (buf
, "%08lx", (unsigned long) (value
& 0xffffffff));
8599 sprintf_vma (buf
, value
);
8604 _bfd_elf_fprintf_vma (bfd
*abfd ATTRIBUTE_UNUSED
, void *stream
, bfd_vma value
)
8607 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
8609 i_ehdrp
= elf_elfheader (abfd
);
8610 if (i_ehdrp
== NULL
)
8611 fprintf_vma ((FILE *) stream
, value
);
8614 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
8616 #if BFD_HOST_64BIT_LONG
8617 fprintf ((FILE *) stream
, "%016lx", value
);
8619 fprintf ((FILE *) stream
, "%08lx%08lx",
8620 _bfd_int64_high (value
), _bfd_int64_low (value
));
8624 fprintf ((FILE *) stream
, "%08lx",
8625 (unsigned long) (value
& 0xffffffff));
8628 fprintf_vma ((FILE *) stream
, value
);
8632 enum elf_reloc_type_class
8633 _bfd_elf_reloc_type_class (const Elf_Internal_Rela
*rela ATTRIBUTE_UNUSED
)
8635 return reloc_class_normal
;
8638 /* For RELA architectures, return the relocation value for a
8639 relocation against a local symbol. */
8642 _bfd_elf_rela_local_sym (bfd
*abfd
,
8643 Elf_Internal_Sym
*sym
,
8645 Elf_Internal_Rela
*rel
)
8647 asection
*sec
= *psec
;
8650 relocation
= (sec
->output_section
->vma
8651 + sec
->output_offset
8653 if ((sec
->flags
& SEC_MERGE
)
8654 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
8655 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
8658 _bfd_merged_section_offset (abfd
, psec
,
8659 elf_section_data (sec
)->sec_info
,
8660 sym
->st_value
+ rel
->r_addend
);
8663 /* If we have changed the section, and our original section is
8664 marked with SEC_EXCLUDE, it means that the original
8665 SEC_MERGE section has been completely subsumed in some
8666 other SEC_MERGE section. In this case, we need to leave
8667 some info around for --emit-relocs. */
8668 if ((sec
->flags
& SEC_EXCLUDE
) != 0)
8669 sec
->kept_section
= *psec
;
8672 rel
->r_addend
-= relocation
;
8673 rel
->r_addend
+= sec
->output_section
->vma
+ sec
->output_offset
;
8679 _bfd_elf_rel_local_sym (bfd
*abfd
,
8680 Elf_Internal_Sym
*sym
,
8684 asection
*sec
= *psec
;
8686 if (sec
->sec_info_type
!= ELF_INFO_TYPE_MERGE
)
8687 return sym
->st_value
+ addend
;
8689 return _bfd_merged_section_offset (abfd
, psec
,
8690 elf_section_data (sec
)->sec_info
,
8691 sym
->st_value
+ addend
);
8695 _bfd_elf_section_offset (bfd
*abfd
,
8696 struct bfd_link_info
*info
,
8700 switch (sec
->sec_info_type
)
8702 case ELF_INFO_TYPE_STABS
:
8703 return _bfd_stab_section_offset (sec
, elf_section_data (sec
)->sec_info
,
8705 case ELF_INFO_TYPE_EH_FRAME
:
8706 return _bfd_elf_eh_frame_section_offset (abfd
, info
, sec
, offset
);
8712 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8713 reconstruct an ELF file by reading the segments out of remote memory
8714 based on the ELF file header at EHDR_VMA and the ELF program headers it
8715 points to. If not null, *LOADBASEP is filled in with the difference
8716 between the VMAs from which the segments were read, and the VMAs the
8717 file headers (and hence BFD's idea of each section's VMA) put them at.
8719 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8720 remote memory at target address VMA into the local buffer at MYADDR; it
8721 should return zero on success or an `errno' code on failure. TEMPL must
8722 be a BFD for an ELF target with the word size and byte order found in
8723 the remote memory. */
8726 bfd_elf_bfd_from_remote_memory
8730 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
8732 return (*get_elf_backend_data (templ
)->elf_backend_bfd_from_remote_memory
)
8733 (templ
, ehdr_vma
, loadbasep
, target_read_memory
);
8737 _bfd_elf_get_synthetic_symtab (bfd
*abfd
,
8738 long symcount ATTRIBUTE_UNUSED
,
8739 asymbol
**syms ATTRIBUTE_UNUSED
,
8744 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
8747 const char *relplt_name
;
8748 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
8752 Elf_Internal_Shdr
*hdr
;
8758 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == 0)
8761 if (dynsymcount
<= 0)
8764 if (!bed
->plt_sym_val
)
8767 relplt_name
= bed
->relplt_name
;
8768 if (relplt_name
== NULL
)
8769 relplt_name
= bed
->default_use_rela_p
? ".rela.plt" : ".rel.plt";
8770 relplt
= bfd_get_section_by_name (abfd
, relplt_name
);
8774 hdr
= &elf_section_data (relplt
)->this_hdr
;
8775 if (hdr
->sh_link
!= elf_dynsymtab (abfd
)
8776 || (hdr
->sh_type
!= SHT_REL
&& hdr
->sh_type
!= SHT_RELA
))
8779 plt
= bfd_get_section_by_name (abfd
, ".plt");
8783 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
8784 if (! (*slurp_relocs
) (abfd
, relplt
, dynsyms
, TRUE
))
8787 count
= relplt
->size
/ hdr
->sh_entsize
;
8788 size
= count
* sizeof (asymbol
);
8789 p
= relplt
->relocation
;
8790 for (i
= 0; i
< count
; i
++, s
++, p
++)
8791 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
8793 s
= *ret
= bfd_malloc (size
);
8797 names
= (char *) (s
+ count
);
8798 p
= relplt
->relocation
;
8800 for (i
= 0; i
< count
; i
++, s
++, p
++)
8805 addr
= bed
->plt_sym_val (i
, plt
, p
);
8806 if (addr
== (bfd_vma
) -1)
8809 *s
= **p
->sym_ptr_ptr
;
8810 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8811 we are defining a symbol, ensure one of them is set. */
8812 if ((s
->flags
& BSF_LOCAL
) == 0)
8813 s
->flags
|= BSF_GLOBAL
;
8815 s
->value
= addr
- plt
->vma
;
8817 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
8818 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
8820 memcpy (names
, "@plt", sizeof ("@plt"));
8821 names
+= sizeof ("@plt");
8828 struct elf_symbuf_symbol
8830 unsigned long st_name
; /* Symbol name, index in string tbl */
8831 unsigned char st_info
; /* Type and binding attributes */
8832 unsigned char st_other
; /* Visibilty, and target specific */
8835 struct elf_symbuf_head
8837 struct elf_symbuf_symbol
*ssym
;
8838 bfd_size_type count
;
8839 unsigned int st_shndx
;
8846 Elf_Internal_Sym
*isym
;
8847 struct elf_symbuf_symbol
*ssym
;
8852 /* Sort references to symbols by ascending section number. */
8855 elf_sort_elf_symbol (const void *arg1
, const void *arg2
)
8857 const Elf_Internal_Sym
*s1
= *(const Elf_Internal_Sym
**) arg1
;
8858 const Elf_Internal_Sym
*s2
= *(const Elf_Internal_Sym
**) arg2
;
8860 return s1
->st_shndx
- s2
->st_shndx
;
8864 elf_sym_name_compare (const void *arg1
, const void *arg2
)
8866 const struct elf_symbol
*s1
= (const struct elf_symbol
*) arg1
;
8867 const struct elf_symbol
*s2
= (const struct elf_symbol
*) arg2
;
8868 return strcmp (s1
->name
, s2
->name
);
8871 static struct elf_symbuf_head
*
8872 elf_create_symbuf (bfd_size_type symcount
, Elf_Internal_Sym
*isymbuf
)
8874 Elf_Internal_Sym
**ind
, **indbufend
, **indbuf
8875 = bfd_malloc2 (symcount
, sizeof (*indbuf
));
8876 struct elf_symbuf_symbol
*ssym
;
8877 struct elf_symbuf_head
*ssymbuf
, *ssymhead
;
8878 bfd_size_type i
, shndx_count
;
8883 for (ind
= indbuf
, i
= 0; i
< symcount
; i
++)
8884 if (isymbuf
[i
].st_shndx
!= SHN_UNDEF
)
8885 *ind
++ = &isymbuf
[i
];
8888 qsort (indbuf
, indbufend
- indbuf
, sizeof (Elf_Internal_Sym
*),
8889 elf_sort_elf_symbol
);
8892 if (indbufend
> indbuf
)
8893 for (ind
= indbuf
, shndx_count
++; ind
< indbufend
- 1; ind
++)
8894 if (ind
[0]->st_shndx
!= ind
[1]->st_shndx
)
8897 ssymbuf
= bfd_malloc ((shndx_count
+ 1) * sizeof (*ssymbuf
)
8898 + (indbufend
- indbuf
) * sizeof (*ssymbuf
));
8899 if (ssymbuf
== NULL
)
8905 ssym
= (struct elf_symbuf_symbol
*) (ssymbuf
+ shndx_count
);
8906 ssymbuf
->ssym
= NULL
;
8907 ssymbuf
->count
= shndx_count
;
8908 ssymbuf
->st_shndx
= 0;
8909 for (ssymhead
= ssymbuf
, ind
= indbuf
; ind
< indbufend
; ssym
++, ind
++)
8911 if (ind
== indbuf
|| ssymhead
->st_shndx
!= (*ind
)->st_shndx
)
8914 ssymhead
->ssym
= ssym
;
8915 ssymhead
->count
= 0;
8916 ssymhead
->st_shndx
= (*ind
)->st_shndx
;
8918 ssym
->st_name
= (*ind
)->st_name
;
8919 ssym
->st_info
= (*ind
)->st_info
;
8920 ssym
->st_other
= (*ind
)->st_other
;
8923 BFD_ASSERT ((bfd_size_type
) (ssymhead
- ssymbuf
) == shndx_count
);
8929 /* Check if 2 sections define the same set of local and global
8933 bfd_elf_match_symbols_in_sections (asection
*sec1
, asection
*sec2
,
8934 struct bfd_link_info
*info
)
8937 const struct elf_backend_data
*bed1
, *bed2
;
8938 Elf_Internal_Shdr
*hdr1
, *hdr2
;
8939 bfd_size_type symcount1
, symcount2
;
8940 Elf_Internal_Sym
*isymbuf1
, *isymbuf2
;
8941 struct elf_symbuf_head
*ssymbuf1
, *ssymbuf2
;
8942 Elf_Internal_Sym
*isym
, *isymend
;
8943 struct elf_symbol
*symtable1
= NULL
, *symtable2
= NULL
;
8944 bfd_size_type count1
, count2
, i
;
8951 /* If both are .gnu.linkonce sections, they have to have the same
8953 if (CONST_STRNEQ (sec1
->name
, ".gnu.linkonce")
8954 && CONST_STRNEQ (sec2
->name
, ".gnu.linkonce"))
8955 return strcmp (sec1
->name
+ sizeof ".gnu.linkonce",
8956 sec2
->name
+ sizeof ".gnu.linkonce") == 0;
8958 /* Both sections have to be in ELF. */
8959 if (bfd_get_flavour (bfd1
) != bfd_target_elf_flavour
8960 || bfd_get_flavour (bfd2
) != bfd_target_elf_flavour
)
8963 if (elf_section_type (sec1
) != elf_section_type (sec2
))
8966 if ((elf_section_flags (sec1
) & SHF_GROUP
) != 0
8967 && (elf_section_flags (sec2
) & SHF_GROUP
) != 0)
8969 /* If both are members of section groups, they have to have the
8971 if (strcmp (elf_group_name (sec1
), elf_group_name (sec2
)) != 0)
8975 shndx1
= _bfd_elf_section_from_bfd_section (bfd1
, sec1
);
8976 shndx2
= _bfd_elf_section_from_bfd_section (bfd2
, sec2
);
8977 if (shndx1
== -1 || shndx2
== -1)
8980 bed1
= get_elf_backend_data (bfd1
);
8981 bed2
= get_elf_backend_data (bfd2
);
8982 hdr1
= &elf_tdata (bfd1
)->symtab_hdr
;
8983 symcount1
= hdr1
->sh_size
/ bed1
->s
->sizeof_sym
;
8984 hdr2
= &elf_tdata (bfd2
)->symtab_hdr
;
8985 symcount2
= hdr2
->sh_size
/ bed2
->s
->sizeof_sym
;
8987 if (symcount1
== 0 || symcount2
== 0)
8993 ssymbuf1
= elf_tdata (bfd1
)->symbuf
;
8994 ssymbuf2
= elf_tdata (bfd2
)->symbuf
;
8996 if (ssymbuf1
== NULL
)
8998 isymbuf1
= bfd_elf_get_elf_syms (bfd1
, hdr1
, symcount1
, 0,
9000 if (isymbuf1
== NULL
)
9003 if (!info
->reduce_memory_overheads
)
9004 elf_tdata (bfd1
)->symbuf
= ssymbuf1
9005 = elf_create_symbuf (symcount1
, isymbuf1
);
9008 if (ssymbuf1
== NULL
|| ssymbuf2
== NULL
)
9010 isymbuf2
= bfd_elf_get_elf_syms (bfd2
, hdr2
, symcount2
, 0,
9012 if (isymbuf2
== NULL
)
9015 if (ssymbuf1
!= NULL
&& !info
->reduce_memory_overheads
)
9016 elf_tdata (bfd2
)->symbuf
= ssymbuf2
9017 = elf_create_symbuf (symcount2
, isymbuf2
);
9020 if (ssymbuf1
!= NULL
&& ssymbuf2
!= NULL
)
9022 /* Optimized faster version. */
9023 bfd_size_type lo
, hi
, mid
;
9024 struct elf_symbol
*symp
;
9025 struct elf_symbuf_symbol
*ssym
, *ssymend
;
9028 hi
= ssymbuf1
->count
;
9033 mid
= (lo
+ hi
) / 2;
9034 if ((unsigned int) shndx1
< ssymbuf1
[mid
].st_shndx
)
9036 else if ((unsigned int) shndx1
> ssymbuf1
[mid
].st_shndx
)
9040 count1
= ssymbuf1
[mid
].count
;
9047 hi
= ssymbuf2
->count
;
9052 mid
= (lo
+ hi
) / 2;
9053 if ((unsigned int) shndx2
< ssymbuf2
[mid
].st_shndx
)
9055 else if ((unsigned int) shndx2
> ssymbuf2
[mid
].st_shndx
)
9059 count2
= ssymbuf2
[mid
].count
;
9065 if (count1
== 0 || count2
== 0 || count1
!= count2
)
9068 symtable1
= bfd_malloc (count1
* sizeof (struct elf_symbol
));
9069 symtable2
= bfd_malloc (count2
* sizeof (struct elf_symbol
));
9070 if (symtable1
== NULL
|| symtable2
== NULL
)
9074 for (ssym
= ssymbuf1
->ssym
, ssymend
= ssym
+ count1
;
9075 ssym
< ssymend
; ssym
++, symp
++)
9077 symp
->u
.ssym
= ssym
;
9078 symp
->name
= bfd_elf_string_from_elf_section (bfd1
,
9084 for (ssym
= ssymbuf2
->ssym
, ssymend
= ssym
+ count2
;
9085 ssym
< ssymend
; ssym
++, symp
++)
9087 symp
->u
.ssym
= ssym
;
9088 symp
->name
= bfd_elf_string_from_elf_section (bfd2
,
9093 /* Sort symbol by name. */
9094 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
9095 elf_sym_name_compare
);
9096 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
9097 elf_sym_name_compare
);
9099 for (i
= 0; i
< count1
; i
++)
9100 /* Two symbols must have the same binding, type and name. */
9101 if (symtable1
[i
].u
.ssym
->st_info
!= symtable2
[i
].u
.ssym
->st_info
9102 || symtable1
[i
].u
.ssym
->st_other
!= symtable2
[i
].u
.ssym
->st_other
9103 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
9110 symtable1
= bfd_malloc (symcount1
* sizeof (struct elf_symbol
));
9111 symtable2
= bfd_malloc (symcount2
* sizeof (struct elf_symbol
));
9112 if (symtable1
== NULL
|| symtable2
== NULL
)
9115 /* Count definitions in the section. */
9117 for (isym
= isymbuf1
, isymend
= isym
+ symcount1
; isym
< isymend
; isym
++)
9118 if (isym
->st_shndx
== (unsigned int) shndx1
)
9119 symtable1
[count1
++].u
.isym
= isym
;
9122 for (isym
= isymbuf2
, isymend
= isym
+ symcount2
; isym
< isymend
; isym
++)
9123 if (isym
->st_shndx
== (unsigned int) shndx2
)
9124 symtable2
[count2
++].u
.isym
= isym
;
9126 if (count1
== 0 || count2
== 0 || count1
!= count2
)
9129 for (i
= 0; i
< count1
; i
++)
9131 = bfd_elf_string_from_elf_section (bfd1
, hdr1
->sh_link
,
9132 symtable1
[i
].u
.isym
->st_name
);
9134 for (i
= 0; i
< count2
; i
++)
9136 = bfd_elf_string_from_elf_section (bfd2
, hdr2
->sh_link
,
9137 symtable2
[i
].u
.isym
->st_name
);
9139 /* Sort symbol by name. */
9140 qsort (symtable1
, count1
, sizeof (struct elf_symbol
),
9141 elf_sym_name_compare
);
9142 qsort (symtable2
, count1
, sizeof (struct elf_symbol
),
9143 elf_sym_name_compare
);
9145 for (i
= 0; i
< count1
; i
++)
9146 /* Two symbols must have the same binding, type and name. */
9147 if (symtable1
[i
].u
.isym
->st_info
!= symtable2
[i
].u
.isym
->st_info
9148 || symtable1
[i
].u
.isym
->st_other
!= symtable2
[i
].u
.isym
->st_other
9149 || strcmp (symtable1
[i
].name
, symtable2
[i
].name
) != 0)
9167 /* It is only used by x86-64 so far. */
9168 asection _bfd_elf_large_com_section
9169 = BFD_FAKE_SECTION (_bfd_elf_large_com_section
,
9170 SEC_IS_COMMON
, NULL
, "LARGE_COMMON", 0);
9172 /* Return TRUE if 2 section types are compatible. */
9175 _bfd_elf_match_sections_by_type (bfd
*abfd
, const asection
*asec
,
9176 bfd
*bbfd
, const asection
*bsec
)
9180 || abfd
->xvec
->flavour
!= bfd_target_elf_flavour
9181 || bbfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
9184 return elf_section_type (asec
) == elf_section_type (bsec
);
9188 _bfd_elf_set_osabi (bfd
* abfd
,
9189 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
)
9191 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
9193 i_ehdrp
= elf_elfheader (abfd
);
9195 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
9199 /* Return TRUE for ELF symbol types that represent functions.
9200 This is the default version of this function, which is sufficient for
9201 most targets. It returns true if TYPE is STT_FUNC. */
9204 _bfd_elf_is_function_type (unsigned int type
)
9206 return (type
== STT_FUNC
);