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 2 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, MA 02110-1301, USA. */
26 BFD support for ELF formats is being worked on.
27 Currently, the best supported back ends are for sparc and i386
28 (running svr4 or Solaris 2).
30 Documentation of the internals of the support code still needs
31 to be written. The code is changing quickly enough that we
32 haven't bothered yet. */
34 /* For sparc64-cross-sparc32. */
42 #include "libiberty.h"
44 static int elf_sort_sections (const void *, const void *);
45 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
46 static bfd_boolean prep_headers (bfd *);
47 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
48 static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
50 /* Swap version information in and out. The version information is
51 currently size independent. If that ever changes, this code will
52 need to move into elfcode.h. */
54 /* Swap in a Verdef structure. */
57 _bfd_elf_swap_verdef_in (bfd *abfd,
58 const Elf_External_Verdef *src,
59 Elf_Internal_Verdef *dst)
61 dst->vd_version = H_GET_16 (abfd, src->vd_version);
62 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
63 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
64 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
65 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
66 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
67 dst->vd_next = H_GET_32 (abfd, src->vd_next);
70 /* Swap out a Verdef structure. */
73 _bfd_elf_swap_verdef_out (bfd *abfd,
74 const Elf_Internal_Verdef *src,
75 Elf_External_Verdef *dst)
77 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
78 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
79 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
80 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
81 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
82 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
83 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
86 /* Swap in a Verdaux structure. */
89 _bfd_elf_swap_verdaux_in (bfd *abfd,
90 const Elf_External_Verdaux *src,
91 Elf_Internal_Verdaux *dst)
93 dst->vda_name = H_GET_32 (abfd, src->vda_name);
94 dst->vda_next = H_GET_32 (abfd, src->vda_next);
97 /* Swap out a Verdaux structure. */
100 _bfd_elf_swap_verdaux_out (bfd *abfd,
101 const Elf_Internal_Verdaux *src,
102 Elf_External_Verdaux *dst)
104 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
105 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
108 /* Swap in a Verneed structure. */
111 _bfd_elf_swap_verneed_in (bfd *abfd,
112 const Elf_External_Verneed *src,
113 Elf_Internal_Verneed *dst)
115 dst->vn_version = H_GET_16 (abfd, src->vn_version);
116 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
117 dst->vn_file = H_GET_32 (abfd, src->vn_file);
118 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
119 dst->vn_next = H_GET_32 (abfd, src->vn_next);
122 /* Swap out a Verneed structure. */
125 _bfd_elf_swap_verneed_out (bfd *abfd,
126 const Elf_Internal_Verneed *src,
127 Elf_External_Verneed *dst)
129 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
130 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
131 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
132 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
133 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
136 /* Swap in a Vernaux structure. */
139 _bfd_elf_swap_vernaux_in (bfd *abfd,
140 const Elf_External_Vernaux *src,
141 Elf_Internal_Vernaux *dst)
143 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
144 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
145 dst->vna_other = H_GET_16 (abfd, src->vna_other);
146 dst->vna_name = H_GET_32 (abfd, src->vna_name);
147 dst->vna_next = H_GET_32 (abfd, src->vna_next);
150 /* Swap out a Vernaux structure. */
153 _bfd_elf_swap_vernaux_out (bfd *abfd,
154 const Elf_Internal_Vernaux *src,
155 Elf_External_Vernaux *dst)
157 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
158 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
159 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
160 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
161 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
164 /* Swap in a Versym structure. */
167 _bfd_elf_swap_versym_in (bfd *abfd,
168 const Elf_External_Versym *src,
169 Elf_Internal_Versym *dst)
171 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
174 /* Swap out a Versym structure. */
177 _bfd_elf_swap_versym_out (bfd *abfd,
178 const Elf_Internal_Versym *src,
179 Elf_External_Versym *dst)
181 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
184 /* Standard ELF hash function. Do not change this function; you will
185 cause invalid hash tables to be generated. */
188 bfd_elf_hash (const char *namearg)
190 const unsigned char *name = (const unsigned char *) namearg;
195 while ((ch = *name++) != '\0')
198 if ((g = (h & 0xf0000000)) != 0)
201 /* The ELF ABI says `h &= ~g', but this is equivalent in
202 this case and on some machines one insn instead of two. */
206 return h & 0xffffffff;
209 /* DT_GNU_HASH hash function. Do not change this function; you will
210 cause invalid hash tables to be generated. */
213 bfd_elf_gnu_hash (const char *namearg)
215 const unsigned char *name = (const unsigned char *) namearg;
216 unsigned long h = 5381;
219 while ((ch = *name++) != '\0')
220 h = (h << 5) + h + ch;
221 return h & 0xffffffff;
225 bfd_elf_mkobject (bfd *abfd)
227 if (abfd->tdata.any == NULL)
229 abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
230 if (abfd->tdata.any == NULL)
234 elf_tdata (abfd)->program_header_size = (bfd_size_type) -1;
240 bfd_elf_mkcorefile (bfd *abfd)
242 /* I think this can be done just like an object file. */
243 return bfd_elf_mkobject (abfd);
247 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
249 Elf_Internal_Shdr **i_shdrp;
250 bfd_byte *shstrtab = NULL;
252 bfd_size_type shstrtabsize;
254 i_shdrp = elf_elfsections (abfd);
256 || shindex >= elf_numsections (abfd)
257 || i_shdrp[shindex] == 0)
260 shstrtab = i_shdrp[shindex]->contents;
261 if (shstrtab == NULL)
263 /* No cached one, attempt to read, and cache what we read. */
264 offset = i_shdrp[shindex]->sh_offset;
265 shstrtabsize = i_shdrp[shindex]->sh_size;
267 /* Allocate and clear an extra byte at the end, to prevent crashes
268 in case the string table is not terminated. */
269 if (shstrtabsize + 1 == 0
270 || (shstrtab = bfd_alloc (abfd, shstrtabsize + 1)) == NULL
271 || bfd_seek (abfd, offset, SEEK_SET) != 0)
273 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
275 if (bfd_get_error () != bfd_error_system_call)
276 bfd_set_error (bfd_error_file_truncated);
280 shstrtab[shstrtabsize] = '\0';
281 i_shdrp[shindex]->contents = shstrtab;
283 return (char *) shstrtab;
287 bfd_elf_string_from_elf_section (bfd *abfd,
288 unsigned int shindex,
289 unsigned int strindex)
291 Elf_Internal_Shdr *hdr;
296 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
299 hdr = elf_elfsections (abfd)[shindex];
301 if (hdr->contents == NULL
302 && bfd_elf_get_str_section (abfd, shindex) == NULL)
305 if (strindex >= hdr->sh_size)
307 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
308 (*_bfd_error_handler)
309 (_("%B: invalid string offset %u >= %lu for section `%s'"),
310 abfd, strindex, (unsigned long) hdr->sh_size,
311 (shindex == shstrndx && strindex == hdr->sh_name
313 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
317 return ((char *) hdr->contents) + strindex;
320 /* Read and convert symbols to internal format.
321 SYMCOUNT specifies the number of symbols to read, starting from
322 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
323 are non-NULL, they are used to store the internal symbols, external
324 symbols, and symbol section index extensions, respectively. */
327 bfd_elf_get_elf_syms (bfd *ibfd,
328 Elf_Internal_Shdr *symtab_hdr,
331 Elf_Internal_Sym *intsym_buf,
333 Elf_External_Sym_Shndx *extshndx_buf)
335 Elf_Internal_Shdr *shndx_hdr;
337 const bfd_byte *esym;
338 Elf_External_Sym_Shndx *alloc_extshndx;
339 Elf_External_Sym_Shndx *shndx;
340 Elf_Internal_Sym *isym;
341 Elf_Internal_Sym *isymend;
342 const struct elf_backend_data *bed;
350 /* Normal syms might have section extension entries. */
352 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
353 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
355 /* Read the symbols. */
357 alloc_extshndx = NULL;
358 bed = get_elf_backend_data (ibfd);
359 extsym_size = bed->s->sizeof_sym;
360 amt = symcount * extsym_size;
361 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
362 if (extsym_buf == NULL)
364 alloc_ext = bfd_malloc2 (symcount, extsym_size);
365 extsym_buf = alloc_ext;
367 if (extsym_buf == NULL
368 || bfd_seek (ibfd, pos, SEEK_SET) != 0
369 || bfd_bread (extsym_buf, amt, ibfd) != amt)
375 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
379 amt = symcount * sizeof (Elf_External_Sym_Shndx);
380 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
381 if (extshndx_buf == NULL)
383 alloc_extshndx = bfd_malloc2 (symcount,
384 sizeof (Elf_External_Sym_Shndx));
385 extshndx_buf = alloc_extshndx;
387 if (extshndx_buf == NULL
388 || bfd_seek (ibfd, pos, SEEK_SET) != 0
389 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
396 if (intsym_buf == NULL)
398 intsym_buf = bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
399 if (intsym_buf == NULL)
403 /* Convert the symbols to internal form. */
404 isymend = intsym_buf + symcount;
405 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
407 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
408 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
410 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
411 (*_bfd_error_handler) (_("%B symbol number %lu references "
412 "nonexistent SHT_SYMTAB_SHNDX section"),
413 ibfd, (unsigned long) symoffset);
419 if (alloc_ext != NULL)
421 if (alloc_extshndx != NULL)
422 free (alloc_extshndx);
427 /* Look up a symbol name. */
429 bfd_elf_sym_name (bfd *abfd,
430 Elf_Internal_Shdr *symtab_hdr,
431 Elf_Internal_Sym *isym,
435 unsigned int iname = isym->st_name;
436 unsigned int shindex = symtab_hdr->sh_link;
438 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
439 /* Check for a bogus st_shndx to avoid crashing. */
440 && isym->st_shndx < elf_numsections (abfd)
441 && !(isym->st_shndx >= SHN_LORESERVE && isym->st_shndx <= SHN_HIRESERVE))
443 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
444 shindex = elf_elfheader (abfd)->e_shstrndx;
447 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
450 else if (sym_sec && *name == '\0')
451 name = bfd_section_name (abfd, sym_sec);
456 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
457 sections. The first element is the flags, the rest are section
460 typedef union elf_internal_group {
461 Elf_Internal_Shdr *shdr;
463 } Elf_Internal_Group;
465 /* Return the name of the group signature symbol. Why isn't the
466 signature just a string? */
469 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
471 Elf_Internal_Shdr *hdr;
472 unsigned char esym[sizeof (Elf64_External_Sym)];
473 Elf_External_Sym_Shndx eshndx;
474 Elf_Internal_Sym isym;
476 /* First we need to ensure the symbol table is available. Make sure
477 that it is a symbol table section. */
478 hdr = elf_elfsections (abfd) [ghdr->sh_link];
479 if (hdr->sh_type != SHT_SYMTAB
480 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
483 /* Go read the symbol. */
484 hdr = &elf_tdata (abfd)->symtab_hdr;
485 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
486 &isym, esym, &eshndx) == NULL)
489 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
492 /* Set next_in_group list pointer, and group name for NEWSECT. */
495 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
497 unsigned int num_group = elf_tdata (abfd)->num_group;
499 /* If num_group is zero, read in all SHT_GROUP sections. The count
500 is set to -1 if there are no SHT_GROUP sections. */
503 unsigned int i, shnum;
505 /* First count the number of groups. If we have a SHT_GROUP
506 section with just a flag word (ie. sh_size is 4), ignore it. */
507 shnum = elf_numsections (abfd);
510 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
511 ( (shdr)->sh_type == SHT_GROUP \
512 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
513 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
514 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
516 for (i = 0; i < shnum; i++)
518 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
520 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
526 num_group = (unsigned) -1;
527 elf_tdata (abfd)->num_group = num_group;
531 /* We keep a list of elf section headers for group sections,
532 so we can find them quickly. */
535 elf_tdata (abfd)->num_group = num_group;
536 elf_tdata (abfd)->group_sect_ptr
537 = bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
538 if (elf_tdata (abfd)->group_sect_ptr == NULL)
542 for (i = 0; i < shnum; i++)
544 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
546 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
549 Elf_Internal_Group *dest;
551 /* Add to list of sections. */
552 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
555 /* Read the raw contents. */
556 BFD_ASSERT (sizeof (*dest) >= 4);
557 amt = shdr->sh_size * sizeof (*dest) / 4;
558 shdr->contents = bfd_alloc2 (abfd, shdr->sh_size,
560 /* PR binutils/4110: Handle corrupt group headers. */
561 if (shdr->contents == NULL)
564 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
565 bfd_set_error (bfd_error_bad_value);
569 memset (shdr->contents, 0, amt);
571 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
572 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
576 /* Translate raw contents, a flag word followed by an
577 array of elf section indices all in target byte order,
578 to the flag word followed by an array of elf section
580 src = shdr->contents + shdr->sh_size;
581 dest = (Elf_Internal_Group *) (shdr->contents + amt);
588 idx = H_GET_32 (abfd, src);
589 if (src == shdr->contents)
592 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
593 shdr->bfd_section->flags
594 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
599 ((*_bfd_error_handler)
600 (_("%B: invalid SHT_GROUP entry"), abfd));
603 dest->shdr = elf_elfsections (abfd)[idx];
610 if (num_group != (unsigned) -1)
614 for (i = 0; i < num_group; i++)
616 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
617 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
618 unsigned int n_elt = shdr->sh_size / 4;
620 /* Look through this group's sections to see if current
621 section is a member. */
623 if ((++idx)->shdr == hdr)
627 /* We are a member of this group. Go looking through
628 other members to see if any others are linked via
630 idx = (Elf_Internal_Group *) shdr->contents;
631 n_elt = shdr->sh_size / 4;
633 if ((s = (++idx)->shdr->bfd_section) != NULL
634 && elf_next_in_group (s) != NULL)
638 /* Snarf the group name from other member, and
639 insert current section in circular list. */
640 elf_group_name (newsect) = elf_group_name (s);
641 elf_next_in_group (newsect) = elf_next_in_group (s);
642 elf_next_in_group (s) = newsect;
648 gname = group_signature (abfd, shdr);
651 elf_group_name (newsect) = gname;
653 /* Start a circular list with one element. */
654 elf_next_in_group (newsect) = newsect;
657 /* If the group section has been created, point to the
659 if (shdr->bfd_section != NULL)
660 elf_next_in_group (shdr->bfd_section) = newsect;
668 if (elf_group_name (newsect) == NULL)
670 (*_bfd_error_handler) (_("%B: no group info for section %A"),
677 _bfd_elf_setup_sections (bfd *abfd)
680 unsigned int num_group = elf_tdata (abfd)->num_group;
681 bfd_boolean result = TRUE;
684 /* Process SHF_LINK_ORDER. */
685 for (s = abfd->sections; s != NULL; s = s->next)
687 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
688 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
690 unsigned int elfsec = this_hdr->sh_link;
691 /* FIXME: The old Intel compiler and old strip/objcopy may
692 not set the sh_link or sh_info fields. Hence we could
693 get the situation where elfsec is 0. */
696 const struct elf_backend_data *bed
697 = get_elf_backend_data (abfd);
698 if (bed->link_order_error_handler)
699 bed->link_order_error_handler
700 (_("%B: warning: sh_link not set for section `%A'"),
707 this_hdr = elf_elfsections (abfd)[elfsec];
710 Some strip/objcopy may leave an incorrect value in
711 sh_link. We don't want to proceed. */
712 link = this_hdr->bfd_section;
715 (*_bfd_error_handler)
716 (_("%B: sh_link [%d] in section `%A' is incorrect"),
717 s->owner, s, elfsec);
721 elf_linked_to_section (s) = link;
726 /* Process section groups. */
727 if (num_group == (unsigned) -1)
730 for (i = 0; i < num_group; i++)
732 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
733 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
734 unsigned int n_elt = shdr->sh_size / 4;
737 if ((++idx)->shdr->bfd_section)
738 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
739 else if (idx->shdr->sh_type == SHT_RELA
740 || idx->shdr->sh_type == SHT_REL)
741 /* We won't include relocation sections in section groups in
742 output object files. We adjust the group section size here
743 so that relocatable link will work correctly when
744 relocation sections are in section group in input object
746 shdr->bfd_section->size -= 4;
749 /* There are some unknown sections in the group. */
750 (*_bfd_error_handler)
751 (_("%B: unknown [%d] section `%s' in group [%s]"),
753 (unsigned int) idx->shdr->sh_type,
754 bfd_elf_string_from_elf_section (abfd,
755 (elf_elfheader (abfd)
758 shdr->bfd_section->name);
766 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
768 return elf_next_in_group (sec) != NULL;
771 /* Make a BFD section from an ELF section. We store a pointer to the
772 BFD section in the bfd_section field of the header. */
775 _bfd_elf_make_section_from_shdr (bfd *abfd,
776 Elf_Internal_Shdr *hdr,
782 const struct elf_backend_data *bed;
784 if (hdr->bfd_section != NULL)
786 BFD_ASSERT (strcmp (name,
787 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
791 newsect = bfd_make_section_anyway (abfd, name);
795 hdr->bfd_section = newsect;
796 elf_section_data (newsect)->this_hdr = *hdr;
797 elf_section_data (newsect)->this_idx = shindex;
799 /* Always use the real type/flags. */
800 elf_section_type (newsect) = hdr->sh_type;
801 elf_section_flags (newsect) = hdr->sh_flags;
803 newsect->filepos = hdr->sh_offset;
805 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
806 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
807 || ! bfd_set_section_alignment (abfd, newsect,
808 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
811 flags = SEC_NO_FLAGS;
812 if (hdr->sh_type != SHT_NOBITS)
813 flags |= SEC_HAS_CONTENTS;
814 if (hdr->sh_type == SHT_GROUP)
815 flags |= SEC_GROUP | SEC_EXCLUDE;
816 if ((hdr->sh_flags & SHF_ALLOC) != 0)
819 if (hdr->sh_type != SHT_NOBITS)
822 if ((hdr->sh_flags & SHF_WRITE) == 0)
823 flags |= SEC_READONLY;
824 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
826 else if ((flags & SEC_LOAD) != 0)
828 if ((hdr->sh_flags & SHF_MERGE) != 0)
831 newsect->entsize = hdr->sh_entsize;
832 if ((hdr->sh_flags & SHF_STRINGS) != 0)
833 flags |= SEC_STRINGS;
835 if (hdr->sh_flags & SHF_GROUP)
836 if (!setup_group (abfd, hdr, newsect))
838 if ((hdr->sh_flags & SHF_TLS) != 0)
839 flags |= SEC_THREAD_LOCAL;
841 if ((flags & SEC_ALLOC) == 0)
843 /* The debugging sections appear to be recognized only by name,
844 not any sort of flag. Their SEC_ALLOC bits are cleared. */
849 } debug_sections [] =
851 { STRING_COMMA_LEN ("debug") }, /* 'd' */
852 { NULL, 0 }, /* 'e' */
853 { NULL, 0 }, /* 'f' */
854 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
855 { NULL, 0 }, /* 'h' */
856 { NULL, 0 }, /* 'i' */
857 { NULL, 0 }, /* 'j' */
858 { NULL, 0 }, /* 'k' */
859 { STRING_COMMA_LEN ("line") }, /* 'l' */
860 { NULL, 0 }, /* 'm' */
861 { NULL, 0 }, /* 'n' */
862 { NULL, 0 }, /* 'o' */
863 { NULL, 0 }, /* 'p' */
864 { NULL, 0 }, /* 'q' */
865 { NULL, 0 }, /* 'r' */
866 { STRING_COMMA_LEN ("stab") } /* 's' */
871 int i = name [1] - 'd';
873 && i < (int) ARRAY_SIZE (debug_sections)
874 && debug_sections [i].name != NULL
875 && strncmp (&name [1], debug_sections [i].name,
876 debug_sections [i].len) == 0)
877 flags |= SEC_DEBUGGING;
881 /* As a GNU extension, if the name begins with .gnu.linkonce, we
882 only link a single copy of the section. This is used to support
883 g++. g++ will emit each template expansion in its own section.
884 The symbols will be defined as weak, so that multiple definitions
885 are permitted. The GNU linker extension is to actually discard
886 all but one of the sections. */
887 if (CONST_STRNEQ (name, ".gnu.linkonce")
888 && elf_next_in_group (newsect) == NULL)
889 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
891 bed = get_elf_backend_data (abfd);
892 if (bed->elf_backend_section_flags)
893 if (! bed->elf_backend_section_flags (&flags, hdr))
896 if (! bfd_set_section_flags (abfd, newsect, flags))
899 if ((flags & SEC_ALLOC) != 0)
901 Elf_Internal_Phdr *phdr;
904 /* Look through the phdrs to see if we need to adjust the lma.
905 If all the p_paddr fields are zero, we ignore them, since
906 some ELF linkers produce such output. */
907 phdr = elf_tdata (abfd)->phdr;
908 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
910 if (phdr->p_paddr != 0)
913 if (i < elf_elfheader (abfd)->e_phnum)
915 phdr = elf_tdata (abfd)->phdr;
916 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
918 /* This section is part of this segment if its file
919 offset plus size lies within the segment's memory
920 span and, if the section is loaded, the extent of the
921 loaded data lies within the extent of the segment.
923 Note - we used to check the p_paddr field as well, and
924 refuse to set the LMA if it was 0. This is wrong
925 though, as a perfectly valid initialised segment can
926 have a p_paddr of zero. Some architectures, eg ARM,
927 place special significance on the address 0 and
928 executables need to be able to have a segment which
929 covers this address. */
930 if (phdr->p_type == PT_LOAD
931 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
932 && (hdr->sh_offset + hdr->sh_size
933 <= phdr->p_offset + phdr->p_memsz)
934 && ((flags & SEC_LOAD) == 0
935 || (hdr->sh_offset + hdr->sh_size
936 <= phdr->p_offset + phdr->p_filesz)))
938 if ((flags & SEC_LOAD) == 0)
939 newsect->lma = (phdr->p_paddr
940 + hdr->sh_addr - phdr->p_vaddr);
942 /* We used to use the same adjustment for SEC_LOAD
943 sections, but that doesn't work if the segment
944 is packed with code from multiple VMAs.
945 Instead we calculate the section LMA based on
946 the segment LMA. It is assumed that the
947 segment will contain sections with contiguous
948 LMAs, even if the VMAs are not. */
949 newsect->lma = (phdr->p_paddr
950 + hdr->sh_offset - phdr->p_offset);
952 /* With contiguous segments, we can't tell from file
953 offsets whether a section with zero size should
954 be placed at the end of one segment or the
955 beginning of the next. Decide based on vaddr. */
956 if (hdr->sh_addr >= phdr->p_vaddr
957 && (hdr->sh_addr + hdr->sh_size
958 <= phdr->p_vaddr + phdr->p_memsz))
973 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
976 Helper functions for GDB to locate the string tables.
977 Since BFD hides string tables from callers, GDB needs to use an
978 internal hook to find them. Sun's .stabstr, in particular,
979 isn't even pointed to by the .stab section, so ordinary
980 mechanisms wouldn't work to find it, even if we had some.
983 struct elf_internal_shdr *
984 bfd_elf_find_section (bfd *abfd, char *name)
986 Elf_Internal_Shdr **i_shdrp;
991 i_shdrp = elf_elfsections (abfd);
994 shstrtab = bfd_elf_get_str_section (abfd,
995 elf_elfheader (abfd)->e_shstrndx);
996 if (shstrtab != NULL)
998 max = elf_numsections (abfd);
999 for (i = 1; i < max; i++)
1000 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
1007 const char *const bfd_elf_section_type_names[] = {
1008 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1009 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1010 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1013 /* ELF relocs are against symbols. If we are producing relocatable
1014 output, and the reloc is against an external symbol, and nothing
1015 has given us any additional addend, the resulting reloc will also
1016 be against the same symbol. In such a case, we don't want to
1017 change anything about the way the reloc is handled, since it will
1018 all be done at final link time. Rather than put special case code
1019 into bfd_perform_relocation, all the reloc types use this howto
1020 function. It just short circuits the reloc if producing
1021 relocatable output against an external symbol. */
1023 bfd_reloc_status_type
1024 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1025 arelent *reloc_entry,
1027 void *data ATTRIBUTE_UNUSED,
1028 asection *input_section,
1030 char **error_message ATTRIBUTE_UNUSED)
1032 if (output_bfd != NULL
1033 && (symbol->flags & BSF_SECTION_SYM) == 0
1034 && (! reloc_entry->howto->partial_inplace
1035 || reloc_entry->addend == 0))
1037 reloc_entry->address += input_section->output_offset;
1038 return bfd_reloc_ok;
1041 return bfd_reloc_continue;
1044 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
1047 merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
1050 BFD_ASSERT (sec->sec_info_type == ELF_INFO_TYPE_MERGE);
1051 sec->sec_info_type = ELF_INFO_TYPE_NONE;
1054 /* Finish SHF_MERGE section merging. */
1057 _bfd_elf_merge_sections (bfd *abfd, struct bfd_link_info *info)
1062 if (!is_elf_hash_table (info->hash))
1065 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1066 if ((ibfd->flags & DYNAMIC) == 0)
1067 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
1068 if ((sec->flags & SEC_MERGE) != 0
1069 && !bfd_is_abs_section (sec->output_section))
1071 struct bfd_elf_section_data *secdata;
1073 secdata = elf_section_data (sec);
1074 if (! _bfd_add_merge_section (abfd,
1075 &elf_hash_table (info)->merge_info,
1076 sec, &secdata->sec_info))
1078 else if (secdata->sec_info)
1079 sec->sec_info_type = ELF_INFO_TYPE_MERGE;
1082 if (elf_hash_table (info)->merge_info != NULL)
1083 _bfd_merge_sections (abfd, info, elf_hash_table (info)->merge_info,
1084 merge_sections_remove_hook);
1089 _bfd_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
1091 sec->output_section = bfd_abs_section_ptr;
1092 sec->output_offset = sec->vma;
1093 if (!is_elf_hash_table (info->hash))
1096 sec->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
1099 /* Copy the program header and other data from one object module to
1103 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1105 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1106 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1109 BFD_ASSERT (!elf_flags_init (obfd)
1110 || (elf_elfheader (obfd)->e_flags
1111 == elf_elfheader (ibfd)->e_flags));
1113 elf_gp (obfd) = elf_gp (ibfd);
1114 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1115 elf_flags_init (obfd) = TRUE;
1117 /* Copy object attributes. */
1118 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1124 get_segment_type (unsigned int p_type)
1129 case PT_NULL: pt = "NULL"; break;
1130 case PT_LOAD: pt = "LOAD"; break;
1131 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1132 case PT_INTERP: pt = "INTERP"; break;
1133 case PT_NOTE: pt = "NOTE"; break;
1134 case PT_SHLIB: pt = "SHLIB"; break;
1135 case PT_PHDR: pt = "PHDR"; break;
1136 case PT_TLS: pt = "TLS"; break;
1137 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1138 case PT_GNU_STACK: pt = "STACK"; break;
1139 case PT_GNU_RELRO: pt = "RELRO"; break;
1140 default: pt = NULL; break;
1145 /* Print out the program headers. */
1148 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1151 Elf_Internal_Phdr *p;
1153 bfd_byte *dynbuf = NULL;
1155 p = elf_tdata (abfd)->phdr;
1160 fprintf (f, _("\nProgram Header:\n"));
1161 c = elf_elfheader (abfd)->e_phnum;
1162 for (i = 0; i < c; i++, p++)
1164 const char *pt = get_segment_type (p->p_type);
1169 sprintf (buf, "0x%lx", p->p_type);
1172 fprintf (f, "%8s off 0x", pt);
1173 bfd_fprintf_vma (abfd, f, p->p_offset);
1174 fprintf (f, " vaddr 0x");
1175 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1176 fprintf (f, " paddr 0x");
1177 bfd_fprintf_vma (abfd, f, p->p_paddr);
1178 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1179 fprintf (f, " filesz 0x");
1180 bfd_fprintf_vma (abfd, f, p->p_filesz);
1181 fprintf (f, " memsz 0x");
1182 bfd_fprintf_vma (abfd, f, p->p_memsz);
1183 fprintf (f, " flags %c%c%c",
1184 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1185 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1186 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1187 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1188 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1193 s = bfd_get_section_by_name (abfd, ".dynamic");
1197 unsigned long shlink;
1198 bfd_byte *extdyn, *extdynend;
1200 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1202 fprintf (f, _("\nDynamic Section:\n"));
1204 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1207 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1210 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1212 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1213 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1216 extdynend = extdyn + s->size;
1217 for (; extdyn < extdynend; extdyn += extdynsize)
1219 Elf_Internal_Dyn dyn;
1222 bfd_boolean stringp;
1224 (*swap_dyn_in) (abfd, extdyn, &dyn);
1226 if (dyn.d_tag == DT_NULL)
1233 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1237 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1238 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1239 case DT_PLTGOT: name = "PLTGOT"; break;
1240 case DT_HASH: name = "HASH"; break;
1241 case DT_STRTAB: name = "STRTAB"; break;
1242 case DT_SYMTAB: name = "SYMTAB"; break;
1243 case DT_RELA: name = "RELA"; break;
1244 case DT_RELASZ: name = "RELASZ"; break;
1245 case DT_RELAENT: name = "RELAENT"; break;
1246 case DT_STRSZ: name = "STRSZ"; break;
1247 case DT_SYMENT: name = "SYMENT"; break;
1248 case DT_INIT: name = "INIT"; break;
1249 case DT_FINI: name = "FINI"; break;
1250 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1251 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1252 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1253 case DT_REL: name = "REL"; break;
1254 case DT_RELSZ: name = "RELSZ"; break;
1255 case DT_RELENT: name = "RELENT"; break;
1256 case DT_PLTREL: name = "PLTREL"; break;
1257 case DT_DEBUG: name = "DEBUG"; break;
1258 case DT_TEXTREL: name = "TEXTREL"; break;
1259 case DT_JMPREL: name = "JMPREL"; break;
1260 case DT_BIND_NOW: name = "BIND_NOW"; break;
1261 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1262 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1263 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1264 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1265 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1266 case DT_FLAGS: name = "FLAGS"; break;
1267 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1268 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1269 case DT_CHECKSUM: name = "CHECKSUM"; break;
1270 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1271 case DT_MOVEENT: name = "MOVEENT"; break;
1272 case DT_MOVESZ: name = "MOVESZ"; break;
1273 case DT_FEATURE: name = "FEATURE"; break;
1274 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1275 case DT_SYMINSZ: name = "SYMINSZ"; break;
1276 case DT_SYMINENT: name = "SYMINENT"; break;
1277 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1278 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1279 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1280 case DT_PLTPAD: name = "PLTPAD"; break;
1281 case DT_MOVETAB: name = "MOVETAB"; break;
1282 case DT_SYMINFO: name = "SYMINFO"; break;
1283 case DT_RELACOUNT: name = "RELACOUNT"; break;
1284 case DT_RELCOUNT: name = "RELCOUNT"; break;
1285 case DT_FLAGS_1: name = "FLAGS_1"; break;
1286 case DT_VERSYM: name = "VERSYM"; break;
1287 case DT_VERDEF: name = "VERDEF"; break;
1288 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1289 case DT_VERNEED: name = "VERNEED"; break;
1290 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1291 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1292 case DT_USED: name = "USED"; break;
1293 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1294 case DT_GNU_HASH: name = "GNU_HASH"; break;
1297 fprintf (f, " %-11s ", name);
1299 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1303 unsigned int tagv = dyn.d_un.d_val;
1305 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1308 fprintf (f, "%s", string);
1317 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1318 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1320 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1324 if (elf_dynverdef (abfd) != 0)
1326 Elf_Internal_Verdef *t;
1328 fprintf (f, _("\nVersion definitions:\n"));
1329 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1331 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1332 t->vd_flags, t->vd_hash,
1333 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1334 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1336 Elf_Internal_Verdaux *a;
1339 for (a = t->vd_auxptr->vda_nextptr;
1343 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1349 if (elf_dynverref (abfd) != 0)
1351 Elf_Internal_Verneed *t;
1353 fprintf (f, _("\nVersion References:\n"));
1354 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1356 Elf_Internal_Vernaux *a;
1358 fprintf (f, _(" required from %s:\n"),
1359 t->vn_filename ? t->vn_filename : "<corrupt>");
1360 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1361 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1362 a->vna_flags, a->vna_other,
1363 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1375 /* Display ELF-specific fields of a symbol. */
1378 bfd_elf_print_symbol (bfd *abfd,
1381 bfd_print_symbol_type how)
1386 case bfd_print_symbol_name:
1387 fprintf (file, "%s", symbol->name);
1389 case bfd_print_symbol_more:
1390 fprintf (file, "elf ");
1391 bfd_fprintf_vma (abfd, file, symbol->value);
1392 fprintf (file, " %lx", (long) symbol->flags);
1394 case bfd_print_symbol_all:
1396 const char *section_name;
1397 const char *name = NULL;
1398 const struct elf_backend_data *bed;
1399 unsigned char st_other;
1402 section_name = symbol->section ? symbol->section->name : "(*none*)";
1404 bed = get_elf_backend_data (abfd);
1405 if (bed->elf_backend_print_symbol_all)
1406 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1410 name = symbol->name;
1411 bfd_print_symbol_vandf (abfd, file, symbol);
1414 fprintf (file, " %s\t", section_name);
1415 /* Print the "other" value for a symbol. For common symbols,
1416 we've already printed the size; now print the alignment.
1417 For other symbols, we have no specified alignment, and
1418 we've printed the address; now print the size. */
1419 if (bfd_is_com_section (symbol->section))
1420 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1422 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1423 bfd_fprintf_vma (abfd, file, val);
1425 /* If we have version information, print it. */
1426 if (elf_tdata (abfd)->dynversym_section != 0
1427 && (elf_tdata (abfd)->dynverdef_section != 0
1428 || elf_tdata (abfd)->dynverref_section != 0))
1430 unsigned int vernum;
1431 const char *version_string;
1433 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1436 version_string = "";
1437 else if (vernum == 1)
1438 version_string = "Base";
1439 else if (vernum <= elf_tdata (abfd)->cverdefs)
1441 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1444 Elf_Internal_Verneed *t;
1446 version_string = "";
1447 for (t = elf_tdata (abfd)->verref;
1451 Elf_Internal_Vernaux *a;
1453 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1455 if (a->vna_other == vernum)
1457 version_string = a->vna_nodename;
1464 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1465 fprintf (file, " %-11s", version_string);
1470 fprintf (file, " (%s)", version_string);
1471 for (i = 10 - strlen (version_string); i > 0; --i)
1476 /* If the st_other field is not zero, print it. */
1477 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1482 case STV_INTERNAL: fprintf (file, " .internal"); break;
1483 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1484 case STV_PROTECTED: fprintf (file, " .protected"); break;
1486 /* Some other non-defined flags are also present, so print
1488 fprintf (file, " 0x%02x", (unsigned int) st_other);
1491 fprintf (file, " %s", name);
1497 /* Create an entry in an ELF linker hash table. */
1499 struct bfd_hash_entry *
1500 _bfd_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1501 struct bfd_hash_table *table,
1504 /* Allocate the structure if it has not already been allocated by a
1508 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1513 /* Call the allocation method of the superclass. */
1514 entry = _bfd_link_hash_newfunc (entry, table, string);
1517 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1518 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1520 /* Set local fields. */
1523 ret->got = htab->init_got_refcount;
1524 ret->plt = htab->init_plt_refcount;
1525 memset (&ret->size, 0, (sizeof (struct elf_link_hash_entry)
1526 - offsetof (struct elf_link_hash_entry, size)));
1527 /* Assume that we have been called by a non-ELF symbol reader.
1528 This flag is then reset by the code which reads an ELF input
1529 file. This ensures that a symbol created by a non-ELF symbol
1530 reader will have the flag set correctly. */
1537 /* Copy data from an indirect symbol to its direct symbol, hiding the
1538 old indirect symbol. Also used for copying flags to a weakdef. */
1541 _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
1542 struct elf_link_hash_entry *dir,
1543 struct elf_link_hash_entry *ind)
1545 struct elf_link_hash_table *htab;
1547 /* Copy down any references that we may have already seen to the
1548 symbol which just became indirect. */
1550 dir->ref_dynamic |= ind->ref_dynamic;
1551 dir->ref_regular |= ind->ref_regular;
1552 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1553 dir->non_got_ref |= ind->non_got_ref;
1554 dir->needs_plt |= ind->needs_plt;
1555 dir->pointer_equality_needed |= ind->pointer_equality_needed;
1557 if (ind->root.type != bfd_link_hash_indirect)
1560 /* Copy over the global and procedure linkage table refcount entries.
1561 These may have been already set up by a check_relocs routine. */
1562 htab = elf_hash_table (info);
1563 if (ind->got.refcount > htab->init_got_refcount.refcount)
1565 if (dir->got.refcount < 0)
1566 dir->got.refcount = 0;
1567 dir->got.refcount += ind->got.refcount;
1568 ind->got.refcount = htab->init_got_refcount.refcount;
1571 if (ind->plt.refcount > htab->init_plt_refcount.refcount)
1573 if (dir->plt.refcount < 0)
1574 dir->plt.refcount = 0;
1575 dir->plt.refcount += ind->plt.refcount;
1576 ind->plt.refcount = htab->init_plt_refcount.refcount;
1579 if (ind->dynindx != -1)
1581 if (dir->dynindx != -1)
1582 _bfd_elf_strtab_delref (htab->dynstr, dir->dynstr_index);
1583 dir->dynindx = ind->dynindx;
1584 dir->dynstr_index = ind->dynstr_index;
1586 ind->dynstr_index = 0;
1591 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
1592 struct elf_link_hash_entry *h,
1593 bfd_boolean force_local)
1595 h->plt = elf_hash_table (info)->init_plt_offset;
1599 h->forced_local = 1;
1600 if (h->dynindx != -1)
1603 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1609 /* Initialize an ELF linker hash table. */
1612 _bfd_elf_link_hash_table_init
1613 (struct elf_link_hash_table *table,
1615 struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
1616 struct bfd_hash_table *,
1618 unsigned int entsize)
1621 int can_refcount = get_elf_backend_data (abfd)->can_refcount;
1623 memset (table, 0, sizeof * table);
1624 table->init_got_refcount.refcount = can_refcount - 1;
1625 table->init_plt_refcount.refcount = can_refcount - 1;
1626 table->init_got_offset.offset = -(bfd_vma) 1;
1627 table->init_plt_offset.offset = -(bfd_vma) 1;
1628 /* The first dynamic symbol is a dummy. */
1629 table->dynsymcount = 1;
1631 ret = _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
1632 table->root.type = bfd_link_elf_hash_table;
1637 /* Create an ELF linker hash table. */
1639 struct bfd_link_hash_table *
1640 _bfd_elf_link_hash_table_create (bfd *abfd)
1642 struct elf_link_hash_table *ret;
1643 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1645 ret = bfd_malloc (amt);
1649 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc,
1650 sizeof (struct elf_link_hash_entry)))
1659 /* This is a hook for the ELF emulation code in the generic linker to
1660 tell the backend linker what file name to use for the DT_NEEDED
1661 entry for a dynamic object. */
1664 bfd_elf_set_dt_needed_name (bfd *abfd, const char *name)
1666 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1667 && bfd_get_format (abfd) == bfd_object)
1668 elf_dt_name (abfd) = name;
1672 bfd_elf_get_dyn_lib_class (bfd *abfd)
1675 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1676 && bfd_get_format (abfd) == bfd_object)
1677 lib_class = elf_dyn_lib_class (abfd);
1684 bfd_elf_set_dyn_lib_class (bfd *abfd, enum dynamic_lib_link_class lib_class)
1686 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1687 && bfd_get_format (abfd) == bfd_object)
1688 elf_dyn_lib_class (abfd) = lib_class;
1691 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1692 the linker ELF emulation code. */
1694 struct bfd_link_needed_list *
1695 bfd_elf_get_needed_list (bfd *abfd ATTRIBUTE_UNUSED,
1696 struct bfd_link_info *info)
1698 if (! is_elf_hash_table (info->hash))
1700 return elf_hash_table (info)->needed;
1703 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1704 hook for the linker ELF emulation code. */
1706 struct bfd_link_needed_list *
1707 bfd_elf_get_runpath_list (bfd *abfd ATTRIBUTE_UNUSED,
1708 struct bfd_link_info *info)
1710 if (! is_elf_hash_table (info->hash))
1712 return elf_hash_table (info)->runpath;
1715 /* Get the name actually used for a dynamic object for a link. This
1716 is the SONAME entry if there is one. Otherwise, it is the string
1717 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1720 bfd_elf_get_dt_soname (bfd *abfd)
1722 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1723 && bfd_get_format (abfd) == bfd_object)
1724 return elf_dt_name (abfd);
1728 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1729 the ELF linker emulation code. */
1732 bfd_elf_get_bfd_needed_list (bfd *abfd,
1733 struct bfd_link_needed_list **pneeded)
1736 bfd_byte *dynbuf = NULL;
1738 unsigned long shlink;
1739 bfd_byte *extdyn, *extdynend;
1741 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1745 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1746 || bfd_get_format (abfd) != bfd_object)
1749 s = bfd_get_section_by_name (abfd, ".dynamic");
1750 if (s == NULL || s->size == 0)
1753 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1756 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1760 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1762 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1763 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1766 extdynend = extdyn + s->size;
1767 for (; extdyn < extdynend; extdyn += extdynsize)
1769 Elf_Internal_Dyn dyn;
1771 (*swap_dyn_in) (abfd, extdyn, &dyn);
1773 if (dyn.d_tag == DT_NULL)
1776 if (dyn.d_tag == DT_NEEDED)
1779 struct bfd_link_needed_list *l;
1780 unsigned int tagv = dyn.d_un.d_val;
1783 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1788 l = bfd_alloc (abfd, amt);
1809 /* Allocate an ELF string table--force the first byte to be zero. */
1811 struct bfd_strtab_hash *
1812 _bfd_elf_stringtab_init (void)
1814 struct bfd_strtab_hash *ret;
1816 ret = _bfd_stringtab_init ();
1821 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1822 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1823 if (loc == (bfd_size_type) -1)
1825 _bfd_stringtab_free (ret);
1832 /* ELF .o/exec file reading */
1834 /* Create a new bfd section from an ELF section header. */
1837 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1839 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1840 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1841 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1844 name = bfd_elf_string_from_elf_section (abfd,
1845 elf_elfheader (abfd)->e_shstrndx,
1850 switch (hdr->sh_type)
1853 /* Inactive section. Throw it away. */
1856 case SHT_PROGBITS: /* Normal section with contents. */
1857 case SHT_NOBITS: /* .bss section. */
1858 case SHT_HASH: /* .hash section. */
1859 case SHT_NOTE: /* .note section. */
1860 case SHT_INIT_ARRAY: /* .init_array section. */
1861 case SHT_FINI_ARRAY: /* .fini_array section. */
1862 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1863 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1864 case SHT_GNU_HASH: /* .gnu.hash section. */
1865 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1867 case SHT_DYNAMIC: /* Dynamic linking information. */
1868 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1870 if (hdr->sh_link > elf_numsections (abfd)
1871 || elf_elfsections (abfd)[hdr->sh_link] == NULL)
1873 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1875 Elf_Internal_Shdr *dynsymhdr;
1877 /* The shared libraries distributed with hpux11 have a bogus
1878 sh_link field for the ".dynamic" section. Find the
1879 string table for the ".dynsym" section instead. */
1880 if (elf_dynsymtab (abfd) != 0)
1882 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1883 hdr->sh_link = dynsymhdr->sh_link;
1887 unsigned int i, num_sec;
1889 num_sec = elf_numsections (abfd);
1890 for (i = 1; i < num_sec; i++)
1892 dynsymhdr = elf_elfsections (abfd)[i];
1893 if (dynsymhdr->sh_type == SHT_DYNSYM)
1895 hdr->sh_link = dynsymhdr->sh_link;
1903 case SHT_SYMTAB: /* A symbol table */
1904 if (elf_onesymtab (abfd) == shindex)
1907 if (hdr->sh_entsize != bed->s->sizeof_sym)
1909 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1910 elf_onesymtab (abfd) = shindex;
1911 elf_tdata (abfd)->symtab_hdr = *hdr;
1912 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1913 abfd->flags |= HAS_SYMS;
1915 /* Sometimes a shared object will map in the symbol table. If
1916 SHF_ALLOC is set, and this is a shared object, then we also
1917 treat this section as a BFD section. We can not base the
1918 decision purely on SHF_ALLOC, because that flag is sometimes
1919 set in a relocatable object file, which would confuse the
1921 if ((hdr->sh_flags & SHF_ALLOC) != 0
1922 && (abfd->flags & DYNAMIC) != 0
1923 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1927 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1928 can't read symbols without that section loaded as well. It
1929 is most likely specified by the next section header. */
1930 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1932 unsigned int i, num_sec;
1934 num_sec = elf_numsections (abfd);
1935 for (i = shindex + 1; i < num_sec; i++)
1937 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1938 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1939 && hdr2->sh_link == shindex)
1943 for (i = 1; i < shindex; i++)
1945 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1946 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1947 && hdr2->sh_link == shindex)
1951 return bfd_section_from_shdr (abfd, i);
1955 case SHT_DYNSYM: /* A dynamic symbol table */
1956 if (elf_dynsymtab (abfd) == shindex)
1959 if (hdr->sh_entsize != bed->s->sizeof_sym)
1961 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1962 elf_dynsymtab (abfd) = shindex;
1963 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1964 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1965 abfd->flags |= HAS_SYMS;
1967 /* Besides being a symbol table, we also treat this as a regular
1968 section, so that objcopy can handle it. */
1969 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1971 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1972 if (elf_symtab_shndx (abfd) == shindex)
1975 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1976 elf_symtab_shndx (abfd) = shindex;
1977 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1978 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1981 case SHT_STRTAB: /* A string table */
1982 if (hdr->bfd_section != NULL)
1984 if (ehdr->e_shstrndx == shindex)
1986 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1987 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1990 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1993 elf_tdata (abfd)->strtab_hdr = *hdr;
1994 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1997 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
2000 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
2001 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
2002 elf_elfsections (abfd)[shindex] = hdr;
2003 /* We also treat this as a regular section, so that objcopy
2005 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2009 /* If the string table isn't one of the above, then treat it as a
2010 regular section. We need to scan all the headers to be sure,
2011 just in case this strtab section appeared before the above. */
2012 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
2014 unsigned int i, num_sec;
2016 num_sec = elf_numsections (abfd);
2017 for (i = 1; i < num_sec; i++)
2019 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
2020 if (hdr2->sh_link == shindex)
2022 /* Prevent endless recursion on broken objects. */
2025 if (! bfd_section_from_shdr (abfd, i))
2027 if (elf_onesymtab (abfd) == i)
2029 if (elf_dynsymtab (abfd) == i)
2030 goto dynsymtab_strtab;
2034 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2038 /* *These* do a lot of work -- but build no sections! */
2040 asection *target_sect;
2041 Elf_Internal_Shdr *hdr2;
2042 unsigned int num_sec = elf_numsections (abfd);
2045 != (bfd_size_type) (hdr->sh_type == SHT_REL
2046 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
2049 /* Check for a bogus link to avoid crashing. */
2050 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
2051 || hdr->sh_link >= num_sec)
2053 ((*_bfd_error_handler)
2054 (_("%B: invalid link %lu for reloc section %s (index %u)"),
2055 abfd, hdr->sh_link, name, shindex));
2056 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2060 /* For some incomprehensible reason Oracle distributes
2061 libraries for Solaris in which some of the objects have
2062 bogus sh_link fields. It would be nice if we could just
2063 reject them, but, unfortunately, some people need to use
2064 them. We scan through the section headers; if we find only
2065 one suitable symbol table, we clobber the sh_link to point
2066 to it. I hope this doesn't break anything. */
2067 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
2068 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
2074 for (scan = 1; scan < num_sec; scan++)
2076 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
2077 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
2088 hdr->sh_link = found;
2091 /* Get the symbol table. */
2092 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
2093 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
2094 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
2097 /* If this reloc section does not use the main symbol table we
2098 don't treat it as a reloc section. BFD can't adequately
2099 represent such a section, so at least for now, we don't
2100 try. We just present it as a normal section. We also
2101 can't use it as a reloc section if it points to the null
2102 section, an invalid section, or another reloc section. */
2103 if (hdr->sh_link != elf_onesymtab (abfd)
2104 || hdr->sh_info == SHN_UNDEF
2105 || (hdr->sh_info >= SHN_LORESERVE && hdr->sh_info <= SHN_HIRESERVE)
2106 || hdr->sh_info >= num_sec
2107 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
2108 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
2109 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2112 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
2114 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
2115 if (target_sect == NULL)
2118 if ((target_sect->flags & SEC_RELOC) == 0
2119 || target_sect->reloc_count == 0)
2120 hdr2 = &elf_section_data (target_sect)->rel_hdr;
2124 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
2125 amt = sizeof (*hdr2);
2126 hdr2 = bfd_alloc (abfd, amt);
2127 elf_section_data (target_sect)->rel_hdr2 = hdr2;
2130 elf_elfsections (abfd)[shindex] = hdr2;
2131 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
2132 target_sect->flags |= SEC_RELOC;
2133 target_sect->relocation = NULL;
2134 target_sect->rel_filepos = hdr->sh_offset;
2135 /* In the section to which the relocations apply, mark whether
2136 its relocations are of the REL or RELA variety. */
2137 if (hdr->sh_size != 0)
2138 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
2139 abfd->flags |= HAS_RELOC;
2143 case SHT_GNU_verdef:
2144 elf_dynverdef (abfd) = shindex;
2145 elf_tdata (abfd)->dynverdef_hdr = *hdr;
2146 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2148 case SHT_GNU_versym:
2149 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
2151 elf_dynversym (abfd) = shindex;
2152 elf_tdata (abfd)->dynversym_hdr = *hdr;
2153 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2155 case SHT_GNU_verneed:
2156 elf_dynverref (abfd) = shindex;
2157 elf_tdata (abfd)->dynverref_hdr = *hdr;
2158 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2164 /* We need a BFD section for objcopy and relocatable linking,
2165 and it's handy to have the signature available as the section
2167 if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
2169 name = group_signature (abfd, hdr);
2172 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2174 if (hdr->contents != NULL)
2176 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2177 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
2180 if (idx->flags & GRP_COMDAT)
2181 hdr->bfd_section->flags
2182 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2184 /* We try to keep the same section order as it comes in. */
2186 while (--n_elt != 0)
2190 if (idx->shdr != NULL
2191 && (s = idx->shdr->bfd_section) != NULL
2192 && elf_next_in_group (s) != NULL)
2194 elf_next_in_group (hdr->bfd_section) = s;
2202 /* Possibly an attributes section. */
2203 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
2204 || hdr->sh_type == bed->obj_attrs_section_type)
2206 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2208 _bfd_elf_parse_attributes (abfd, hdr);
2212 /* Check for any processor-specific section types. */
2213 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
2216 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
2218 if ((hdr->sh_flags & SHF_ALLOC) != 0)
2219 /* FIXME: How to properly handle allocated section reserved
2220 for applications? */
2221 (*_bfd_error_handler)
2222 (_("%B: don't know how to handle allocated, application "
2223 "specific section `%s' [0x%8x]"),
2224 abfd, name, hdr->sh_type);
2226 /* Allow sections reserved for applications. */
2227 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
2230 else if (hdr->sh_type >= SHT_LOPROC
2231 && hdr->sh_type <= SHT_HIPROC)
2232 /* FIXME: We should handle this section. */
2233 (*_bfd_error_handler)
2234 (_("%B: don't know how to handle processor specific section "
2236 abfd, name, hdr->sh_type);
2237 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
2239 /* Unrecognised OS-specific sections. */
2240 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
2241 /* SHF_OS_NONCONFORMING indicates that special knowledge is
2242 required to correctly process the section and the file should
2243 be rejected with an error message. */
2244 (*_bfd_error_handler)
2245 (_("%B: don't know how to handle OS specific section "
2247 abfd, name, hdr->sh_type);
2249 /* Otherwise it should be processed. */
2250 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2253 /* FIXME: We should handle this section. */
2254 (*_bfd_error_handler)
2255 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2256 abfd, name, hdr->sh_type);
2264 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2265 Return SEC for sections that have no elf section, and NULL on error. */
2268 bfd_section_from_r_symndx (bfd *abfd,
2269 struct sym_sec_cache *cache,
2271 unsigned long r_symndx)
2273 Elf_Internal_Shdr *symtab_hdr;
2274 unsigned char esym[sizeof (Elf64_External_Sym)];
2275 Elf_External_Sym_Shndx eshndx;
2276 Elf_Internal_Sym isym;
2277 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2279 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2280 return cache->sec[ent];
2282 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2283 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2284 &isym, esym, &eshndx) == NULL)
2287 if (cache->abfd != abfd)
2289 memset (cache->indx, -1, sizeof (cache->indx));
2292 cache->indx[ent] = r_symndx;
2293 cache->sec[ent] = sec;
2294 if ((isym.st_shndx != SHN_UNDEF && isym.st_shndx < SHN_LORESERVE)
2295 || isym.st_shndx > SHN_HIRESERVE)
2298 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2300 cache->sec[ent] = s;
2302 return cache->sec[ent];
2305 /* Given an ELF section number, retrieve the corresponding BFD
2309 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
2311 if (index >= elf_numsections (abfd))
2313 return elf_elfsections (abfd)[index]->bfd_section;
2316 static const struct bfd_elf_special_section special_sections_b[] =
2318 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2319 { NULL, 0, 0, 0, 0 }
2322 static const struct bfd_elf_special_section special_sections_c[] =
2324 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2325 { NULL, 0, 0, 0, 0 }
2328 static const struct bfd_elf_special_section special_sections_d[] =
2330 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2331 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2332 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2333 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2334 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2335 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2336 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2337 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2338 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2339 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2340 { NULL, 0, 0, 0, 0 }
2343 static const struct bfd_elf_special_section special_sections_f[] =
2345 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2346 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2347 { NULL, 0, 0, 0, 0 }
2350 static const struct bfd_elf_special_section special_sections_g[] =
2352 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2353 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2354 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2355 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2356 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2357 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2358 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2359 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2360 { NULL, 0, 0, 0, 0 }
2363 static const struct bfd_elf_special_section special_sections_h[] =
2365 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2366 { NULL, 0, 0, 0, 0 }
2369 static const struct bfd_elf_special_section special_sections_i[] =
2371 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2372 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2373 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2374 { NULL, 0, 0, 0, 0 }
2377 static const struct bfd_elf_special_section special_sections_l[] =
2379 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2380 { NULL, 0, 0, 0, 0 }
2383 static const struct bfd_elf_special_section special_sections_n[] =
2385 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2386 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2387 { NULL, 0, 0, 0, 0 }
2390 static const struct bfd_elf_special_section special_sections_p[] =
2392 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2393 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2394 { NULL, 0, 0, 0, 0 }
2397 static const struct bfd_elf_special_section special_sections_r[] =
2399 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2400 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2401 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2402 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2403 { NULL, 0, 0, 0, 0 }
2406 static const struct bfd_elf_special_section special_sections_s[] =
2408 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2409 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2410 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2411 /* See struct bfd_elf_special_section declaration for the semantics of
2412 this special case where .prefix_length != strlen (.prefix). */
2413 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2414 { NULL, 0, 0, 0, 0 }
2417 static const struct bfd_elf_special_section special_sections_t[] =
2419 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2420 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2421 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2422 { NULL, 0, 0, 0, 0 }
2425 static const struct bfd_elf_special_section *special_sections[] =
2427 special_sections_b, /* 'b' */
2428 special_sections_c, /* 'b' */
2429 special_sections_d, /* 'd' */
2431 special_sections_f, /* 'f' */
2432 special_sections_g, /* 'g' */
2433 special_sections_h, /* 'h' */
2434 special_sections_i, /* 'i' */
2437 special_sections_l, /* 'l' */
2439 special_sections_n, /* 'n' */
2441 special_sections_p, /* 'p' */
2443 special_sections_r, /* 'r' */
2444 special_sections_s, /* 's' */
2445 special_sections_t, /* 't' */
2448 const struct bfd_elf_special_section *
2449 _bfd_elf_get_special_section (const char *name,
2450 const struct bfd_elf_special_section *spec,
2456 len = strlen (name);
2458 for (i = 0; spec[i].prefix != NULL; i++)
2461 int prefix_len = spec[i].prefix_length;
2463 if (len < prefix_len)
2465 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2468 suffix_len = spec[i].suffix_length;
2469 if (suffix_len <= 0)
2471 if (name[prefix_len] != 0)
2473 if (suffix_len == 0)
2475 if (name[prefix_len] != '.'
2476 && (suffix_len == -2
2477 || (rela && spec[i].type == SHT_REL)))
2483 if (len < prefix_len + suffix_len)
2485 if (memcmp (name + len - suffix_len,
2486 spec[i].prefix + prefix_len,
2496 const struct bfd_elf_special_section *
2497 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2500 const struct bfd_elf_special_section *spec;
2501 const struct elf_backend_data *bed;
2503 /* See if this is one of the special sections. */
2504 if (sec->name == NULL)
2507 bed = get_elf_backend_data (abfd);
2508 spec = bed->special_sections;
2511 spec = _bfd_elf_get_special_section (sec->name,
2512 bed->special_sections,
2518 if (sec->name[0] != '.')
2521 i = sec->name[1] - 'b';
2522 if (i < 0 || i > 't' - 'b')
2525 spec = special_sections[i];
2530 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2534 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2536 struct bfd_elf_section_data *sdata;
2537 const struct elf_backend_data *bed;
2538 const struct bfd_elf_special_section *ssect;
2540 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2543 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2546 sec->used_by_bfd = sdata;
2549 /* Indicate whether or not this section should use RELA relocations. */
2550 bed = get_elf_backend_data (abfd);
2551 sec->use_rela_p = bed->default_use_rela_p;
2553 /* When we read a file, we don't need to set ELF section type and
2554 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2555 anyway. We will set ELF section type and flags for all linker
2556 created sections. If user specifies BFD section flags, we will
2557 set ELF section type and flags based on BFD section flags in
2558 elf_fake_sections. */
2559 if ((!sec->flags && abfd->direction != read_direction)
2560 || (sec->flags & SEC_LINKER_CREATED) != 0)
2562 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2565 elf_section_type (sec) = ssect->type;
2566 elf_section_flags (sec) = ssect->attr;
2570 return _bfd_generic_new_section_hook (abfd, sec);
2573 /* Create a new bfd section from an ELF program header.
2575 Since program segments have no names, we generate a synthetic name
2576 of the form segment<NUM>, where NUM is generally the index in the
2577 program header table. For segments that are split (see below) we
2578 generate the names segment<NUM>a and segment<NUM>b.
2580 Note that some program segments may have a file size that is different than
2581 (less than) the memory size. All this means is that at execution the
2582 system must allocate the amount of memory specified by the memory size,
2583 but only initialize it with the first "file size" bytes read from the
2584 file. This would occur for example, with program segments consisting
2585 of combined data+bss.
2587 To handle the above situation, this routine generates TWO bfd sections
2588 for the single program segment. The first has the length specified by
2589 the file size of the segment, and the second has the length specified
2590 by the difference between the two sizes. In effect, the segment is split
2591 into it's initialized and uninitialized parts.
2596 _bfd_elf_make_section_from_phdr (bfd *abfd,
2597 Elf_Internal_Phdr *hdr,
2599 const char *typename)
2607 split = ((hdr->p_memsz > 0)
2608 && (hdr->p_filesz > 0)
2609 && (hdr->p_memsz > hdr->p_filesz));
2610 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2611 len = strlen (namebuf) + 1;
2612 name = bfd_alloc (abfd, len);
2615 memcpy (name, namebuf, len);
2616 newsect = bfd_make_section (abfd, name);
2617 if (newsect == NULL)
2619 newsect->vma = hdr->p_vaddr;
2620 newsect->lma = hdr->p_paddr;
2621 newsect->size = hdr->p_filesz;
2622 newsect->filepos = hdr->p_offset;
2623 newsect->flags |= SEC_HAS_CONTENTS;
2624 newsect->alignment_power = bfd_log2 (hdr->p_align);
2625 if (hdr->p_type == PT_LOAD)
2627 newsect->flags |= SEC_ALLOC;
2628 newsect->flags |= SEC_LOAD;
2629 if (hdr->p_flags & PF_X)
2631 /* FIXME: all we known is that it has execute PERMISSION,
2633 newsect->flags |= SEC_CODE;
2636 if (!(hdr->p_flags & PF_W))
2638 newsect->flags |= SEC_READONLY;
2643 sprintf (namebuf, "%s%db", typename, index);
2644 len = strlen (namebuf) + 1;
2645 name = bfd_alloc (abfd, len);
2648 memcpy (name, namebuf, len);
2649 newsect = bfd_make_section (abfd, name);
2650 if (newsect == NULL)
2652 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2653 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2654 newsect->size = hdr->p_memsz - hdr->p_filesz;
2655 if (hdr->p_type == PT_LOAD)
2657 newsect->flags |= SEC_ALLOC;
2658 if (hdr->p_flags & PF_X)
2659 newsect->flags |= SEC_CODE;
2661 if (!(hdr->p_flags & PF_W))
2662 newsect->flags |= SEC_READONLY;
2669 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2671 const struct elf_backend_data *bed;
2673 switch (hdr->p_type)
2676 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2679 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2682 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2685 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2688 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2690 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2695 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2698 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2700 case PT_GNU_EH_FRAME:
2701 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2705 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2708 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2711 /* Check for any processor-specific program segment types. */
2712 bed = get_elf_backend_data (abfd);
2713 return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2717 /* Initialize REL_HDR, the section-header for new section, containing
2718 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2719 relocations; otherwise, we use REL relocations. */
2722 _bfd_elf_init_reloc_shdr (bfd *abfd,
2723 Elf_Internal_Shdr *rel_hdr,
2725 bfd_boolean use_rela_p)
2728 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2729 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2731 name = bfd_alloc (abfd, amt);
2734 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2736 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2738 if (rel_hdr->sh_name == (unsigned int) -1)
2740 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2741 rel_hdr->sh_entsize = (use_rela_p
2742 ? bed->s->sizeof_rela
2743 : bed->s->sizeof_rel);
2744 rel_hdr->sh_addralign = 1 << bed->s->log_file_align;
2745 rel_hdr->sh_flags = 0;
2746 rel_hdr->sh_addr = 0;
2747 rel_hdr->sh_size = 0;
2748 rel_hdr->sh_offset = 0;
2753 /* Set up an ELF internal section header for a section. */
2756 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2758 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2759 bfd_boolean *failedptr = failedptrarg;
2760 Elf_Internal_Shdr *this_hdr;
2761 unsigned int sh_type;
2765 /* We already failed; just get out of the bfd_map_over_sections
2770 this_hdr = &elf_section_data (asect)->this_hdr;
2772 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2773 asect->name, FALSE);
2774 if (this_hdr->sh_name == (unsigned int) -1)
2780 /* Don't clear sh_flags. Assembler may set additional bits. */
2782 if ((asect->flags & SEC_ALLOC) != 0
2783 || asect->user_set_vma)
2784 this_hdr->sh_addr = asect->vma;
2786 this_hdr->sh_addr = 0;
2788 this_hdr->sh_offset = 0;
2789 this_hdr->sh_size = asect->size;
2790 this_hdr->sh_link = 0;
2791 this_hdr->sh_addralign = 1 << asect->alignment_power;
2792 /* The sh_entsize and sh_info fields may have been set already by
2793 copy_private_section_data. */
2795 this_hdr->bfd_section = asect;
2796 this_hdr->contents = NULL;
2798 /* If the section type is unspecified, we set it based on
2800 if (this_hdr->sh_type == SHT_NULL)
2802 if ((asect->flags & SEC_GROUP) != 0)
2803 this_hdr->sh_type = SHT_GROUP;
2804 else if ((asect->flags & SEC_ALLOC) != 0
2805 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2806 || (asect->flags & SEC_NEVER_LOAD) != 0))
2807 this_hdr->sh_type = SHT_NOBITS;
2809 this_hdr->sh_type = SHT_PROGBITS;
2812 switch (this_hdr->sh_type)
2818 case SHT_INIT_ARRAY:
2819 case SHT_FINI_ARRAY:
2820 case SHT_PREINIT_ARRAY:
2827 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2831 this_hdr->sh_entsize = bed->s->sizeof_sym;
2835 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2839 if (get_elf_backend_data (abfd)->may_use_rela_p)
2840 this_hdr->sh_entsize = bed->s->sizeof_rela;
2844 if (get_elf_backend_data (abfd)->may_use_rel_p)
2845 this_hdr->sh_entsize = bed->s->sizeof_rel;
2848 case SHT_GNU_versym:
2849 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2852 case SHT_GNU_verdef:
2853 this_hdr->sh_entsize = 0;
2854 /* objcopy or strip will copy over sh_info, but may not set
2855 cverdefs. The linker will set cverdefs, but sh_info will be
2857 if (this_hdr->sh_info == 0)
2858 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2860 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2861 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2864 case SHT_GNU_verneed:
2865 this_hdr->sh_entsize = 0;
2866 /* objcopy or strip will copy over sh_info, but may not set
2867 cverrefs. The linker will set cverrefs, but sh_info will be
2869 if (this_hdr->sh_info == 0)
2870 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2872 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2873 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2877 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2881 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2885 if ((asect->flags & SEC_ALLOC) != 0)
2886 this_hdr->sh_flags |= SHF_ALLOC;
2887 if ((asect->flags & SEC_READONLY) == 0)
2888 this_hdr->sh_flags |= SHF_WRITE;
2889 if ((asect->flags & SEC_CODE) != 0)
2890 this_hdr->sh_flags |= SHF_EXECINSTR;
2891 if ((asect->flags & SEC_MERGE) != 0)
2893 this_hdr->sh_flags |= SHF_MERGE;
2894 this_hdr->sh_entsize = asect->entsize;
2895 if ((asect->flags & SEC_STRINGS) != 0)
2896 this_hdr->sh_flags |= SHF_STRINGS;
2898 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2899 this_hdr->sh_flags |= SHF_GROUP;
2900 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2902 this_hdr->sh_flags |= SHF_TLS;
2903 if (asect->size == 0
2904 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2906 struct bfd_link_order *o = asect->map_tail.link_order;
2908 this_hdr->sh_size = 0;
2911 this_hdr->sh_size = o->offset + o->size;
2912 if (this_hdr->sh_size != 0)
2913 this_hdr->sh_type = SHT_NOBITS;
2918 /* Check for processor-specific section types. */
2919 sh_type = this_hdr->sh_type;
2920 if (bed->elf_backend_fake_sections
2921 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2924 if (sh_type == SHT_NOBITS && asect->size != 0)
2926 /* Don't change the header type from NOBITS if we are being
2927 called for objcopy --only-keep-debug. */
2928 this_hdr->sh_type = sh_type;
2931 /* If the section has relocs, set up a section header for the
2932 SHT_REL[A] section. If two relocation sections are required for
2933 this section, it is up to the processor-specific back-end to
2934 create the other. */
2935 if ((asect->flags & SEC_RELOC) != 0
2936 && !_bfd_elf_init_reloc_shdr (abfd,
2937 &elf_section_data (asect)->rel_hdr,
2943 /* Fill in the contents of a SHT_GROUP section. */
2946 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2948 bfd_boolean *failedptr = failedptrarg;
2949 unsigned long symindx;
2950 asection *elt, *first;
2954 /* Ignore linker created group section. See elfNN_ia64_object_p in
2956 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2961 if (elf_group_id (sec) != NULL)
2962 symindx = elf_group_id (sec)->udata.i;
2966 /* If called from the assembler, swap_out_syms will have set up
2967 elf_section_syms; If called for "ld -r", use target_index. */
2968 if (elf_section_syms (abfd) != NULL)
2969 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2971 symindx = sec->target_index;
2973 elf_section_data (sec)->this_hdr.sh_info = symindx;
2975 /* The contents won't be allocated for "ld -r" or objcopy. */
2977 if (sec->contents == NULL)
2980 sec->contents = bfd_alloc (abfd, sec->size);
2982 /* Arrange for the section to be written out. */
2983 elf_section_data (sec)->this_hdr.contents = sec->contents;
2984 if (sec->contents == NULL)
2991 loc = sec->contents + sec->size;
2993 /* Get the pointer to the first section in the group that gas
2994 squirreled away here. objcopy arranges for this to be set to the
2995 start of the input section group. */
2996 first = elt = elf_next_in_group (sec);
2998 /* First element is a flag word. Rest of section is elf section
2999 indices for all the sections of the group. Write them backwards
3000 just to keep the group in the same order as given in .section
3001 directives, not that it matters. */
3010 s = s->output_section;
3013 idx = elf_section_data (s)->this_idx;
3014 H_PUT_32 (abfd, idx, loc);
3015 elt = elf_next_in_group (elt);
3020 if ((loc -= 4) != sec->contents)
3023 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
3026 /* Assign all ELF section numbers. The dummy first section is handled here
3027 too. The link/info pointers for the standard section types are filled
3028 in here too, while we're at it. */
3031 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
3033 struct elf_obj_tdata *t = elf_tdata (abfd);
3035 unsigned int section_number, secn;
3036 Elf_Internal_Shdr **i_shdrp;
3037 struct bfd_elf_section_data *d;
3041 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
3043 /* SHT_GROUP sections are in relocatable files only. */
3044 if (link_info == NULL || link_info->relocatable)
3046 /* Put SHT_GROUP sections first. */
3047 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3049 d = elf_section_data (sec);
3051 if (d->this_hdr.sh_type == SHT_GROUP)
3053 if (sec->flags & SEC_LINKER_CREATED)
3055 /* Remove the linker created SHT_GROUP sections. */
3056 bfd_section_list_remove (abfd, sec);
3057 abfd->section_count--;
3061 if (section_number == SHN_LORESERVE)
3062 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3063 d->this_idx = section_number++;
3069 for (sec = abfd->sections; sec; sec = sec->next)
3071 d = elf_section_data (sec);
3073 if (d->this_hdr.sh_type != SHT_GROUP)
3075 if (section_number == SHN_LORESERVE)
3076 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3077 d->this_idx = section_number++;
3079 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
3080 if ((sec->flags & SEC_RELOC) == 0)
3084 if (section_number == SHN_LORESERVE)
3085 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3086 d->rel_idx = section_number++;
3087 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
3092 if (section_number == SHN_LORESERVE)
3093 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3094 d->rel_idx2 = section_number++;
3095 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
3101 if (section_number == SHN_LORESERVE)
3102 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3103 t->shstrtab_section = section_number++;
3104 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
3105 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
3107 if (bfd_get_symcount (abfd) > 0)
3109 if (section_number == SHN_LORESERVE)
3110 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3111 t->symtab_section = section_number++;
3112 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
3113 if (section_number > SHN_LORESERVE - 2)
3115 if (section_number == SHN_LORESERVE)
3116 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3117 t->symtab_shndx_section = section_number++;
3118 t->symtab_shndx_hdr.sh_name
3119 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
3120 ".symtab_shndx", FALSE);
3121 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
3124 if (section_number == SHN_LORESERVE)
3125 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
3126 t->strtab_section = section_number++;
3127 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
3130 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3131 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3133 elf_numsections (abfd) = section_number;
3134 elf_elfheader (abfd)->e_shnum = section_number;
3135 if (section_number > SHN_LORESERVE)
3136 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
3138 /* Set up the list of section header pointers, in agreement with the
3140 i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
3141 if (i_shdrp == NULL)
3144 i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
3145 if (i_shdrp[0] == NULL)
3147 bfd_release (abfd, i_shdrp);
3151 elf_elfsections (abfd) = i_shdrp;
3153 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3154 if (bfd_get_symcount (abfd) > 0)
3156 i_shdrp[t->symtab_section] = &t->symtab_hdr;
3157 if (elf_numsections (abfd) > SHN_LORESERVE)
3159 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3160 t->symtab_shndx_hdr.sh_link = t->symtab_section;
3162 i_shdrp[t->strtab_section] = &t->strtab_hdr;
3163 t->symtab_hdr.sh_link = t->strtab_section;
3166 for (sec = abfd->sections; sec; sec = sec->next)
3168 struct bfd_elf_section_data *d = elf_section_data (sec);
3172 i_shdrp[d->this_idx] = &d->this_hdr;
3173 if (d->rel_idx != 0)
3174 i_shdrp[d->rel_idx] = &d->rel_hdr;
3175 if (d->rel_idx2 != 0)
3176 i_shdrp[d->rel_idx2] = d->rel_hdr2;
3178 /* Fill in the sh_link and sh_info fields while we're at it. */
3180 /* sh_link of a reloc section is the section index of the symbol
3181 table. sh_info is the section index of the section to which
3182 the relocation entries apply. */
3183 if (d->rel_idx != 0)
3185 d->rel_hdr.sh_link = t->symtab_section;
3186 d->rel_hdr.sh_info = d->this_idx;
3188 if (d->rel_idx2 != 0)
3190 d->rel_hdr2->sh_link = t->symtab_section;
3191 d->rel_hdr2->sh_info = d->this_idx;
3194 /* We need to set up sh_link for SHF_LINK_ORDER. */
3195 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3197 s = elf_linked_to_section (sec);
3200 /* elf_linked_to_section points to the input section. */
3201 if (link_info != NULL)
3203 /* Check discarded linkonce section. */
3204 if (elf_discarded_section (s))
3207 (*_bfd_error_handler)
3208 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3209 abfd, d->this_hdr.bfd_section,
3211 /* Point to the kept section if it has the same
3212 size as the discarded one. */
3213 kept = _bfd_elf_check_kept_section (s, link_info);
3216 bfd_set_error (bfd_error_bad_value);
3222 s = s->output_section;
3223 BFD_ASSERT (s != NULL);
3227 /* Handle objcopy. */
3228 if (s->output_section == NULL)
3230 (*_bfd_error_handler)
3231 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3232 abfd, d->this_hdr.bfd_section, s, s->owner);
3233 bfd_set_error (bfd_error_bad_value);
3236 s = s->output_section;
3238 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3243 The Intel C compiler generates SHT_IA_64_UNWIND with
3244 SHF_LINK_ORDER. But it doesn't set the sh_link or
3245 sh_info fields. Hence we could get the situation
3247 const struct elf_backend_data *bed
3248 = get_elf_backend_data (abfd);
3249 if (bed->link_order_error_handler)
3250 bed->link_order_error_handler
3251 (_("%B: warning: sh_link not set for section `%A'"),
3256 switch (d->this_hdr.sh_type)
3260 /* A reloc section which we are treating as a normal BFD
3261 section. sh_link is the section index of the symbol
3262 table. sh_info is the section index of the section to
3263 which the relocation entries apply. We assume that an
3264 allocated reloc section uses the dynamic symbol table.
3265 FIXME: How can we be sure? */
3266 s = bfd_get_section_by_name (abfd, ".dynsym");
3268 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3270 /* We look up the section the relocs apply to by name. */
3272 if (d->this_hdr.sh_type == SHT_REL)
3276 s = bfd_get_section_by_name (abfd, name);
3278 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3282 /* We assume that a section named .stab*str is a stabs
3283 string section. We look for a section with the same name
3284 but without the trailing ``str'', and set its sh_link
3285 field to point to this section. */
3286 if (CONST_STRNEQ (sec->name, ".stab")
3287 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3292 len = strlen (sec->name);
3293 alc = bfd_malloc (len - 2);
3296 memcpy (alc, sec->name, len - 3);
3297 alc[len - 3] = '\0';
3298 s = bfd_get_section_by_name (abfd, alc);
3302 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3304 /* This is a .stab section. */
3305 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3306 elf_section_data (s)->this_hdr.sh_entsize
3307 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3314 case SHT_GNU_verneed:
3315 case SHT_GNU_verdef:
3316 /* sh_link is the section header index of the string table
3317 used for the dynamic entries, or the symbol table, or the
3319 s = bfd_get_section_by_name (abfd, ".dynstr");
3321 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3324 case SHT_GNU_LIBLIST:
3325 /* sh_link is the section header index of the prelink library
3326 list used for the dynamic entries, or the symbol table, or
3327 the version strings. */
3328 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3329 ? ".dynstr" : ".gnu.libstr");
3331 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3336 case SHT_GNU_versym:
3337 /* sh_link is the section header index of the symbol table
3338 this hash table or version table is for. */
3339 s = bfd_get_section_by_name (abfd, ".dynsym");
3341 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3345 d->this_hdr.sh_link = t->symtab_section;
3349 for (secn = 1; secn < section_number; ++secn)
3350 if (i_shdrp[secn] == NULL)
3351 i_shdrp[secn] = i_shdrp[0];
3353 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3354 i_shdrp[secn]->sh_name);
3358 /* Map symbol from it's internal number to the external number, moving
3359 all local symbols to be at the head of the list. */
3362 sym_is_global (bfd *abfd, asymbol *sym)
3364 /* If the backend has a special mapping, use it. */
3365 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3366 if (bed->elf_backend_sym_is_global)
3367 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3369 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3370 || bfd_is_und_section (bfd_get_section (sym))
3371 || bfd_is_com_section (bfd_get_section (sym)));
3374 /* Don't output section symbols for sections that are not going to be
3375 output. Also, don't output section symbols for reloc and other
3376 special sections. */
3379 ignore_section_sym (bfd *abfd, asymbol *sym)
3381 return ((sym->flags & BSF_SECTION_SYM) != 0
3383 || (sym->section->owner != abfd
3384 && (sym->section->output_section->owner != abfd
3385 || sym->section->output_offset != 0))));
3389 elf_map_symbols (bfd *abfd)
3391 unsigned int symcount = bfd_get_symcount (abfd);
3392 asymbol **syms = bfd_get_outsymbols (abfd);
3393 asymbol **sect_syms;
3394 unsigned int num_locals = 0;
3395 unsigned int num_globals = 0;
3396 unsigned int num_locals2 = 0;
3397 unsigned int num_globals2 = 0;
3404 fprintf (stderr, "elf_map_symbols\n");
3408 for (asect = abfd->sections; asect; asect = asect->next)
3410 if (max_index < asect->index)
3411 max_index = asect->index;
3415 sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3416 if (sect_syms == NULL)
3418 elf_section_syms (abfd) = sect_syms;
3419 elf_num_section_syms (abfd) = max_index;
3421 /* Init sect_syms entries for any section symbols we have already
3422 decided to output. */
3423 for (idx = 0; idx < symcount; idx++)
3425 asymbol *sym = syms[idx];
3427 if ((sym->flags & BSF_SECTION_SYM) != 0
3428 && !ignore_section_sym (abfd, sym))
3430 asection *sec = sym->section;
3432 if (sec->owner != abfd)
3433 sec = sec->output_section;
3435 sect_syms[sec->index] = syms[idx];
3439 /* Classify all of the symbols. */
3440 for (idx = 0; idx < symcount; idx++)
3442 if (ignore_section_sym (abfd, syms[idx]))
3444 if (!sym_is_global (abfd, syms[idx]))
3450 /* We will be adding a section symbol for each normal BFD section. Most
3451 sections will already have a section symbol in outsymbols, but
3452 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3453 at least in that case. */
3454 for (asect = abfd->sections; asect; asect = asect->next)
3456 if (sect_syms[asect->index] == NULL)
3458 if (!sym_is_global (abfd, asect->symbol))
3465 /* Now sort the symbols so the local symbols are first. */
3466 new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
3468 if (new_syms == NULL)
3471 for (idx = 0; idx < symcount; idx++)
3473 asymbol *sym = syms[idx];
3476 if (ignore_section_sym (abfd, sym))
3478 if (!sym_is_global (abfd, sym))
3481 i = num_locals + num_globals2++;
3483 sym->udata.i = i + 1;
3485 for (asect = abfd->sections; asect; asect = asect->next)
3487 if (sect_syms[asect->index] == NULL)
3489 asymbol *sym = asect->symbol;
3492 sect_syms[asect->index] = sym;
3493 if (!sym_is_global (abfd, sym))
3496 i = num_locals + num_globals2++;
3498 sym->udata.i = i + 1;
3502 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3504 elf_num_locals (abfd) = num_locals;
3505 elf_num_globals (abfd) = num_globals;
3509 /* Align to the maximum file alignment that could be required for any
3510 ELF data structure. */
3512 static inline file_ptr
3513 align_file_position (file_ptr off, int align)
3515 return (off + align - 1) & ~(align - 1);
3518 /* Assign a file position to a section, optionally aligning to the
3519 required section alignment. */
3522 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3530 al = i_shdrp->sh_addralign;
3532 offset = BFD_ALIGN (offset, al);
3534 i_shdrp->sh_offset = offset;
3535 if (i_shdrp->bfd_section != NULL)
3536 i_shdrp->bfd_section->filepos = offset;
3537 if (i_shdrp->sh_type != SHT_NOBITS)
3538 offset += i_shdrp->sh_size;
3542 /* Compute the file positions we are going to put the sections at, and
3543 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3544 is not NULL, this is being called by the ELF backend linker. */
3547 _bfd_elf_compute_section_file_positions (bfd *abfd,
3548 struct bfd_link_info *link_info)
3550 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3552 struct bfd_strtab_hash *strtab = NULL;
3553 Elf_Internal_Shdr *shstrtab_hdr;
3555 if (abfd->output_has_begun)
3558 /* Do any elf backend specific processing first. */
3559 if (bed->elf_backend_begin_write_processing)
3560 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3562 if (! prep_headers (abfd))
3565 /* Post process the headers if necessary. */
3566 if (bed->elf_backend_post_process_headers)
3567 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3570 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3574 if (!assign_section_numbers (abfd, link_info))
3577 /* The backend linker builds symbol table information itself. */
3578 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3580 /* Non-zero if doing a relocatable link. */
3581 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3583 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3587 if (link_info == NULL)
3589 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3594 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3595 /* sh_name was set in prep_headers. */
3596 shstrtab_hdr->sh_type = SHT_STRTAB;
3597 shstrtab_hdr->sh_flags = 0;
3598 shstrtab_hdr->sh_addr = 0;
3599 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3600 shstrtab_hdr->sh_entsize = 0;
3601 shstrtab_hdr->sh_link = 0;
3602 shstrtab_hdr->sh_info = 0;
3603 /* sh_offset is set in assign_file_positions_except_relocs. */
3604 shstrtab_hdr->sh_addralign = 1;
3606 if (!assign_file_positions_except_relocs (abfd, link_info))
3609 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3612 Elf_Internal_Shdr *hdr;
3614 off = elf_tdata (abfd)->next_file_pos;
3616 hdr = &elf_tdata (abfd)->symtab_hdr;
3617 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3619 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3620 if (hdr->sh_size != 0)
3621 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3623 hdr = &elf_tdata (abfd)->strtab_hdr;
3624 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3626 elf_tdata (abfd)->next_file_pos = off;
3628 /* Now that we know where the .strtab section goes, write it
3630 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3631 || ! _bfd_stringtab_emit (abfd, strtab))
3633 _bfd_stringtab_free (strtab);
3636 abfd->output_has_begun = TRUE;
3641 /* Make an initial estimate of the size of the program header. If we
3642 get the number wrong here, we'll redo section placement. */
3644 static bfd_size_type
3645 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3649 const struct elf_backend_data *bed;
3651 /* Assume we will need exactly two PT_LOAD segments: one for text
3652 and one for data. */
3655 s = bfd_get_section_by_name (abfd, ".interp");
3656 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3658 /* If we have a loadable interpreter section, we need a
3659 PT_INTERP segment. In this case, assume we also need a
3660 PT_PHDR segment, although that may not be true for all
3665 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3667 /* We need a PT_DYNAMIC segment. */
3670 if (elf_tdata (abfd)->relro)
3672 /* We need a PT_GNU_RELRO segment only when there is a
3673 PT_DYNAMIC segment. */
3678 if (elf_tdata (abfd)->eh_frame_hdr)
3680 /* We need a PT_GNU_EH_FRAME segment. */
3684 if (elf_tdata (abfd)->stack_flags)
3686 /* We need a PT_GNU_STACK segment. */
3690 for (s = abfd->sections; s != NULL; s = s->next)
3692 if ((s->flags & SEC_LOAD) != 0
3693 && CONST_STRNEQ (s->name, ".note"))
3695 /* We need a PT_NOTE segment. */
3700 for (s = abfd->sections; s != NULL; s = s->next)
3702 if (s->flags & SEC_THREAD_LOCAL)
3704 /* We need a PT_TLS segment. */
3710 /* Let the backend count up any program headers it might need. */
3711 bed = get_elf_backend_data (abfd);
3712 if (bed->elf_backend_additional_program_headers)
3716 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3722 return segs * bed->s->sizeof_phdr;
3725 /* Create a mapping from a set of sections to a program segment. */
3727 static struct elf_segment_map *
3728 make_mapping (bfd *abfd,
3729 asection **sections,
3734 struct elf_segment_map *m;
3739 amt = sizeof (struct elf_segment_map);
3740 amt += (to - from - 1) * sizeof (asection *);
3741 m = bfd_zalloc (abfd, amt);
3745 m->p_type = PT_LOAD;
3746 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3747 m->sections[i - from] = *hdrpp;
3748 m->count = to - from;
3750 if (from == 0 && phdr)
3752 /* Include the headers in the first PT_LOAD segment. */
3753 m->includes_filehdr = 1;
3754 m->includes_phdrs = 1;
3760 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3763 struct elf_segment_map *
3764 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3766 struct elf_segment_map *m;
3768 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3772 m->p_type = PT_DYNAMIC;
3774 m->sections[0] = dynsec;
3779 /* Possibly add or remove segments from the segment map. */
3782 elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
3784 struct elf_segment_map **m;
3785 const struct elf_backend_data *bed;
3787 /* The placement algorithm assumes that non allocated sections are
3788 not in PT_LOAD segments. We ensure this here by removing such
3789 sections from the segment map. We also remove excluded
3790 sections. Finally, any PT_LOAD segment without sections is
3792 m = &elf_tdata (abfd)->segment_map;
3795 unsigned int i, new_count;
3797 for (new_count = 0, i = 0; i < (*m)->count; i++)
3799 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3800 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3801 || (*m)->p_type != PT_LOAD))
3803 (*m)->sections[new_count] = (*m)->sections[i];
3807 (*m)->count = new_count;
3809 if ((*m)->p_type == PT_LOAD && (*m)->count == 0)
3815 bed = get_elf_backend_data (abfd);
3816 if (bed->elf_backend_modify_segment_map != NULL)
3818 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3825 /* Set up a mapping from BFD sections to program segments. */
3828 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3831 struct elf_segment_map *m;
3832 asection **sections = NULL;
3833 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3835 if (elf_tdata (abfd)->segment_map == NULL
3836 && bfd_count_sections (abfd) != 0)
3840 struct elf_segment_map *mfirst;
3841 struct elf_segment_map **pm;
3844 unsigned int phdr_index;
3845 bfd_vma maxpagesize;
3847 bfd_boolean phdr_in_segment = TRUE;
3848 bfd_boolean writable;
3850 asection *first_tls = NULL;
3851 asection *dynsec, *eh_frame_hdr;
3854 /* Select the allocated sections, and sort them. */
3856 sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3857 if (sections == NULL)
3861 for (s = abfd->sections; s != NULL; s = s->next)
3863 if ((s->flags & SEC_ALLOC) != 0)
3869 BFD_ASSERT (i <= bfd_count_sections (abfd));
3872 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3874 /* Build the mapping. */
3879 /* If we have a .interp section, then create a PT_PHDR segment for
3880 the program headers and a PT_INTERP segment for the .interp
3882 s = bfd_get_section_by_name (abfd, ".interp");
3883 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3885 amt = sizeof (struct elf_segment_map);
3886 m = bfd_zalloc (abfd, amt);
3890 m->p_type = PT_PHDR;
3891 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3892 m->p_flags = PF_R | PF_X;
3893 m->p_flags_valid = 1;
3894 m->includes_phdrs = 1;
3899 amt = sizeof (struct elf_segment_map);
3900 m = bfd_zalloc (abfd, amt);
3904 m->p_type = PT_INTERP;
3912 /* Look through the sections. We put sections in the same program
3913 segment when the start of the second section can be placed within
3914 a few bytes of the end of the first section. */
3918 maxpagesize = bed->maxpagesize;
3920 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3922 && (dynsec->flags & SEC_LOAD) == 0)
3925 /* Deal with -Ttext or something similar such that the first section
3926 is not adjacent to the program headers. This is an
3927 approximation, since at this point we don't know exactly how many
3928 program headers we will need. */
3931 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3933 if (phdr_size == (bfd_size_type) -1)
3934 phdr_size = get_program_header_size (abfd, info);
3935 if ((abfd->flags & D_PAGED) == 0
3936 || sections[0]->lma < phdr_size
3937 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3938 phdr_in_segment = FALSE;
3941 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3944 bfd_boolean new_segment;
3948 /* See if this section and the last one will fit in the same
3951 if (last_hdr == NULL)
3953 /* If we don't have a segment yet, then we don't need a new
3954 one (we build the last one after this loop). */
3955 new_segment = FALSE;
3957 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3959 /* If this section has a different relation between the
3960 virtual address and the load address, then we need a new
3964 else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3965 < BFD_ALIGN (hdr->lma, maxpagesize))
3967 /* If putting this section in this segment would force us to
3968 skip a page in the segment, then we need a new segment. */
3971 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3972 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3974 /* We don't want to put a loadable section after a
3975 nonloadable section in the same segment.
3976 Consider .tbss sections as loadable for this purpose. */
3979 else if ((abfd->flags & D_PAGED) == 0)
3981 /* If the file is not demand paged, which means that we
3982 don't require the sections to be correctly aligned in the
3983 file, then there is no other reason for a new segment. */
3984 new_segment = FALSE;
3987 && (hdr->flags & SEC_READONLY) == 0
3988 && (((last_hdr->lma + last_size - 1)
3989 & ~(maxpagesize - 1))
3990 != (hdr->lma & ~(maxpagesize - 1))))
3992 /* We don't want to put a writable section in a read only
3993 segment, unless they are on the same page in memory
3994 anyhow. We already know that the last section does not
3995 bring us past the current section on the page, so the
3996 only case in which the new section is not on the same
3997 page as the previous section is when the previous section
3998 ends precisely on a page boundary. */
4003 /* Otherwise, we can use the same segment. */
4004 new_segment = FALSE;
4007 /* Allow interested parties a chance to override our decision. */
4008 if (last_hdr && info->callbacks->override_segment_assignment)
4009 new_segment = info->callbacks->override_segment_assignment (info, abfd, hdr, last_hdr, new_segment);
4013 if ((hdr->flags & SEC_READONLY) == 0)
4016 /* .tbss sections effectively have zero size. */
4017 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
4018 != SEC_THREAD_LOCAL)
4019 last_size = hdr->size;
4025 /* We need a new program segment. We must create a new program
4026 header holding all the sections from phdr_index until hdr. */
4028 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4035 if ((hdr->flags & SEC_READONLY) == 0)
4041 /* .tbss sections effectively have zero size. */
4042 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
4043 last_size = hdr->size;
4047 phdr_in_segment = FALSE;
4050 /* Create a final PT_LOAD program segment. */
4051 if (last_hdr != NULL)
4053 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4061 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4064 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4071 /* For each loadable .note section, add a PT_NOTE segment. We don't
4072 use bfd_get_section_by_name, because if we link together
4073 nonloadable .note sections and loadable .note sections, we will
4074 generate two .note sections in the output file. FIXME: Using
4075 names for section types is bogus anyhow. */
4076 for (s = abfd->sections; s != NULL; s = s->next)
4078 if ((s->flags & SEC_LOAD) != 0
4079 && CONST_STRNEQ (s->name, ".note"))
4081 amt = sizeof (struct elf_segment_map);
4082 m = bfd_zalloc (abfd, amt);
4086 m->p_type = PT_NOTE;
4093 if (s->flags & SEC_THREAD_LOCAL)
4101 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4106 amt = sizeof (struct elf_segment_map);
4107 amt += (tls_count - 1) * sizeof (asection *);
4108 m = bfd_zalloc (abfd, amt);
4113 m->count = tls_count;
4114 /* Mandated PF_R. */
4116 m->p_flags_valid = 1;
4117 for (i = 0; i < tls_count; ++i)
4119 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
4120 m->sections[i] = first_tls;
4121 first_tls = first_tls->next;
4128 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4130 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
4131 if (eh_frame_hdr != NULL
4132 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4134 amt = sizeof (struct elf_segment_map);
4135 m = bfd_zalloc (abfd, amt);
4139 m->p_type = PT_GNU_EH_FRAME;
4141 m->sections[0] = eh_frame_hdr->output_section;
4147 if (elf_tdata (abfd)->stack_flags)
4149 amt = sizeof (struct elf_segment_map);
4150 m = bfd_zalloc (abfd, amt);
4154 m->p_type = PT_GNU_STACK;
4155 m->p_flags = elf_tdata (abfd)->stack_flags;
4156 m->p_flags_valid = 1;
4162 if (dynsec != NULL && elf_tdata (abfd)->relro)
4164 /* We make a PT_GNU_RELRO segment only when there is a
4165 PT_DYNAMIC segment. */
4166 amt = sizeof (struct elf_segment_map);
4167 m = bfd_zalloc (abfd, amt);
4171 m->p_type = PT_GNU_RELRO;
4173 m->p_flags_valid = 1;
4180 elf_tdata (abfd)->segment_map = mfirst;
4183 if (!elf_modify_segment_map (abfd, info))
4186 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4188 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
4193 if (sections != NULL)
4198 /* Sort sections by address. */
4201 elf_sort_sections (const void *arg1, const void *arg2)
4203 const asection *sec1 = *(const asection **) arg1;
4204 const asection *sec2 = *(const asection **) arg2;
4205 bfd_size_type size1, size2;
4207 /* Sort by LMA first, since this is the address used to
4208 place the section into a segment. */
4209 if (sec1->lma < sec2->lma)
4211 else if (sec1->lma > sec2->lma)
4214 /* Then sort by VMA. Normally the LMA and the VMA will be
4215 the same, and this will do nothing. */
4216 if (sec1->vma < sec2->vma)
4218 else if (sec1->vma > sec2->vma)
4221 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4223 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4229 /* If the indicies are the same, do not return 0
4230 here, but continue to try the next comparison. */
4231 if (sec1->target_index - sec2->target_index != 0)
4232 return sec1->target_index - sec2->target_index;
4237 else if (TOEND (sec2))
4242 /* Sort by size, to put zero sized sections
4243 before others at the same address. */
4245 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4246 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4253 return sec1->target_index - sec2->target_index;
4256 /* Ian Lance Taylor writes:
4258 We shouldn't be using % with a negative signed number. That's just
4259 not good. We have to make sure either that the number is not
4260 negative, or that the number has an unsigned type. When the types
4261 are all the same size they wind up as unsigned. When file_ptr is a
4262 larger signed type, the arithmetic winds up as signed long long,
4265 What we're trying to say here is something like ``increase OFF by
4266 the least amount that will cause it to be equal to the VMA modulo
4268 /* In other words, something like:
4270 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4271 off_offset = off % bed->maxpagesize;
4272 if (vma_offset < off_offset)
4273 adjustment = vma_offset + bed->maxpagesize - off_offset;
4275 adjustment = vma_offset - off_offset;
4277 which can can be collapsed into the expression below. */
4280 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4282 return ((vma - off) % maxpagesize);
4285 /* Assign file positions to the sections based on the mapping from
4286 sections to segments. This function also sets up some fields in
4290 assign_file_positions_for_load_sections (bfd *abfd,
4291 struct bfd_link_info *link_info)
4293 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4294 struct elf_segment_map *m;
4295 Elf_Internal_Phdr *phdrs;
4296 Elf_Internal_Phdr *p;
4298 bfd_size_type maxpagesize;
4302 if (link_info == NULL
4303 && !elf_modify_segment_map (abfd, link_info))
4307 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4310 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4311 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4312 elf_elfheader (abfd)->e_phnum = alloc;
4314 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4315 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4317 BFD_ASSERT (elf_tdata (abfd)->program_header_size
4318 >= alloc * bed->s->sizeof_phdr);
4322 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4326 phdrs = bfd_alloc2 (abfd, alloc, sizeof (Elf_Internal_Phdr));
4327 elf_tdata (abfd)->phdr = phdrs;
4332 if ((abfd->flags & D_PAGED) != 0)
4333 maxpagesize = bed->maxpagesize;
4335 off = bed->s->sizeof_ehdr;
4336 off += alloc * bed->s->sizeof_phdr;
4338 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4340 m = m->next, p++, j++)
4344 bfd_boolean no_contents;
4346 /* If elf_segment_map is not from map_sections_to_segments, the
4347 sections may not be correctly ordered. NOTE: sorting should
4348 not be done to the PT_NOTE section of a corefile, which may
4349 contain several pseudo-sections artificially created by bfd.
4350 Sorting these pseudo-sections breaks things badly. */
4352 && !(elf_elfheader (abfd)->e_type == ET_CORE
4353 && m->p_type == PT_NOTE))
4354 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4357 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4358 number of sections with contents contributing to both p_filesz
4359 and p_memsz, followed by a number of sections with no contents
4360 that just contribute to p_memsz. In this loop, OFF tracks next
4361 available file offset for PT_LOAD and PT_NOTE segments. */
4362 p->p_type = m->p_type;
4363 p->p_flags = m->p_flags;
4368 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4370 if (m->p_paddr_valid)
4371 p->p_paddr = m->p_paddr;
4372 else if (m->count == 0)
4375 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4377 if (p->p_type == PT_LOAD
4378 && (abfd->flags & D_PAGED) != 0)
4380 /* p_align in demand paged PT_LOAD segments effectively stores
4381 the maximum page size. When copying an executable with
4382 objcopy, we set m->p_align from the input file. Use this
4383 value for maxpagesize rather than bed->maxpagesize, which
4384 may be different. Note that we use maxpagesize for PT_TLS
4385 segment alignment later in this function, so we are relying
4386 on at least one PT_LOAD segment appearing before a PT_TLS
4388 if (m->p_align_valid)
4389 maxpagesize = m->p_align;
4391 p->p_align = maxpagesize;
4393 else if (m->count == 0)
4394 p->p_align = 1 << bed->s->log_file_align;
4395 else if (m->p_align_valid)
4396 p->p_align = m->p_align;
4400 no_contents = FALSE;
4402 if (p->p_type == PT_LOAD
4405 bfd_size_type align;
4406 unsigned int align_power = 0;
4408 if (m->p_align_valid)
4412 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4414 unsigned int secalign;
4416 secalign = bfd_get_section_alignment (abfd, *secpp);
4417 if (secalign > align_power)
4418 align_power = secalign;
4420 align = (bfd_size_type) 1 << align_power;
4421 if (align < maxpagesize)
4422 align = maxpagesize;
4425 for (i = 0; i < m->count; i++)
4426 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4427 /* If we aren't making room for this section, then
4428 it must be SHT_NOBITS regardless of what we've
4429 set via struct bfd_elf_special_section. */
4430 elf_section_type (m->sections[i]) = SHT_NOBITS;
4432 /* Find out whether this segment contains any loadable
4433 sections. If the first section isn't loadable, the same
4434 holds for any other sections. */
4436 while (elf_section_type (m->sections[i]) == SHT_NOBITS)
4438 /* If a segment starts with .tbss, we need to look
4439 at the next section to decide whether the segment
4440 has any loadable sections. */
4441 if ((elf_section_flags (m->sections[i]) & SHF_TLS) == 0
4449 off_adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4453 /* We shouldn't need to align the segment on disk since
4454 the segment doesn't need file space, but the gABI
4455 arguably requires the alignment and glibc ld.so
4456 checks it. So to comply with the alignment
4457 requirement but not waste file space, we adjust
4458 p_offset for just this segment. (OFF_ADJUST is
4459 subtracted from OFF later.) This may put p_offset
4460 past the end of file, but that shouldn't matter. */
4465 /* Make sure the .dynamic section is the first section in the
4466 PT_DYNAMIC segment. */
4467 else if (p->p_type == PT_DYNAMIC
4469 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4472 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4474 bfd_set_error (bfd_error_bad_value);
4482 if (m->includes_filehdr)
4484 if (!m->p_flags_valid)
4486 p->p_filesz = bed->s->sizeof_ehdr;
4487 p->p_memsz = bed->s->sizeof_ehdr;
4490 BFD_ASSERT (p->p_type == PT_LOAD);
4492 if (p->p_vaddr < (bfd_vma) off)
4494 (*_bfd_error_handler)
4495 (_("%B: Not enough room for program headers, try linking with -N"),
4497 bfd_set_error (bfd_error_bad_value);
4502 if (!m->p_paddr_valid)
4507 if (m->includes_phdrs)
4509 if (!m->p_flags_valid)
4512 if (!m->includes_filehdr)
4514 p->p_offset = bed->s->sizeof_ehdr;
4518 BFD_ASSERT (p->p_type == PT_LOAD);
4519 p->p_vaddr -= off - p->p_offset;
4520 if (!m->p_paddr_valid)
4521 p->p_paddr -= off - p->p_offset;
4525 p->p_filesz += alloc * bed->s->sizeof_phdr;
4526 p->p_memsz += alloc * bed->s->sizeof_phdr;
4529 if (p->p_type == PT_LOAD
4530 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4532 if (!m->includes_filehdr && !m->includes_phdrs)
4538 adjust = off - (p->p_offset + p->p_filesz);
4540 p->p_filesz += adjust;
4541 p->p_memsz += adjust;
4545 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4546 maps. Set filepos for sections in PT_LOAD segments, and in
4547 core files, for sections in PT_NOTE segments.
4548 assign_file_positions_for_non_load_sections will set filepos
4549 for other sections and update p_filesz for other segments. */
4550 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4553 bfd_size_type align;
4554 Elf_Internal_Shdr *this_hdr;
4557 this_hdr = &elf_section_data (sec)->this_hdr;
4558 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4560 if (p->p_type == PT_LOAD
4561 || p->p_type == PT_TLS)
4563 bfd_signed_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
4565 if (this_hdr->sh_type != SHT_NOBITS
4566 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4567 && ((this_hdr->sh_flags & SHF_TLS) == 0
4568 || p->p_type == PT_TLS)))
4572 (*_bfd_error_handler)
4573 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4574 abfd, sec, (unsigned long) sec->lma);
4577 p->p_memsz += adjust;
4579 if (this_hdr->sh_type != SHT_NOBITS)
4582 p->p_filesz += adjust;
4587 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4589 /* The section at i == 0 is the one that actually contains
4593 this_hdr->sh_offset = sec->filepos = off;
4594 off += this_hdr->sh_size;
4595 p->p_filesz = this_hdr->sh_size;
4601 /* The rest are fake sections that shouldn't be written. */
4610 if (p->p_type == PT_LOAD)
4612 this_hdr->sh_offset = sec->filepos = off;
4613 if (this_hdr->sh_type != SHT_NOBITS)
4614 off += this_hdr->sh_size;
4617 if (this_hdr->sh_type != SHT_NOBITS)
4619 p->p_filesz += this_hdr->sh_size;
4620 /* A load section without SHF_ALLOC is something like
4621 a note section in a PT_NOTE segment. These take
4622 file space but are not loaded into memory. */
4623 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4624 p->p_memsz += this_hdr->sh_size;
4626 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4628 if (p->p_type == PT_TLS)
4629 p->p_memsz += this_hdr->sh_size;
4631 /* .tbss is special. It doesn't contribute to p_memsz of
4633 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4634 p->p_memsz += this_hdr->sh_size;
4637 if (p->p_type == PT_GNU_RELRO)
4639 else if (align > p->p_align
4640 && !m->p_align_valid
4641 && (p->p_type != PT_LOAD
4642 || (abfd->flags & D_PAGED) == 0))
4646 if (!m->p_flags_valid)
4649 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4651 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4657 /* Check that all sections are in a PT_LOAD segment.
4658 Don't check funky gdb generated core files. */
4659 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4660 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4662 Elf_Internal_Shdr *this_hdr;
4666 this_hdr = &(elf_section_data(sec)->this_hdr);
4667 if (this_hdr->sh_size != 0
4668 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4670 (*_bfd_error_handler)
4671 (_("%B: section `%A' can't be allocated in segment %d"),
4673 bfd_set_error (bfd_error_bad_value);
4679 elf_tdata (abfd)->next_file_pos = off;
4683 /* Assign file positions for the other sections. */
4686 assign_file_positions_for_non_load_sections (bfd *abfd,
4687 struct bfd_link_info *link_info)
4689 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4690 Elf_Internal_Shdr **i_shdrpp;
4691 Elf_Internal_Shdr **hdrpp;
4692 Elf_Internal_Phdr *phdrs;
4693 Elf_Internal_Phdr *p;
4694 struct elf_segment_map *m;
4695 bfd_vma filehdr_vaddr, filehdr_paddr;
4696 bfd_vma phdrs_vaddr, phdrs_paddr;
4698 unsigned int num_sec;
4702 i_shdrpp = elf_elfsections (abfd);
4703 num_sec = elf_numsections (abfd);
4704 off = elf_tdata (abfd)->next_file_pos;
4705 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4707 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4708 Elf_Internal_Shdr *hdr;
4711 if (hdr->bfd_section != NULL
4712 && (hdr->bfd_section->filepos != 0
4713 || (hdr->sh_type == SHT_NOBITS
4714 && hdr->contents == NULL)))
4715 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4716 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4718 if (hdr->sh_size != 0)
4719 ((*_bfd_error_handler)
4720 (_("%B: warning: allocated section `%s' not in segment"),
4722 (hdr->bfd_section == NULL
4724 : hdr->bfd_section->name)));
4725 /* We don't need to page align empty sections. */
4726 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4727 off += vma_page_aligned_bias (hdr->sh_addr, off,
4730 off += vma_page_aligned_bias (hdr->sh_addr, off,
4732 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4735 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4736 && hdr->bfd_section == NULL)
4737 || hdr == i_shdrpp[tdata->symtab_section]
4738 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4739 || hdr == i_shdrpp[tdata->strtab_section])
4740 hdr->sh_offset = -1;
4742 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4744 if (i == SHN_LORESERVE - 1)
4746 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4747 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4751 /* Now that we have set the section file positions, we can set up
4752 the file positions for the non PT_LOAD segments. */
4756 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4758 phdrs = elf_tdata (abfd)->phdr;
4759 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4764 if (p->p_type != PT_LOAD)
4767 if (m->includes_filehdr)
4769 filehdr_vaddr = p->p_vaddr;
4770 filehdr_paddr = p->p_paddr;
4772 if (m->includes_phdrs)
4774 phdrs_vaddr = p->p_vaddr;
4775 phdrs_paddr = p->p_paddr;
4776 if (m->includes_filehdr)
4778 phdrs_vaddr += bed->s->sizeof_ehdr;
4779 phdrs_paddr += bed->s->sizeof_ehdr;
4784 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4790 if (p->p_type != PT_LOAD
4791 && (p->p_type != PT_NOTE || bfd_get_format (abfd) != bfd_core))
4793 Elf_Internal_Shdr *hdr;
4794 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4796 hdr = &elf_section_data (m->sections[m->count - 1])->this_hdr;
4797 p->p_filesz = (m->sections[m->count - 1]->filepos
4798 - m->sections[0]->filepos);
4799 if (hdr->sh_type != SHT_NOBITS)
4800 p->p_filesz += hdr->sh_size;
4802 p->p_offset = m->sections[0]->filepos;
4807 if (m->includes_filehdr)
4809 p->p_vaddr = filehdr_vaddr;
4810 if (! m->p_paddr_valid)
4811 p->p_paddr = filehdr_paddr;
4813 else if (m->includes_phdrs)
4815 p->p_vaddr = phdrs_vaddr;
4816 if (! m->p_paddr_valid)
4817 p->p_paddr = phdrs_paddr;
4819 else if (p->p_type == PT_GNU_RELRO)
4821 Elf_Internal_Phdr *lp;
4823 for (lp = phdrs; lp < phdrs + count; ++lp)
4825 if (lp->p_type == PT_LOAD
4826 && lp->p_vaddr <= link_info->relro_end
4827 && lp->p_vaddr >= link_info->relro_start
4828 && (lp->p_vaddr + lp->p_filesz
4829 >= link_info->relro_end))
4833 if (lp < phdrs + count
4834 && link_info->relro_end > lp->p_vaddr)
4836 p->p_vaddr = lp->p_vaddr;
4837 p->p_paddr = lp->p_paddr;
4838 p->p_offset = lp->p_offset;
4839 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4840 p->p_memsz = p->p_filesz;
4842 p->p_flags = (lp->p_flags & ~PF_W);
4846 memset (p, 0, sizeof *p);
4847 p->p_type = PT_NULL;
4853 elf_tdata (abfd)->next_file_pos = off;
4858 /* Work out the file positions of all the sections. This is called by
4859 _bfd_elf_compute_section_file_positions. All the section sizes and
4860 VMAs must be known before this is called.
4862 Reloc sections come in two flavours: Those processed specially as
4863 "side-channel" data attached to a section to which they apply, and
4864 those that bfd doesn't process as relocations. The latter sort are
4865 stored in a normal bfd section by bfd_section_from_shdr. We don't
4866 consider the former sort here, unless they form part of the loadable
4867 image. Reloc sections not assigned here will be handled later by
4868 assign_file_positions_for_relocs.
4870 We also don't set the positions of the .symtab and .strtab here. */
4873 assign_file_positions_except_relocs (bfd *abfd,
4874 struct bfd_link_info *link_info)
4876 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4877 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4879 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4881 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4882 && bfd_get_format (abfd) != bfd_core)
4884 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4885 unsigned int num_sec = elf_numsections (abfd);
4886 Elf_Internal_Shdr **hdrpp;
4889 /* Start after the ELF header. */
4890 off = i_ehdrp->e_ehsize;
4892 /* We are not creating an executable, which means that we are
4893 not creating a program header, and that the actual order of
4894 the sections in the file is unimportant. */
4895 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4897 Elf_Internal_Shdr *hdr;
4900 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4901 && hdr->bfd_section == NULL)
4902 || i == tdata->symtab_section
4903 || i == tdata->symtab_shndx_section
4904 || i == tdata->strtab_section)
4906 hdr->sh_offset = -1;
4909 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4911 if (i == SHN_LORESERVE - 1)
4913 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4914 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4922 /* Assign file positions for the loaded sections based on the
4923 assignment of sections to segments. */
4924 if (!assign_file_positions_for_load_sections (abfd, link_info))
4927 /* And for non-load sections. */
4928 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4931 if (bed->elf_backend_modify_program_headers != NULL)
4933 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4937 /* Write out the program headers. */
4938 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4939 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4940 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4943 off = tdata->next_file_pos;
4946 /* Place the section headers. */
4947 off = align_file_position (off, 1 << bed->s->log_file_align);
4948 i_ehdrp->e_shoff = off;
4949 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4951 tdata->next_file_pos = off;
4957 prep_headers (bfd *abfd)
4959 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4960 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4961 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4962 struct elf_strtab_hash *shstrtab;
4963 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4965 i_ehdrp = elf_elfheader (abfd);
4966 i_shdrp = elf_elfsections (abfd);
4968 shstrtab = _bfd_elf_strtab_init ();
4969 if (shstrtab == NULL)
4972 elf_shstrtab (abfd) = shstrtab;
4974 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4975 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4976 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4977 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4979 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4980 i_ehdrp->e_ident[EI_DATA] =
4981 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4982 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4984 if ((abfd->flags & DYNAMIC) != 0)
4985 i_ehdrp->e_type = ET_DYN;
4986 else if ((abfd->flags & EXEC_P) != 0)
4987 i_ehdrp->e_type = ET_EXEC;
4988 else if (bfd_get_format (abfd) == bfd_core)
4989 i_ehdrp->e_type = ET_CORE;
4991 i_ehdrp->e_type = ET_REL;
4993 switch (bfd_get_arch (abfd))
4995 case bfd_arch_unknown:
4996 i_ehdrp->e_machine = EM_NONE;
4999 /* There used to be a long list of cases here, each one setting
5000 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5001 in the corresponding bfd definition. To avoid duplication,
5002 the switch was removed. Machines that need special handling
5003 can generally do it in elf_backend_final_write_processing(),
5004 unless they need the information earlier than the final write.
5005 Such need can generally be supplied by replacing the tests for
5006 e_machine with the conditions used to determine it. */
5008 i_ehdrp->e_machine = bed->elf_machine_code;
5011 i_ehdrp->e_version = bed->s->ev_current;
5012 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5014 /* No program header, for now. */
5015 i_ehdrp->e_phoff = 0;
5016 i_ehdrp->e_phentsize = 0;
5017 i_ehdrp->e_phnum = 0;
5019 /* Each bfd section is section header entry. */
5020 i_ehdrp->e_entry = bfd_get_start_address (abfd);
5021 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5023 /* If we're building an executable, we'll need a program header table. */
5024 if (abfd->flags & EXEC_P)
5025 /* It all happens later. */
5029 i_ehdrp->e_phentsize = 0;
5031 i_ehdrp->e_phoff = 0;
5034 elf_tdata (abfd)->symtab_hdr.sh_name =
5035 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
5036 elf_tdata (abfd)->strtab_hdr.sh_name =
5037 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
5038 elf_tdata (abfd)->shstrtab_hdr.sh_name =
5039 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
5040 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5041 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5042 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
5048 /* Assign file positions for all the reloc sections which are not part
5049 of the loadable file image. */
5052 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
5055 unsigned int i, num_sec;
5056 Elf_Internal_Shdr **shdrpp;
5058 off = elf_tdata (abfd)->next_file_pos;
5060 num_sec = elf_numsections (abfd);
5061 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
5063 Elf_Internal_Shdr *shdrp;
5066 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
5067 && shdrp->sh_offset == -1)
5068 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
5071 elf_tdata (abfd)->next_file_pos = off;
5075 _bfd_elf_write_object_contents (bfd *abfd)
5077 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5078 Elf_Internal_Ehdr *i_ehdrp;
5079 Elf_Internal_Shdr **i_shdrp;
5081 unsigned int count, num_sec;
5083 if (! abfd->output_has_begun
5084 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
5087 i_shdrp = elf_elfsections (abfd);
5088 i_ehdrp = elf_elfheader (abfd);
5091 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5095 _bfd_elf_assign_file_positions_for_relocs (abfd);
5097 /* After writing the headers, we need to write the sections too... */
5098 num_sec = elf_numsections (abfd);
5099 for (count = 1; count < num_sec; count++)
5101 if (bed->elf_backend_section_processing)
5102 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5103 if (i_shdrp[count]->contents)
5105 bfd_size_type amt = i_shdrp[count]->sh_size;
5107 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
5108 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
5111 if (count == SHN_LORESERVE - 1)
5112 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
5115 /* Write out the section header names. */
5116 if (elf_shstrtab (abfd) != NULL
5117 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
5118 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
5121 if (bed->elf_backend_final_write_processing)
5122 (*bed->elf_backend_final_write_processing) (abfd,
5123 elf_tdata (abfd)->linker);
5125 return bed->s->write_shdrs_and_ehdr (abfd);
5129 _bfd_elf_write_corefile_contents (bfd *abfd)
5131 /* Hopefully this can be done just like an object file. */
5132 return _bfd_elf_write_object_contents (abfd);
5135 /* Given a section, search the header to find them. */
5138 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5140 const struct elf_backend_data *bed;
5143 if (elf_section_data (asect) != NULL
5144 && elf_section_data (asect)->this_idx != 0)
5145 return elf_section_data (asect)->this_idx;
5147 if (bfd_is_abs_section (asect))
5149 else if (bfd_is_com_section (asect))
5151 else if (bfd_is_und_section (asect))
5156 bed = get_elf_backend_data (abfd);
5157 if (bed->elf_backend_section_from_bfd_section)
5161 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5166 bfd_set_error (bfd_error_nonrepresentable_section);
5171 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5175 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5177 asymbol *asym_ptr = *asym_ptr_ptr;
5179 flagword flags = asym_ptr->flags;
5181 /* When gas creates relocations against local labels, it creates its
5182 own symbol for the section, but does put the symbol into the
5183 symbol chain, so udata is 0. When the linker is generating
5184 relocatable output, this section symbol may be for one of the
5185 input sections rather than the output section. */
5186 if (asym_ptr->udata.i == 0
5187 && (flags & BSF_SECTION_SYM)
5188 && asym_ptr->section)
5193 sec = asym_ptr->section;
5194 if (sec->owner != abfd && sec->output_section != NULL)
5195 sec = sec->output_section;
5196 if (sec->owner == abfd
5197 && (indx = sec->index) < elf_num_section_syms (abfd)
5198 && elf_section_syms (abfd)[indx] != NULL)
5199 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5202 idx = asym_ptr->udata.i;
5206 /* This case can occur when using --strip-symbol on a symbol
5207 which is used in a relocation entry. */
5208 (*_bfd_error_handler)
5209 (_("%B: symbol `%s' required but not present"),
5210 abfd, bfd_asymbol_name (asym_ptr));
5211 bfd_set_error (bfd_error_no_symbols);
5218 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5219 (long) asym_ptr, asym_ptr->name, idx, flags,
5220 elf_symbol_flags (flags));
5228 /* Rewrite program header information. */
5231 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5233 Elf_Internal_Ehdr *iehdr;
5234 struct elf_segment_map *map;
5235 struct elf_segment_map *map_first;
5236 struct elf_segment_map **pointer_to_map;
5237 Elf_Internal_Phdr *segment;
5240 unsigned int num_segments;
5241 bfd_boolean phdr_included = FALSE;
5242 bfd_vma maxpagesize;
5243 struct elf_segment_map *phdr_adjust_seg = NULL;
5244 unsigned int phdr_adjust_num = 0;
5245 const struct elf_backend_data *bed;
5247 bed = get_elf_backend_data (ibfd);
5248 iehdr = elf_elfheader (ibfd);
5251 pointer_to_map = &map_first;
5253 num_segments = elf_elfheader (ibfd)->e_phnum;
5254 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5256 /* Returns the end address of the segment + 1. */
5257 #define SEGMENT_END(segment, start) \
5258 (start + (segment->p_memsz > segment->p_filesz \
5259 ? segment->p_memsz : segment->p_filesz))
5261 #define SECTION_SIZE(section, segment) \
5262 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5263 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5264 ? section->size : 0)
5266 /* Returns TRUE if the given section is contained within
5267 the given segment. VMA addresses are compared. */
5268 #define IS_CONTAINED_BY_VMA(section, segment) \
5269 (section->vma >= segment->p_vaddr \
5270 && (section->vma + SECTION_SIZE (section, segment) \
5271 <= (SEGMENT_END (segment, segment->p_vaddr))))
5273 /* Returns TRUE if the given section is contained within
5274 the given segment. LMA addresses are compared. */
5275 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5276 (section->lma >= base \
5277 && (section->lma + SECTION_SIZE (section, segment) \
5278 <= SEGMENT_END (segment, base)))
5280 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
5281 #define IS_COREFILE_NOTE(p, s) \
5282 (p->p_type == PT_NOTE \
5283 && bfd_get_format (ibfd) == bfd_core \
5284 && s->vma == 0 && s->lma == 0 \
5285 && (bfd_vma) s->filepos >= p->p_offset \
5286 && ((bfd_vma) s->filepos + s->size \
5287 <= p->p_offset + p->p_filesz))
5289 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5290 linker, which generates a PT_INTERP section with p_vaddr and
5291 p_memsz set to 0. */
5292 #define IS_SOLARIS_PT_INTERP(p, s) \
5294 && p->p_paddr == 0 \
5295 && p->p_memsz == 0 \
5296 && p->p_filesz > 0 \
5297 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5299 && (bfd_vma) s->filepos >= p->p_offset \
5300 && ((bfd_vma) s->filepos + s->size \
5301 <= p->p_offset + p->p_filesz))
5303 /* Decide if the given section should be included in the given segment.
5304 A section will be included if:
5305 1. It is within the address space of the segment -- we use the LMA
5306 if that is set for the segment and the VMA otherwise,
5307 2. It is an allocated segment,
5308 3. There is an output section associated with it,
5309 4. The section has not already been allocated to a previous segment.
5310 5. PT_GNU_STACK segments do not include any sections.
5311 6. PT_TLS segment includes only SHF_TLS sections.
5312 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5313 8. PT_DYNAMIC should not contain empty sections at the beginning
5314 (with the possible exception of .dynamic). */
5315 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5316 ((((segment->p_paddr \
5317 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5318 : IS_CONTAINED_BY_VMA (section, segment)) \
5319 && (section->flags & SEC_ALLOC) != 0) \
5320 || IS_COREFILE_NOTE (segment, section)) \
5321 && segment->p_type != PT_GNU_STACK \
5322 && (segment->p_type != PT_TLS \
5323 || (section->flags & SEC_THREAD_LOCAL)) \
5324 && (segment->p_type == PT_LOAD \
5325 || segment->p_type == PT_TLS \
5326 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5327 && (segment->p_type != PT_DYNAMIC \
5328 || SECTION_SIZE (section, segment) > 0 \
5329 || (segment->p_paddr \
5330 ? segment->p_paddr != section->lma \
5331 : segment->p_vaddr != section->vma) \
5332 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5334 && ! section->segment_mark)
5336 /* If the output section of a section in the input segment is NULL,
5337 it is removed from the corresponding output segment. */
5338 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5339 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5340 && section->output_section != NULL)
5342 /* Returns TRUE iff seg1 starts after the end of seg2. */
5343 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5344 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5346 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5347 their VMA address ranges and their LMA address ranges overlap.
5348 It is possible to have overlapping VMA ranges without overlapping LMA
5349 ranges. RedBoot images for example can have both .data and .bss mapped
5350 to the same VMA range, but with the .data section mapped to a different
5352 #define SEGMENT_OVERLAPS(seg1, seg2) \
5353 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5354 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5355 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5356 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5358 /* Initialise the segment mark field. */
5359 for (section = ibfd->sections; section != NULL; section = section->next)
5360 section->segment_mark = FALSE;
5362 /* Scan through the segments specified in the program header
5363 of the input BFD. For this first scan we look for overlaps
5364 in the loadable segments. These can be created by weird
5365 parameters to objcopy. Also, fix some solaris weirdness. */
5366 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5371 Elf_Internal_Phdr *segment2;
5373 if (segment->p_type == PT_INTERP)
5374 for (section = ibfd->sections; section; section = section->next)
5375 if (IS_SOLARIS_PT_INTERP (segment, section))
5377 /* Mininal change so that the normal section to segment
5378 assignment code will work. */
5379 segment->p_vaddr = section->vma;
5383 if (segment->p_type != PT_LOAD)
5386 /* Determine if this segment overlaps any previous segments. */
5387 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
5389 bfd_signed_vma extra_length;
5391 if (segment2->p_type != PT_LOAD
5392 || ! SEGMENT_OVERLAPS (segment, segment2))
5395 /* Merge the two segments together. */
5396 if (segment2->p_vaddr < segment->p_vaddr)
5398 /* Extend SEGMENT2 to include SEGMENT and then delete
5401 SEGMENT_END (segment, segment->p_vaddr)
5402 - SEGMENT_END (segment2, segment2->p_vaddr);
5404 if (extra_length > 0)
5406 segment2->p_memsz += extra_length;
5407 segment2->p_filesz += extra_length;
5410 segment->p_type = PT_NULL;
5412 /* Since we have deleted P we must restart the outer loop. */
5414 segment = elf_tdata (ibfd)->phdr;
5419 /* Extend SEGMENT to include SEGMENT2 and then delete
5422 SEGMENT_END (segment2, segment2->p_vaddr)
5423 - SEGMENT_END (segment, segment->p_vaddr);
5425 if (extra_length > 0)
5427 segment->p_memsz += extra_length;
5428 segment->p_filesz += extra_length;
5431 segment2->p_type = PT_NULL;
5436 /* The second scan attempts to assign sections to segments. */
5437 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5441 unsigned int section_count;
5442 asection ** sections;
5443 asection * output_section;
5445 bfd_vma matching_lma;
5446 bfd_vma suggested_lma;
5449 asection * first_section;
5451 if (segment->p_type == PT_NULL)
5454 first_section = NULL;
5455 /* Compute how many sections might be placed into this segment. */
5456 for (section = ibfd->sections, section_count = 0;
5458 section = section->next)
5460 /* Find the first section in the input segment, which may be
5461 removed from the corresponding output segment. */
5462 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5464 if (first_section == NULL)
5465 first_section = section;
5466 if (section->output_section != NULL)
5471 /* Allocate a segment map big enough to contain
5472 all of the sections we have selected. */
5473 amt = sizeof (struct elf_segment_map);
5474 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5475 map = bfd_zalloc (obfd, amt);
5479 /* Initialise the fields of the segment map. Default to
5480 using the physical address of the segment in the input BFD. */
5482 map->p_type = segment->p_type;
5483 map->p_flags = segment->p_flags;
5484 map->p_flags_valid = 1;
5486 /* If the first section in the input segment is removed, there is
5487 no need to preserve segment physical address in the corresponding
5489 if (!first_section || first_section->output_section != NULL)
5491 map->p_paddr = segment->p_paddr;
5492 map->p_paddr_valid = 1;
5495 /* Determine if this segment contains the ELF file header
5496 and if it contains the program headers themselves. */
5497 map->includes_filehdr = (segment->p_offset == 0
5498 && segment->p_filesz >= iehdr->e_ehsize);
5500 map->includes_phdrs = 0;
5502 if (! phdr_included || segment->p_type != PT_LOAD)
5504 map->includes_phdrs =
5505 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5506 && (segment->p_offset + segment->p_filesz
5507 >= ((bfd_vma) iehdr->e_phoff
5508 + iehdr->e_phnum * iehdr->e_phentsize)));
5510 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5511 phdr_included = TRUE;
5514 if (section_count == 0)
5516 /* Special segments, such as the PT_PHDR segment, may contain
5517 no sections, but ordinary, loadable segments should contain
5518 something. They are allowed by the ELF spec however, so only
5519 a warning is produced. */
5520 if (segment->p_type == PT_LOAD)
5521 (*_bfd_error_handler)
5522 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5526 *pointer_to_map = map;
5527 pointer_to_map = &map->next;
5532 /* Now scan the sections in the input BFD again and attempt
5533 to add their corresponding output sections to the segment map.
5534 The problem here is how to handle an output section which has
5535 been moved (ie had its LMA changed). There are four possibilities:
5537 1. None of the sections have been moved.
5538 In this case we can continue to use the segment LMA from the
5541 2. All of the sections have been moved by the same amount.
5542 In this case we can change the segment's LMA to match the LMA
5543 of the first section.
5545 3. Some of the sections have been moved, others have not.
5546 In this case those sections which have not been moved can be
5547 placed in the current segment which will have to have its size,
5548 and possibly its LMA changed, and a new segment or segments will
5549 have to be created to contain the other sections.
5551 4. The sections have been moved, but not by the same amount.
5552 In this case we can change the segment's LMA to match the LMA
5553 of the first section and we will have to create a new segment
5554 or segments to contain the other sections.
5556 In order to save time, we allocate an array to hold the section
5557 pointers that we are interested in. As these sections get assigned
5558 to a segment, they are removed from this array. */
5560 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5561 to work around this long long bug. */
5562 sections = bfd_malloc2 (section_count, sizeof (asection *));
5563 if (sections == NULL)
5566 /* Step One: Scan for segment vs section LMA conflicts.
5567 Also add the sections to the section array allocated above.
5568 Also add the sections to the current segment. In the common
5569 case, where the sections have not been moved, this means that
5570 we have completely filled the segment, and there is nothing
5576 for (j = 0, section = ibfd->sections;
5578 section = section->next)
5580 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5582 output_section = section->output_section;
5584 sections[j ++] = section;
5586 /* The Solaris native linker always sets p_paddr to 0.
5587 We try to catch that case here, and set it to the
5588 correct value. Note - some backends require that
5589 p_paddr be left as zero. */
5590 if (segment->p_paddr == 0
5591 && segment->p_vaddr != 0
5592 && (! bed->want_p_paddr_set_to_zero)
5594 && output_section->lma != 0
5595 && (output_section->vma == (segment->p_vaddr
5596 + (map->includes_filehdr
5599 + (map->includes_phdrs
5601 * iehdr->e_phentsize)
5603 map->p_paddr = segment->p_vaddr;
5605 /* Match up the physical address of the segment with the
5606 LMA address of the output section. */
5607 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5608 || IS_COREFILE_NOTE (segment, section)
5609 || (bed->want_p_paddr_set_to_zero &&
5610 IS_CONTAINED_BY_VMA (output_section, segment)))
5612 if (matching_lma == 0)
5613 matching_lma = output_section->lma;
5615 /* We assume that if the section fits within the segment
5616 then it does not overlap any other section within that
5618 map->sections[isec ++] = output_section;
5620 else if (suggested_lma == 0)
5621 suggested_lma = output_section->lma;
5625 BFD_ASSERT (j == section_count);
5627 /* Step Two: Adjust the physical address of the current segment,
5629 if (isec == section_count)
5631 /* All of the sections fitted within the segment as currently
5632 specified. This is the default case. Add the segment to
5633 the list of built segments and carry on to process the next
5634 program header in the input BFD. */
5635 map->count = section_count;
5636 *pointer_to_map = map;
5637 pointer_to_map = &map->next;
5639 if (matching_lma != map->p_paddr
5640 && !map->includes_filehdr && !map->includes_phdrs)
5641 /* There is some padding before the first section in the
5642 segment. So, we must account for that in the output
5644 map->p_vaddr_offset = matching_lma - map->p_paddr;
5651 if (matching_lma != 0)
5653 /* At least one section fits inside the current segment.
5654 Keep it, but modify its physical address to match the
5655 LMA of the first section that fitted. */
5656 map->p_paddr = matching_lma;
5660 /* None of the sections fitted inside the current segment.
5661 Change the current segment's physical address to match
5662 the LMA of the first section. */
5663 map->p_paddr = suggested_lma;
5666 /* Offset the segment physical address from the lma
5667 to allow for space taken up by elf headers. */
5668 if (map->includes_filehdr)
5669 map->p_paddr -= iehdr->e_ehsize;
5671 if (map->includes_phdrs)
5673 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5675 /* iehdr->e_phnum is just an estimate of the number
5676 of program headers that we will need. Make a note
5677 here of the number we used and the segment we chose
5678 to hold these headers, so that we can adjust the
5679 offset when we know the correct value. */
5680 phdr_adjust_num = iehdr->e_phnum;
5681 phdr_adjust_seg = map;
5685 /* Step Three: Loop over the sections again, this time assigning
5686 those that fit to the current segment and removing them from the
5687 sections array; but making sure not to leave large gaps. Once all
5688 possible sections have been assigned to the current segment it is
5689 added to the list of built segments and if sections still remain
5690 to be assigned, a new segment is constructed before repeating
5698 /* Fill the current segment with sections that fit. */
5699 for (j = 0; j < section_count; j++)
5701 section = sections[j];
5703 if (section == NULL)
5706 output_section = section->output_section;
5708 BFD_ASSERT (output_section != NULL);
5710 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5711 || IS_COREFILE_NOTE (segment, section))
5713 if (map->count == 0)
5715 /* If the first section in a segment does not start at
5716 the beginning of the segment, then something is
5718 if (output_section->lma !=
5720 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5721 + (map->includes_phdrs
5722 ? iehdr->e_phnum * iehdr->e_phentsize
5728 asection * prev_sec;
5730 prev_sec = map->sections[map->count - 1];
5732 /* If the gap between the end of the previous section
5733 and the start of this section is more than
5734 maxpagesize then we need to start a new segment. */
5735 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5737 < BFD_ALIGN (output_section->lma, maxpagesize))
5738 || ((prev_sec->lma + prev_sec->size)
5739 > output_section->lma))
5741 if (suggested_lma == 0)
5742 suggested_lma = output_section->lma;
5748 map->sections[map->count++] = output_section;
5751 section->segment_mark = TRUE;
5753 else if (suggested_lma == 0)
5754 suggested_lma = output_section->lma;
5757 BFD_ASSERT (map->count > 0);
5759 /* Add the current segment to the list of built segments. */
5760 *pointer_to_map = map;
5761 pointer_to_map = &map->next;
5763 if (isec < section_count)
5765 /* We still have not allocated all of the sections to
5766 segments. Create a new segment here, initialise it
5767 and carry on looping. */
5768 amt = sizeof (struct elf_segment_map);
5769 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5770 map = bfd_alloc (obfd, amt);
5777 /* Initialise the fields of the segment map. Set the physical
5778 physical address to the LMA of the first section that has
5779 not yet been assigned. */
5781 map->p_type = segment->p_type;
5782 map->p_flags = segment->p_flags;
5783 map->p_flags_valid = 1;
5784 map->p_paddr = suggested_lma;
5785 map->p_paddr_valid = 1;
5786 map->includes_filehdr = 0;
5787 map->includes_phdrs = 0;
5790 while (isec < section_count);
5795 /* The Solaris linker creates program headers in which all the
5796 p_paddr fields are zero. When we try to objcopy or strip such a
5797 file, we get confused. Check for this case, and if we find it
5798 reset the p_paddr_valid fields. */
5799 for (map = map_first; map != NULL; map = map->next)
5800 if (map->p_paddr != 0)
5803 for (map = map_first; map != NULL; map = map->next)
5804 map->p_paddr_valid = 0;
5806 elf_tdata (obfd)->segment_map = map_first;
5808 /* If we had to estimate the number of program headers that were
5809 going to be needed, then check our estimate now and adjust
5810 the offset if necessary. */
5811 if (phdr_adjust_seg != NULL)
5815 for (count = 0, map = map_first; map != NULL; map = map->next)
5818 if (count > phdr_adjust_num)
5819 phdr_adjust_seg->p_paddr
5820 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5825 #undef IS_CONTAINED_BY_VMA
5826 #undef IS_CONTAINED_BY_LMA
5827 #undef IS_COREFILE_NOTE
5828 #undef IS_SOLARIS_PT_INTERP
5829 #undef IS_SECTION_IN_INPUT_SEGMENT
5830 #undef INCLUDE_SECTION_IN_SEGMENT
5831 #undef SEGMENT_AFTER_SEGMENT
5832 #undef SEGMENT_OVERLAPS
5836 /* Copy ELF program header information. */
5839 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5841 Elf_Internal_Ehdr *iehdr;
5842 struct elf_segment_map *map;
5843 struct elf_segment_map *map_first;
5844 struct elf_segment_map **pointer_to_map;
5845 Elf_Internal_Phdr *segment;
5847 unsigned int num_segments;
5848 bfd_boolean phdr_included = FALSE;
5850 iehdr = elf_elfheader (ibfd);
5853 pointer_to_map = &map_first;
5855 num_segments = elf_elfheader (ibfd)->e_phnum;
5856 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5861 unsigned int section_count;
5863 Elf_Internal_Shdr *this_hdr;
5864 asection *first_section = NULL;
5866 /* FIXME: Do we need to copy PT_NULL segment? */
5867 if (segment->p_type == PT_NULL)
5870 /* Compute how many sections are in this segment. */
5871 for (section = ibfd->sections, section_count = 0;
5873 section = section->next)
5875 this_hdr = &(elf_section_data(section)->this_hdr);
5876 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5879 first_section = section;
5884 /* Allocate a segment map big enough to contain
5885 all of the sections we have selected. */
5886 amt = sizeof (struct elf_segment_map);
5887 if (section_count != 0)
5888 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5889 map = bfd_zalloc (obfd, amt);
5893 /* Initialize the fields of the output segment map with the
5896 map->p_type = segment->p_type;
5897 map->p_flags = segment->p_flags;
5898 map->p_flags_valid = 1;
5899 map->p_paddr = segment->p_paddr;
5900 map->p_paddr_valid = 1;
5901 map->p_align = segment->p_align;
5902 map->p_align_valid = 1;
5903 map->p_vaddr_offset = 0;
5905 /* Determine if this segment contains the ELF file header
5906 and if it contains the program headers themselves. */
5907 map->includes_filehdr = (segment->p_offset == 0
5908 && segment->p_filesz >= iehdr->e_ehsize);
5910 map->includes_phdrs = 0;
5911 if (! phdr_included || segment->p_type != PT_LOAD)
5913 map->includes_phdrs =
5914 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5915 && (segment->p_offset + segment->p_filesz
5916 >= ((bfd_vma) iehdr->e_phoff
5917 + iehdr->e_phnum * iehdr->e_phentsize)));
5919 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5920 phdr_included = TRUE;
5923 if (!map->includes_phdrs && !map->includes_filehdr)
5924 /* There is some other padding before the first section. */
5925 map->p_vaddr_offset = ((first_section ? first_section->lma : 0)
5926 - segment->p_paddr);
5928 if (section_count != 0)
5930 unsigned int isec = 0;
5932 for (section = first_section;
5934 section = section->next)
5936 this_hdr = &(elf_section_data(section)->this_hdr);
5937 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5939 map->sections[isec++] = section->output_section;
5940 if (isec == section_count)
5946 map->count = section_count;
5947 *pointer_to_map = map;
5948 pointer_to_map = &map->next;
5951 elf_tdata (obfd)->segment_map = map_first;
5955 /* Copy private BFD data. This copies or rewrites ELF program header
5959 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5961 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5962 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5965 if (elf_tdata (ibfd)->phdr == NULL)
5968 if (ibfd->xvec == obfd->xvec)
5970 /* Check to see if any sections in the input BFD
5971 covered by ELF program header have changed. */
5972 Elf_Internal_Phdr *segment;
5973 asection *section, *osec;
5974 unsigned int i, num_segments;
5975 Elf_Internal_Shdr *this_hdr;
5977 /* Initialize the segment mark field. */
5978 for (section = obfd->sections; section != NULL;
5979 section = section->next)
5980 section->segment_mark = FALSE;
5982 num_segments = elf_elfheader (ibfd)->e_phnum;
5983 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5987 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5988 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5989 which severly confuses things, so always regenerate the segment
5990 map in this case. */
5991 if (segment->p_paddr == 0
5992 && segment->p_memsz == 0
5993 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
5996 for (section = ibfd->sections;
5997 section != NULL; section = section->next)
5999 /* We mark the output section so that we know it comes
6000 from the input BFD. */
6001 osec = section->output_section;
6003 osec->segment_mark = TRUE;
6005 /* Check if this section is covered by the segment. */
6006 this_hdr = &(elf_section_data(section)->this_hdr);
6007 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
6009 /* FIXME: Check if its output section is changed or
6010 removed. What else do we need to check? */
6012 || section->flags != osec->flags
6013 || section->lma != osec->lma
6014 || section->vma != osec->vma
6015 || section->size != osec->size
6016 || section->rawsize != osec->rawsize
6017 || section->alignment_power != osec->alignment_power)
6023 /* Check to see if any output section do not come from the
6025 for (section = obfd->sections; section != NULL;
6026 section = section->next)
6028 if (section->segment_mark == FALSE)
6031 section->segment_mark = FALSE;
6034 return copy_elf_program_header (ibfd, obfd);
6038 return rewrite_elf_program_header (ibfd, obfd);
6041 /* Initialize private output section information from input section. */
6044 _bfd_elf_init_private_section_data (bfd *ibfd,
6048 struct bfd_link_info *link_info)
6051 Elf_Internal_Shdr *ihdr, *ohdr;
6052 bfd_boolean need_group = link_info == NULL || link_info->relocatable;
6054 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6055 || obfd->xvec->flavour != bfd_target_elf_flavour)
6058 /* Don't copy the output ELF section type from input if the
6059 output BFD section flags have been set to something different.
6060 elf_fake_sections will set ELF section type based on BFD
6062 if (elf_section_type (osec) == SHT_NULL
6063 && (osec->flags == isec->flags || !osec->flags))
6064 elf_section_type (osec) = elf_section_type (isec);
6066 /* FIXME: Is this correct for all OS/PROC specific flags? */
6067 elf_section_flags (osec) |= (elf_section_flags (isec)
6068 & (SHF_MASKOS | SHF_MASKPROC));
6070 /* Set things up for objcopy and relocatable link. The output
6071 SHT_GROUP section will have its elf_next_in_group pointing back
6072 to the input group members. Ignore linker created group section.
6073 See elfNN_ia64_object_p in elfxx-ia64.c. */
6076 if (elf_sec_group (isec) == NULL
6077 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6079 if (elf_section_flags (isec) & SHF_GROUP)
6080 elf_section_flags (osec) |= SHF_GROUP;
6081 elf_next_in_group (osec) = elf_next_in_group (isec);
6082 elf_group_name (osec) = elf_group_name (isec);
6086 ihdr = &elf_section_data (isec)->this_hdr;
6088 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6089 don't use the output section of the linked-to section since it
6090 may be NULL at this point. */
6091 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6093 ohdr = &elf_section_data (osec)->this_hdr;
6094 ohdr->sh_flags |= SHF_LINK_ORDER;
6095 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6098 osec->use_rela_p = isec->use_rela_p;
6103 /* Copy private section information. This copies over the entsize
6104 field, and sometimes the info field. */
6107 _bfd_elf_copy_private_section_data (bfd *ibfd,
6112 Elf_Internal_Shdr *ihdr, *ohdr;
6114 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6115 || obfd->xvec->flavour != bfd_target_elf_flavour)
6118 ihdr = &elf_section_data (isec)->this_hdr;
6119 ohdr = &elf_section_data (osec)->this_hdr;
6121 ohdr->sh_entsize = ihdr->sh_entsize;
6123 if (ihdr->sh_type == SHT_SYMTAB
6124 || ihdr->sh_type == SHT_DYNSYM
6125 || ihdr->sh_type == SHT_GNU_verneed
6126 || ihdr->sh_type == SHT_GNU_verdef)
6127 ohdr->sh_info = ihdr->sh_info;
6129 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6133 /* Copy private header information. */
6136 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6140 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6141 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6144 /* Copy over private BFD data if it has not already been copied.
6145 This must be done here, rather than in the copy_private_bfd_data
6146 entry point, because the latter is called after the section
6147 contents have been set, which means that the program headers have
6148 already been worked out. */
6149 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6151 if (! copy_private_bfd_data (ibfd, obfd))
6155 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6156 but this might be wrong if we deleted the group section. */
6157 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6158 if (elf_section_type (isec) == SHT_GROUP
6159 && isec->output_section == NULL)
6161 asection *first = elf_next_in_group (isec);
6162 asection *s = first;
6165 if (s->output_section != NULL)
6167 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6168 elf_group_name (s->output_section) = NULL;
6170 s = elf_next_in_group (s);
6179 /* Copy private symbol information. If this symbol is in a section
6180 which we did not map into a BFD section, try to map the section
6181 index correctly. We use special macro definitions for the mapped
6182 section indices; these definitions are interpreted by the
6183 swap_out_syms function. */
6185 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6186 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6187 #define MAP_STRTAB (SHN_HIOS + 3)
6188 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6189 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6192 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6197 elf_symbol_type *isym, *osym;
6199 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6200 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6203 isym = elf_symbol_from (ibfd, isymarg);
6204 osym = elf_symbol_from (obfd, osymarg);
6208 && bfd_is_abs_section (isym->symbol.section))
6212 shndx = isym->internal_elf_sym.st_shndx;
6213 if (shndx == elf_onesymtab (ibfd))
6214 shndx = MAP_ONESYMTAB;
6215 else if (shndx == elf_dynsymtab (ibfd))
6216 shndx = MAP_DYNSYMTAB;
6217 else if (shndx == elf_tdata (ibfd)->strtab_section)
6219 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6220 shndx = MAP_SHSTRTAB;
6221 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6222 shndx = MAP_SYM_SHNDX;
6223 osym->internal_elf_sym.st_shndx = shndx;
6229 /* Swap out the symbols. */
6232 swap_out_syms (bfd *abfd,
6233 struct bfd_strtab_hash **sttp,
6236 const struct elf_backend_data *bed;
6239 struct bfd_strtab_hash *stt;
6240 Elf_Internal_Shdr *symtab_hdr;
6241 Elf_Internal_Shdr *symtab_shndx_hdr;
6242 Elf_Internal_Shdr *symstrtab_hdr;
6243 bfd_byte *outbound_syms;
6244 bfd_byte *outbound_shndx;
6247 bfd_boolean name_local_sections;
6249 if (!elf_map_symbols (abfd))
6252 /* Dump out the symtabs. */
6253 stt = _bfd_elf_stringtab_init ();
6257 bed = get_elf_backend_data (abfd);
6258 symcount = bfd_get_symcount (abfd);
6259 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6260 symtab_hdr->sh_type = SHT_SYMTAB;
6261 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6262 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6263 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6264 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
6266 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6267 symstrtab_hdr->sh_type = SHT_STRTAB;
6269 outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
6270 if (outbound_syms == NULL)
6272 _bfd_stringtab_free (stt);
6275 symtab_hdr->contents = outbound_syms;
6277 outbound_shndx = NULL;
6278 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6279 if (symtab_shndx_hdr->sh_name != 0)
6281 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6282 outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6283 sizeof (Elf_External_Sym_Shndx));
6284 if (outbound_shndx == NULL)
6286 _bfd_stringtab_free (stt);
6290 symtab_shndx_hdr->contents = outbound_shndx;
6291 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6292 symtab_shndx_hdr->sh_size = amt;
6293 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6294 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6297 /* Now generate the data (for "contents"). */
6299 /* Fill in zeroth symbol and swap it out. */
6300 Elf_Internal_Sym sym;
6306 sym.st_shndx = SHN_UNDEF;
6307 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6308 outbound_syms += bed->s->sizeof_sym;
6309 if (outbound_shndx != NULL)
6310 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6314 = (bed->elf_backend_name_local_section_symbols
6315 && bed->elf_backend_name_local_section_symbols (abfd));
6317 syms = bfd_get_outsymbols (abfd);
6318 for (idx = 0; idx < symcount; idx++)
6320 Elf_Internal_Sym sym;
6321 bfd_vma value = syms[idx]->value;
6322 elf_symbol_type *type_ptr;
6323 flagword flags = syms[idx]->flags;
6326 if (!name_local_sections
6327 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6329 /* Local section symbols have no name. */
6334 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6337 if (sym.st_name == (unsigned long) -1)
6339 _bfd_stringtab_free (stt);
6344 type_ptr = elf_symbol_from (abfd, syms[idx]);
6346 if ((flags & BSF_SECTION_SYM) == 0
6347 && bfd_is_com_section (syms[idx]->section))
6349 /* ELF common symbols put the alignment into the `value' field,
6350 and the size into the `size' field. This is backwards from
6351 how BFD handles it, so reverse it here. */
6352 sym.st_size = value;
6353 if (type_ptr == NULL
6354 || type_ptr->internal_elf_sym.st_value == 0)
6355 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6357 sym.st_value = type_ptr->internal_elf_sym.st_value;
6358 sym.st_shndx = _bfd_elf_section_from_bfd_section
6359 (abfd, syms[idx]->section);
6363 asection *sec = syms[idx]->section;
6366 if (sec->output_section)
6368 value += sec->output_offset;
6369 sec = sec->output_section;
6372 /* Don't add in the section vma for relocatable output. */
6373 if (! relocatable_p)
6375 sym.st_value = value;
6376 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6378 if (bfd_is_abs_section (sec)
6380 && type_ptr->internal_elf_sym.st_shndx != 0)
6382 /* This symbol is in a real ELF section which we did
6383 not create as a BFD section. Undo the mapping done
6384 by copy_private_symbol_data. */
6385 shndx = type_ptr->internal_elf_sym.st_shndx;
6389 shndx = elf_onesymtab (abfd);
6392 shndx = elf_dynsymtab (abfd);
6395 shndx = elf_tdata (abfd)->strtab_section;
6398 shndx = elf_tdata (abfd)->shstrtab_section;
6401 shndx = elf_tdata (abfd)->symtab_shndx_section;
6409 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6415 /* Writing this would be a hell of a lot easier if
6416 we had some decent documentation on bfd, and
6417 knew what to expect of the library, and what to
6418 demand of applications. For example, it
6419 appears that `objcopy' might not set the
6420 section of a symbol to be a section that is
6421 actually in the output file. */
6422 sec2 = bfd_get_section_by_name (abfd, sec->name);
6425 _bfd_error_handler (_("\
6426 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6427 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6429 bfd_set_error (bfd_error_invalid_operation);
6430 _bfd_stringtab_free (stt);
6434 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6435 BFD_ASSERT (shndx != -1);
6439 sym.st_shndx = shndx;
6442 if ((flags & BSF_THREAD_LOCAL) != 0)
6444 else if ((flags & BSF_FUNCTION) != 0)
6446 else if ((flags & BSF_OBJECT) != 0)
6448 else if ((flags & BSF_RELC) != 0)
6450 else if ((flags & BSF_SRELC) != 0)
6455 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6458 /* Processor-specific types. */
6459 if (type_ptr != NULL
6460 && bed->elf_backend_get_symbol_type)
6461 type = ((*bed->elf_backend_get_symbol_type)
6462 (&type_ptr->internal_elf_sym, type));
6464 if (flags & BSF_SECTION_SYM)
6466 if (flags & BSF_GLOBAL)
6467 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6469 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6471 else if (bfd_is_com_section (syms[idx]->section))
6472 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6473 else if (bfd_is_und_section (syms[idx]->section))
6474 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6478 else if (flags & BSF_FILE)
6479 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6482 int bind = STB_LOCAL;
6484 if (flags & BSF_LOCAL)
6486 else if (flags & BSF_WEAK)
6488 else if (flags & BSF_GLOBAL)
6491 sym.st_info = ELF_ST_INFO (bind, type);
6494 if (type_ptr != NULL)
6495 sym.st_other = type_ptr->internal_elf_sym.st_other;
6499 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6500 outbound_syms += bed->s->sizeof_sym;
6501 if (outbound_shndx != NULL)
6502 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6506 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6507 symstrtab_hdr->sh_type = SHT_STRTAB;
6509 symstrtab_hdr->sh_flags = 0;
6510 symstrtab_hdr->sh_addr = 0;
6511 symstrtab_hdr->sh_entsize = 0;
6512 symstrtab_hdr->sh_link = 0;
6513 symstrtab_hdr->sh_info = 0;
6514 symstrtab_hdr->sh_addralign = 1;
6519 /* Return the number of bytes required to hold the symtab vector.
6521 Note that we base it on the count plus 1, since we will null terminate
6522 the vector allocated based on this size. However, the ELF symbol table
6523 always has a dummy entry as symbol #0, so it ends up even. */
6526 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6530 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6532 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6533 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6535 symtab_size -= sizeof (asymbol *);
6541 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6545 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6547 if (elf_dynsymtab (abfd) == 0)
6549 bfd_set_error (bfd_error_invalid_operation);
6553 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6554 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6556 symtab_size -= sizeof (asymbol *);
6562 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6565 return (asect->reloc_count + 1) * sizeof (arelent *);
6568 /* Canonicalize the relocs. */
6571 _bfd_elf_canonicalize_reloc (bfd *abfd,
6578 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6580 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6583 tblptr = section->relocation;
6584 for (i = 0; i < section->reloc_count; i++)
6585 *relptr++ = tblptr++;
6589 return section->reloc_count;
6593 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6595 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6596 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6599 bfd_get_symcount (abfd) = symcount;
6604 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6605 asymbol **allocation)
6607 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6608 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6611 bfd_get_dynamic_symcount (abfd) = symcount;
6615 /* Return the size required for the dynamic reloc entries. Any loadable
6616 section that was actually installed in the BFD, and has type SHT_REL
6617 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6618 dynamic reloc section. */
6621 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6626 if (elf_dynsymtab (abfd) == 0)
6628 bfd_set_error (bfd_error_invalid_operation);
6632 ret = sizeof (arelent *);
6633 for (s = abfd->sections; s != NULL; s = s->next)
6634 if ((s->flags & SEC_LOAD) != 0
6635 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6636 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6637 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6638 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6639 * sizeof (arelent *));
6644 /* Canonicalize the dynamic relocation entries. Note that we return the
6645 dynamic relocations as a single block, although they are actually
6646 associated with particular sections; the interface, which was
6647 designed for SunOS style shared libraries, expects that there is only
6648 one set of dynamic relocs. Any loadable section that was actually
6649 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6650 dynamic symbol table, is considered to be a dynamic reloc section. */
6653 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6657 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6661 if (elf_dynsymtab (abfd) == 0)
6663 bfd_set_error (bfd_error_invalid_operation);
6667 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6669 for (s = abfd->sections; s != NULL; s = s->next)
6671 if ((s->flags & SEC_LOAD) != 0
6672 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6673 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6674 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6679 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6681 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6683 for (i = 0; i < count; i++)
6694 /* Read in the version information. */
6697 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6699 bfd_byte *contents = NULL;
6700 unsigned int freeidx = 0;
6702 if (elf_dynverref (abfd) != 0)
6704 Elf_Internal_Shdr *hdr;
6705 Elf_External_Verneed *everneed;
6706 Elf_Internal_Verneed *iverneed;
6708 bfd_byte *contents_end;
6710 hdr = &elf_tdata (abfd)->dynverref_hdr;
6712 elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6713 sizeof (Elf_Internal_Verneed));
6714 if (elf_tdata (abfd)->verref == NULL)
6717 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6719 contents = bfd_malloc (hdr->sh_size);
6720 if (contents == NULL)
6722 error_return_verref:
6723 elf_tdata (abfd)->verref = NULL;
6724 elf_tdata (abfd)->cverrefs = 0;
6727 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6728 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6729 goto error_return_verref;
6731 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6732 goto error_return_verref;
6734 BFD_ASSERT (sizeof (Elf_External_Verneed)
6735 == sizeof (Elf_External_Vernaux));
6736 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6737 everneed = (Elf_External_Verneed *) contents;
6738 iverneed = elf_tdata (abfd)->verref;
6739 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6741 Elf_External_Vernaux *evernaux;
6742 Elf_Internal_Vernaux *ivernaux;
6745 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6747 iverneed->vn_bfd = abfd;
6749 iverneed->vn_filename =
6750 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6752 if (iverneed->vn_filename == NULL)
6753 goto error_return_verref;
6755 if (iverneed->vn_cnt == 0)
6756 iverneed->vn_auxptr = NULL;
6759 iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6760 sizeof (Elf_Internal_Vernaux));
6761 if (iverneed->vn_auxptr == NULL)
6762 goto error_return_verref;
6765 if (iverneed->vn_aux
6766 > (size_t) (contents_end - (bfd_byte *) everneed))
6767 goto error_return_verref;
6769 evernaux = ((Elf_External_Vernaux *)
6770 ((bfd_byte *) everneed + iverneed->vn_aux));
6771 ivernaux = iverneed->vn_auxptr;
6772 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6774 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6776 ivernaux->vna_nodename =
6777 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6778 ivernaux->vna_name);
6779 if (ivernaux->vna_nodename == NULL)
6780 goto error_return_verref;
6782 if (j + 1 < iverneed->vn_cnt)
6783 ivernaux->vna_nextptr = ivernaux + 1;
6785 ivernaux->vna_nextptr = NULL;
6787 if (ivernaux->vna_next
6788 > (size_t) (contents_end - (bfd_byte *) evernaux))
6789 goto error_return_verref;
6791 evernaux = ((Elf_External_Vernaux *)
6792 ((bfd_byte *) evernaux + ivernaux->vna_next));
6794 if (ivernaux->vna_other > freeidx)
6795 freeidx = ivernaux->vna_other;
6798 if (i + 1 < hdr->sh_info)
6799 iverneed->vn_nextref = iverneed + 1;
6801 iverneed->vn_nextref = NULL;
6803 if (iverneed->vn_next
6804 > (size_t) (contents_end - (bfd_byte *) everneed))
6805 goto error_return_verref;
6807 everneed = ((Elf_External_Verneed *)
6808 ((bfd_byte *) everneed + iverneed->vn_next));
6815 if (elf_dynverdef (abfd) != 0)
6817 Elf_Internal_Shdr *hdr;
6818 Elf_External_Verdef *everdef;
6819 Elf_Internal_Verdef *iverdef;
6820 Elf_Internal_Verdef *iverdefarr;
6821 Elf_Internal_Verdef iverdefmem;
6823 unsigned int maxidx;
6824 bfd_byte *contents_end_def, *contents_end_aux;
6826 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6828 contents = bfd_malloc (hdr->sh_size);
6829 if (contents == NULL)
6831 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6832 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6835 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6838 BFD_ASSERT (sizeof (Elf_External_Verdef)
6839 >= sizeof (Elf_External_Verdaux));
6840 contents_end_def = contents + hdr->sh_size
6841 - sizeof (Elf_External_Verdef);
6842 contents_end_aux = contents + hdr->sh_size
6843 - sizeof (Elf_External_Verdaux);
6845 /* We know the number of entries in the section but not the maximum
6846 index. Therefore we have to run through all entries and find
6848 everdef = (Elf_External_Verdef *) contents;
6850 for (i = 0; i < hdr->sh_info; ++i)
6852 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6854 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6855 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6857 if (iverdefmem.vd_next
6858 > (size_t) (contents_end_def - (bfd_byte *) everdef))
6861 everdef = ((Elf_External_Verdef *)
6862 ((bfd_byte *) everdef + iverdefmem.vd_next));
6865 if (default_imported_symver)
6867 if (freeidx > maxidx)
6872 elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6873 sizeof (Elf_Internal_Verdef));
6874 if (elf_tdata (abfd)->verdef == NULL)
6877 elf_tdata (abfd)->cverdefs = maxidx;
6879 everdef = (Elf_External_Verdef *) contents;
6880 iverdefarr = elf_tdata (abfd)->verdef;
6881 for (i = 0; i < hdr->sh_info; i++)
6883 Elf_External_Verdaux *everdaux;
6884 Elf_Internal_Verdaux *iverdaux;
6887 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6889 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6891 error_return_verdef:
6892 elf_tdata (abfd)->verdef = NULL;
6893 elf_tdata (abfd)->cverdefs = 0;
6897 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6898 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6900 iverdef->vd_bfd = abfd;
6902 if (iverdef->vd_cnt == 0)
6903 iverdef->vd_auxptr = NULL;
6906 iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6907 sizeof (Elf_Internal_Verdaux));
6908 if (iverdef->vd_auxptr == NULL)
6909 goto error_return_verdef;
6913 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6914 goto error_return_verdef;
6916 everdaux = ((Elf_External_Verdaux *)
6917 ((bfd_byte *) everdef + iverdef->vd_aux));
6918 iverdaux = iverdef->vd_auxptr;
6919 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6921 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6923 iverdaux->vda_nodename =
6924 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6925 iverdaux->vda_name);
6926 if (iverdaux->vda_nodename == NULL)
6927 goto error_return_verdef;
6929 if (j + 1 < iverdef->vd_cnt)
6930 iverdaux->vda_nextptr = iverdaux + 1;
6932 iverdaux->vda_nextptr = NULL;
6934 if (iverdaux->vda_next
6935 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6936 goto error_return_verdef;
6938 everdaux = ((Elf_External_Verdaux *)
6939 ((bfd_byte *) everdaux + iverdaux->vda_next));
6942 if (iverdef->vd_cnt)
6943 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6945 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6946 iverdef->vd_nextdef = iverdef + 1;
6948 iverdef->vd_nextdef = NULL;
6950 everdef = ((Elf_External_Verdef *)
6951 ((bfd_byte *) everdef + iverdef->vd_next));
6957 else if (default_imported_symver)
6964 elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6965 sizeof (Elf_Internal_Verdef));
6966 if (elf_tdata (abfd)->verdef == NULL)
6969 elf_tdata (abfd)->cverdefs = freeidx;
6972 /* Create a default version based on the soname. */
6973 if (default_imported_symver)
6975 Elf_Internal_Verdef *iverdef;
6976 Elf_Internal_Verdaux *iverdaux;
6978 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6980 iverdef->vd_version = VER_DEF_CURRENT;
6981 iverdef->vd_flags = 0;
6982 iverdef->vd_ndx = freeidx;
6983 iverdef->vd_cnt = 1;
6985 iverdef->vd_bfd = abfd;
6987 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6988 if (iverdef->vd_nodename == NULL)
6989 goto error_return_verdef;
6990 iverdef->vd_nextdef = NULL;
6991 iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6992 if (iverdef->vd_auxptr == NULL)
6993 goto error_return_verdef;
6995 iverdaux = iverdef->vd_auxptr;
6996 iverdaux->vda_nodename = iverdef->vd_nodename;
6997 iverdaux->vda_nextptr = NULL;
7003 if (contents != NULL)
7009 _bfd_elf_make_empty_symbol (bfd *abfd)
7011 elf_symbol_type *newsym;
7012 bfd_size_type amt = sizeof (elf_symbol_type);
7014 newsym = bfd_zalloc (abfd, amt);
7019 newsym->symbol.the_bfd = abfd;
7020 return &newsym->symbol;
7025 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7029 bfd_symbol_info (symbol, ret);
7032 /* Return whether a symbol name implies a local symbol. Most targets
7033 use this function for the is_local_label_name entry point, but some
7037 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7040 /* Normal local symbols start with ``.L''. */
7041 if (name[0] == '.' && name[1] == 'L')
7044 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7045 DWARF debugging symbols starting with ``..''. */
7046 if (name[0] == '.' && name[1] == '.')
7049 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7050 emitting DWARF debugging output. I suspect this is actually a
7051 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7052 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7053 underscore to be emitted on some ELF targets). For ease of use,
7054 we treat such symbols as local. */
7055 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7062 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7063 asymbol *symbol ATTRIBUTE_UNUSED)
7070 _bfd_elf_set_arch_mach (bfd *abfd,
7071 enum bfd_architecture arch,
7072 unsigned long machine)
7074 /* If this isn't the right architecture for this backend, and this
7075 isn't the generic backend, fail. */
7076 if (arch != get_elf_backend_data (abfd)->arch
7077 && arch != bfd_arch_unknown
7078 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7081 return bfd_default_set_arch_mach (abfd, arch, machine);
7084 /* Find the function to a particular section and offset,
7085 for error reporting. */
7088 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7092 const char **filename_ptr,
7093 const char **functionname_ptr)
7095 const char *filename;
7096 asymbol *func, *file;
7099 /* ??? Given multiple file symbols, it is impossible to reliably
7100 choose the right file name for global symbols. File symbols are
7101 local symbols, and thus all file symbols must sort before any
7102 global symbols. The ELF spec may be interpreted to say that a
7103 file symbol must sort before other local symbols, but currently
7104 ld -r doesn't do this. So, for ld -r output, it is possible to
7105 make a better choice of file name for local symbols by ignoring
7106 file symbols appearing after a given local symbol. */
7107 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7113 state = nothing_seen;
7115 for (p = symbols; *p != NULL; p++)
7119 q = (elf_symbol_type *) *p;
7121 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7127 if (state == symbol_seen)
7128 state = file_after_symbol_seen;
7132 if (bfd_get_section (&q->symbol) == section
7133 && q->symbol.value >= low_func
7134 && q->symbol.value <= offset)
7136 func = (asymbol *) q;
7137 low_func = q->symbol.value;
7140 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7141 || state != file_after_symbol_seen))
7142 filename = bfd_asymbol_name (file);
7146 if (state == nothing_seen)
7147 state = symbol_seen;
7154 *filename_ptr = filename;
7155 if (functionname_ptr)
7156 *functionname_ptr = bfd_asymbol_name (func);
7161 /* Find the nearest line to a particular section and offset,
7162 for error reporting. */
7165 _bfd_elf_find_nearest_line (bfd *abfd,
7169 const char **filename_ptr,
7170 const char **functionname_ptr,
7171 unsigned int *line_ptr)
7175 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7176 filename_ptr, functionname_ptr,
7179 if (!*functionname_ptr)
7180 elf_find_function (abfd, section, symbols, offset,
7181 *filename_ptr ? NULL : filename_ptr,
7187 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7188 filename_ptr, functionname_ptr,
7190 &elf_tdata (abfd)->dwarf2_find_line_info))
7192 if (!*functionname_ptr)
7193 elf_find_function (abfd, section, symbols, offset,
7194 *filename_ptr ? NULL : filename_ptr,
7200 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7201 &found, filename_ptr,
7202 functionname_ptr, line_ptr,
7203 &elf_tdata (abfd)->line_info))
7205 if (found && (*functionname_ptr || *line_ptr))
7208 if (symbols == NULL)
7211 if (! elf_find_function (abfd, section, symbols, offset,
7212 filename_ptr, functionname_ptr))
7219 /* Find the line for a symbol. */
7222 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7223 const char **filename_ptr, unsigned int *line_ptr)
7225 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7226 filename_ptr, line_ptr, 0,
7227 &elf_tdata (abfd)->dwarf2_find_line_info);
7230 /* After a call to bfd_find_nearest_line, successive calls to
7231 bfd_find_inliner_info can be used to get source information about
7232 each level of function inlining that terminated at the address
7233 passed to bfd_find_nearest_line. Currently this is only supported
7234 for DWARF2 with appropriate DWARF3 extensions. */
7237 _bfd_elf_find_inliner_info (bfd *abfd,
7238 const char **filename_ptr,
7239 const char **functionname_ptr,
7240 unsigned int *line_ptr)
7243 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7244 functionname_ptr, line_ptr,
7245 & elf_tdata (abfd)->dwarf2_find_line_info);
7250 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7252 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7253 int ret = bed->s->sizeof_ehdr;
7255 if (!info->relocatable)
7257 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7259 if (phdr_size == (bfd_size_type) -1)
7261 struct elf_segment_map *m;
7264 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7265 phdr_size += bed->s->sizeof_phdr;
7268 phdr_size = get_program_header_size (abfd, info);
7271 elf_tdata (abfd)->program_header_size = phdr_size;
7279 _bfd_elf_set_section_contents (bfd *abfd,
7281 const void *location,
7283 bfd_size_type count)
7285 Elf_Internal_Shdr *hdr;
7288 if (! abfd->output_has_begun
7289 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7292 hdr = &elf_section_data (section)->this_hdr;
7293 pos = hdr->sh_offset + offset;
7294 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7295 || bfd_bwrite (location, count, abfd) != count)
7302 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7303 arelent *cache_ptr ATTRIBUTE_UNUSED,
7304 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7309 /* Try to convert a non-ELF reloc into an ELF one. */
7312 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7314 /* Check whether we really have an ELF howto. */
7316 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7318 bfd_reloc_code_real_type code;
7319 reloc_howto_type *howto;
7321 /* Alien reloc: Try to determine its type to replace it with an
7322 equivalent ELF reloc. */
7324 if (areloc->howto->pc_relative)
7326 switch (areloc->howto->bitsize)
7329 code = BFD_RELOC_8_PCREL;
7332 code = BFD_RELOC_12_PCREL;
7335 code = BFD_RELOC_16_PCREL;
7338 code = BFD_RELOC_24_PCREL;
7341 code = BFD_RELOC_32_PCREL;
7344 code = BFD_RELOC_64_PCREL;
7350 howto = bfd_reloc_type_lookup (abfd, code);
7352 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7354 if (howto->pcrel_offset)
7355 areloc->addend += areloc->address;
7357 areloc->addend -= areloc->address; /* addend is unsigned!! */
7362 switch (areloc->howto->bitsize)
7368 code = BFD_RELOC_14;
7371 code = BFD_RELOC_16;
7374 code = BFD_RELOC_26;
7377 code = BFD_RELOC_32;
7380 code = BFD_RELOC_64;
7386 howto = bfd_reloc_type_lookup (abfd, code);
7390 areloc->howto = howto;
7398 (*_bfd_error_handler)
7399 (_("%B: unsupported relocation type %s"),
7400 abfd, areloc->howto->name);
7401 bfd_set_error (bfd_error_bad_value);
7406 _bfd_elf_close_and_cleanup (bfd *abfd)
7408 if (bfd_get_format (abfd) == bfd_object)
7410 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7411 _bfd_elf_strtab_free (elf_shstrtab (abfd));
7412 _bfd_dwarf2_cleanup_debug_info (abfd);
7415 return _bfd_generic_close_and_cleanup (abfd);
7418 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7419 in the relocation's offset. Thus we cannot allow any sort of sanity
7420 range-checking to interfere. There is nothing else to do in processing
7423 bfd_reloc_status_type
7424 _bfd_elf_rel_vtable_reloc_fn
7425 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7426 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7427 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7428 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7430 return bfd_reloc_ok;
7433 /* Elf core file support. Much of this only works on native
7434 toolchains, since we rely on knowing the
7435 machine-dependent procfs structure in order to pick
7436 out details about the corefile. */
7438 #ifdef HAVE_SYS_PROCFS_H
7439 # include <sys/procfs.h>
7442 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7445 elfcore_make_pid (bfd *abfd)
7447 return ((elf_tdata (abfd)->core_lwpid << 16)
7448 + (elf_tdata (abfd)->core_pid));
7451 /* If there isn't a section called NAME, make one, using
7452 data from SECT. Note, this function will generate a
7453 reference to NAME, so you shouldn't deallocate or
7457 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7461 if (bfd_get_section_by_name (abfd, name) != NULL)
7464 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7468 sect2->size = sect->size;
7469 sect2->filepos = sect->filepos;
7470 sect2->alignment_power = sect->alignment_power;
7474 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7475 actually creates up to two pseudosections:
7476 - For the single-threaded case, a section named NAME, unless
7477 such a section already exists.
7478 - For the multi-threaded case, a section named "NAME/PID", where
7479 PID is elfcore_make_pid (abfd).
7480 Both pseudosections have identical contents. */
7482 _bfd_elfcore_make_pseudosection (bfd *abfd,
7488 char *threaded_name;
7492 /* Build the section name. */
7494 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7495 len = strlen (buf) + 1;
7496 threaded_name = bfd_alloc (abfd, len);
7497 if (threaded_name == NULL)
7499 memcpy (threaded_name, buf, len);
7501 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7506 sect->filepos = filepos;
7507 sect->alignment_power = 2;
7509 return elfcore_maybe_make_sect (abfd, name, sect);
7512 /* prstatus_t exists on:
7514 linux 2.[01] + glibc
7518 #if defined (HAVE_PRSTATUS_T)
7521 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7526 if (note->descsz == sizeof (prstatus_t))
7530 size = sizeof (prstat.pr_reg);
7531 offset = offsetof (prstatus_t, pr_reg);
7532 memcpy (&prstat, note->descdata, sizeof (prstat));
7534 /* Do not overwrite the core signal if it
7535 has already been set by another thread. */
7536 if (elf_tdata (abfd)->core_signal == 0)
7537 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7538 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7540 /* pr_who exists on:
7543 pr_who doesn't exist on:
7546 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7547 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7550 #if defined (HAVE_PRSTATUS32_T)
7551 else if (note->descsz == sizeof (prstatus32_t))
7553 /* 64-bit host, 32-bit corefile */
7554 prstatus32_t prstat;
7556 size = sizeof (prstat.pr_reg);
7557 offset = offsetof (prstatus32_t, pr_reg);
7558 memcpy (&prstat, note->descdata, sizeof (prstat));
7560 /* Do not overwrite the core signal if it
7561 has already been set by another thread. */
7562 if (elf_tdata (abfd)->core_signal == 0)
7563 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7564 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7566 /* pr_who exists on:
7569 pr_who doesn't exist on:
7572 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7573 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7576 #endif /* HAVE_PRSTATUS32_T */
7579 /* Fail - we don't know how to handle any other
7580 note size (ie. data object type). */
7584 /* Make a ".reg/999" section and a ".reg" section. */
7585 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7586 size, note->descpos + offset);
7588 #endif /* defined (HAVE_PRSTATUS_T) */
7590 /* Create a pseudosection containing the exact contents of NOTE. */
7592 elfcore_make_note_pseudosection (bfd *abfd,
7594 Elf_Internal_Note *note)
7596 return _bfd_elfcore_make_pseudosection (abfd, name,
7597 note->descsz, note->descpos);
7600 /* There isn't a consistent prfpregset_t across platforms,
7601 but it doesn't matter, because we don't have to pick this
7602 data structure apart. */
7605 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7607 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7610 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7611 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7615 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7617 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7620 #if defined (HAVE_PRPSINFO_T)
7621 typedef prpsinfo_t elfcore_psinfo_t;
7622 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7623 typedef prpsinfo32_t elfcore_psinfo32_t;
7627 #if defined (HAVE_PSINFO_T)
7628 typedef psinfo_t elfcore_psinfo_t;
7629 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7630 typedef psinfo32_t elfcore_psinfo32_t;
7634 /* return a malloc'ed copy of a string at START which is at
7635 most MAX bytes long, possibly without a terminating '\0'.
7636 the copy will always have a terminating '\0'. */
7639 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7642 char *end = memchr (start, '\0', max);
7650 dups = bfd_alloc (abfd, len + 1);
7654 memcpy (dups, start, len);
7660 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7662 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7664 if (note->descsz == sizeof (elfcore_psinfo_t))
7666 elfcore_psinfo_t psinfo;
7668 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7670 elf_tdata (abfd)->core_program
7671 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7672 sizeof (psinfo.pr_fname));
7674 elf_tdata (abfd)->core_command
7675 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7676 sizeof (psinfo.pr_psargs));
7678 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7679 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7681 /* 64-bit host, 32-bit corefile */
7682 elfcore_psinfo32_t psinfo;
7684 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7686 elf_tdata (abfd)->core_program
7687 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7688 sizeof (psinfo.pr_fname));
7690 elf_tdata (abfd)->core_command
7691 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7692 sizeof (psinfo.pr_psargs));
7698 /* Fail - we don't know how to handle any other
7699 note size (ie. data object type). */
7703 /* Note that for some reason, a spurious space is tacked
7704 onto the end of the args in some (at least one anyway)
7705 implementations, so strip it off if it exists. */
7708 char *command = elf_tdata (abfd)->core_command;
7709 int n = strlen (command);
7711 if (0 < n && command[n - 1] == ' ')
7712 command[n - 1] = '\0';
7717 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7719 #if defined (HAVE_PSTATUS_T)
7721 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7723 if (note->descsz == sizeof (pstatus_t)
7724 #if defined (HAVE_PXSTATUS_T)
7725 || note->descsz == sizeof (pxstatus_t)
7731 memcpy (&pstat, note->descdata, sizeof (pstat));
7733 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7735 #if defined (HAVE_PSTATUS32_T)
7736 else if (note->descsz == sizeof (pstatus32_t))
7738 /* 64-bit host, 32-bit corefile */
7741 memcpy (&pstat, note->descdata, sizeof (pstat));
7743 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7746 /* Could grab some more details from the "representative"
7747 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7748 NT_LWPSTATUS note, presumably. */
7752 #endif /* defined (HAVE_PSTATUS_T) */
7754 #if defined (HAVE_LWPSTATUS_T)
7756 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7758 lwpstatus_t lwpstat;
7764 if (note->descsz != sizeof (lwpstat)
7765 #if defined (HAVE_LWPXSTATUS_T)
7766 && note->descsz != sizeof (lwpxstatus_t)
7771 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7773 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7774 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7776 /* Make a ".reg/999" section. */
7778 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7779 len = strlen (buf) + 1;
7780 name = bfd_alloc (abfd, len);
7783 memcpy (name, buf, len);
7785 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7789 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7790 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7791 sect->filepos = note->descpos
7792 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7795 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7796 sect->size = sizeof (lwpstat.pr_reg);
7797 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7800 sect->alignment_power = 2;
7802 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7805 /* Make a ".reg2/999" section */
7807 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7808 len = strlen (buf) + 1;
7809 name = bfd_alloc (abfd, len);
7812 memcpy (name, buf, len);
7814 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7818 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7819 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7820 sect->filepos = note->descpos
7821 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7824 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7825 sect->size = sizeof (lwpstat.pr_fpreg);
7826 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7829 sect->alignment_power = 2;
7831 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7833 #endif /* defined (HAVE_LWPSTATUS_T) */
7835 #if defined (HAVE_WIN32_PSTATUS_T)
7837 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7843 win32_pstatus_t pstatus;
7845 if (note->descsz < sizeof (pstatus))
7848 memcpy (&pstatus, note->descdata, sizeof (pstatus));
7850 switch (pstatus.data_type)
7852 case NOTE_INFO_PROCESS:
7853 /* FIXME: need to add ->core_command. */
7854 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7855 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
7858 case NOTE_INFO_THREAD:
7859 /* Make a ".reg/999" section. */
7860 sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
7862 len = strlen (buf) + 1;
7863 name = bfd_alloc (abfd, len);
7867 memcpy (name, buf, len);
7869 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7873 sect->size = sizeof (pstatus.data.thread_info.thread_context);
7874 sect->filepos = (note->descpos
7875 + offsetof (struct win32_pstatus,
7876 data.thread_info.thread_context));
7877 sect->alignment_power = 2;
7879 if (pstatus.data.thread_info.is_active_thread)
7880 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7884 case NOTE_INFO_MODULE:
7885 /* Make a ".module/xxxxxxxx" section. */
7886 sprintf (buf, ".module/%08lx",
7887 (long) pstatus.data.module_info.base_address);
7889 len = strlen (buf) + 1;
7890 name = bfd_alloc (abfd, len);
7894 memcpy (name, buf, len);
7896 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7901 sect->size = note->descsz;
7902 sect->filepos = note->descpos;
7903 sect->alignment_power = 2;
7912 #endif /* HAVE_WIN32_PSTATUS_T */
7915 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7917 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7925 if (bed->elf_backend_grok_prstatus)
7926 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7928 #if defined (HAVE_PRSTATUS_T)
7929 return elfcore_grok_prstatus (abfd, note);
7934 #if defined (HAVE_PSTATUS_T)
7936 return elfcore_grok_pstatus (abfd, note);
7939 #if defined (HAVE_LWPSTATUS_T)
7941 return elfcore_grok_lwpstatus (abfd, note);
7944 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7945 return elfcore_grok_prfpreg (abfd, note);
7947 #if defined (HAVE_WIN32_PSTATUS_T)
7948 case NT_WIN32PSTATUS:
7949 return elfcore_grok_win32pstatus (abfd, note);
7952 case NT_PRXFPREG: /* Linux SSE extension */
7953 if (note->namesz == 6
7954 && strcmp (note->namedata, "LINUX") == 0)
7955 return elfcore_grok_prxfpreg (abfd, note);
7961 if (bed->elf_backend_grok_psinfo)
7962 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7964 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7965 return elfcore_grok_psinfo (abfd, note);
7972 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7977 sect->size = note->descsz;
7978 sect->filepos = note->descpos;
7979 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7987 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7991 cp = strchr (note->namedata, '@');
7994 *lwpidp = atoi(cp + 1);
8001 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8003 /* Signal number at offset 0x08. */
8004 elf_tdata (abfd)->core_signal
8005 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8007 /* Process ID at offset 0x50. */
8008 elf_tdata (abfd)->core_pid
8009 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8011 /* Command name at 0x7c (max 32 bytes, including nul). */
8012 elf_tdata (abfd)->core_command
8013 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8015 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8020 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8024 if (elfcore_netbsd_get_lwpid (note, &lwp))
8025 elf_tdata (abfd)->core_lwpid = lwp;
8027 if (note->type == NT_NETBSDCORE_PROCINFO)
8029 /* NetBSD-specific core "procinfo". Note that we expect to
8030 find this note before any of the others, which is fine,
8031 since the kernel writes this note out first when it
8032 creates a core file. */
8034 return elfcore_grok_netbsd_procinfo (abfd, note);
8037 /* As of Jan 2002 there are no other machine-independent notes
8038 defined for NetBSD core files. If the note type is less
8039 than the start of the machine-dependent note types, we don't
8042 if (note->type < NT_NETBSDCORE_FIRSTMACH)
8046 switch (bfd_get_arch (abfd))
8048 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8049 PT_GETFPREGS == mach+2. */
8051 case bfd_arch_alpha:
8052 case bfd_arch_sparc:
8055 case NT_NETBSDCORE_FIRSTMACH+0:
8056 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8058 case NT_NETBSDCORE_FIRSTMACH+2:
8059 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8065 /* On all other arch's, PT_GETREGS == mach+1 and
8066 PT_GETFPREGS == mach+3. */
8071 case NT_NETBSDCORE_FIRSTMACH+1:
8072 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8074 case NT_NETBSDCORE_FIRSTMACH+3:
8075 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8085 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8087 void *ddata = note->descdata;
8094 /* nto_procfs_status 'pid' field is at offset 0. */
8095 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8097 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8098 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8100 /* nto_procfs_status 'flags' field is at offset 8. */
8101 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8103 /* nto_procfs_status 'what' field is at offset 14. */
8104 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8106 elf_tdata (abfd)->core_signal = sig;
8107 elf_tdata (abfd)->core_lwpid = *tid;
8110 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8111 do not come from signals so we make sure we set the current
8112 thread just in case. */
8113 if (flags & 0x00000080)
8114 elf_tdata (abfd)->core_lwpid = *tid;
8116 /* Make a ".qnx_core_status/%d" section. */
8117 sprintf (buf, ".qnx_core_status/%ld", *tid);
8119 name = bfd_alloc (abfd, strlen (buf) + 1);
8124 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8128 sect->size = note->descsz;
8129 sect->filepos = note->descpos;
8130 sect->alignment_power = 2;
8132 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8136 elfcore_grok_nto_regs (bfd *abfd,
8137 Elf_Internal_Note *note,
8145 /* Make a "(base)/%d" section. */
8146 sprintf (buf, "%s/%ld", base, tid);
8148 name = bfd_alloc (abfd, strlen (buf) + 1);
8153 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8157 sect->size = note->descsz;
8158 sect->filepos = note->descpos;
8159 sect->alignment_power = 2;
8161 /* This is the current thread. */
8162 if (elf_tdata (abfd)->core_lwpid == tid)
8163 return elfcore_maybe_make_sect (abfd, base, sect);
8168 #define BFD_QNT_CORE_INFO 7
8169 #define BFD_QNT_CORE_STATUS 8
8170 #define BFD_QNT_CORE_GREG 9
8171 #define BFD_QNT_CORE_FPREG 10
8174 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8176 /* Every GREG section has a STATUS section before it. Store the
8177 tid from the previous call to pass down to the next gregs
8179 static long tid = 1;
8183 case BFD_QNT_CORE_INFO:
8184 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8185 case BFD_QNT_CORE_STATUS:
8186 return elfcore_grok_nto_status (abfd, note, &tid);
8187 case BFD_QNT_CORE_GREG:
8188 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8189 case BFD_QNT_CORE_FPREG:
8190 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8196 /* Function: elfcore_write_note
8199 buffer to hold note, and current size of buffer
8203 size of data for note
8205 Writes note to end of buffer. ELF64 notes are written exactly as
8206 for ELF32, despite the current (as of 2006) ELF gabi specifying
8207 that they ought to have 8-byte namesz and descsz field, and have
8208 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8211 Pointer to realloc'd buffer, *BUFSIZ updated. */
8214 elfcore_write_note (bfd *abfd,
8222 Elf_External_Note *xnp;
8229 namesz = strlen (name) + 1;
8231 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8233 buf = realloc (buf, *bufsiz + newspace);
8234 dest = buf + *bufsiz;
8235 *bufsiz += newspace;
8236 xnp = (Elf_External_Note *) dest;
8237 H_PUT_32 (abfd, namesz, xnp->namesz);
8238 H_PUT_32 (abfd, size, xnp->descsz);
8239 H_PUT_32 (abfd, type, xnp->type);
8243 memcpy (dest, name, namesz);
8251 memcpy (dest, input, size);
8261 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8263 elfcore_write_prpsinfo (bfd *abfd,
8269 const char *note_name = "CORE";
8270 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8272 if (bed->elf_backend_write_core_note != NULL)
8275 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8276 NT_PRPSINFO, fname, psargs);
8281 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8282 if (bed->s->elfclass == ELFCLASS32)
8284 #if defined (HAVE_PSINFO32_T)
8286 int note_type = NT_PSINFO;
8289 int note_type = NT_PRPSINFO;
8292 memset (&data, 0, sizeof (data));
8293 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8294 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8295 return elfcore_write_note (abfd, buf, bufsiz,
8296 note_name, note_type, &data, sizeof (data));
8301 #if defined (HAVE_PSINFO_T)
8303 int note_type = NT_PSINFO;
8306 int note_type = NT_PRPSINFO;
8309 memset (&data, 0, sizeof (data));
8310 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8311 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8312 return elfcore_write_note (abfd, buf, bufsiz,
8313 note_name, note_type, &data, sizeof (data));
8316 #endif /* PSINFO_T or PRPSINFO_T */
8318 #if defined (HAVE_PRSTATUS_T)
8320 elfcore_write_prstatus (bfd *abfd,
8327 const char *note_name = "CORE";
8328 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8330 if (bed->elf_backend_write_core_note != NULL)
8333 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8335 pid, cursig, gregs);
8340 #if defined (HAVE_PRSTATUS32_T)
8341 if (bed->s->elfclass == ELFCLASS32)
8343 prstatus32_t prstat;
8345 memset (&prstat, 0, sizeof (prstat));
8346 prstat.pr_pid = pid;
8347 prstat.pr_cursig = cursig;
8348 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8349 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8350 NT_PRSTATUS, &prstat, sizeof (prstat));
8357 memset (&prstat, 0, sizeof (prstat));
8358 prstat.pr_pid = pid;
8359 prstat.pr_cursig = cursig;
8360 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8361 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8362 NT_PRSTATUS, &prstat, sizeof (prstat));
8365 #endif /* HAVE_PRSTATUS_T */
8367 #if defined (HAVE_LWPSTATUS_T)
8369 elfcore_write_lwpstatus (bfd *abfd,
8376 lwpstatus_t lwpstat;
8377 const char *note_name = "CORE";
8379 memset (&lwpstat, 0, sizeof (lwpstat));
8380 lwpstat.pr_lwpid = pid >> 16;
8381 lwpstat.pr_cursig = cursig;
8382 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8383 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8384 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8386 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8387 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8389 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8390 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8393 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8394 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8396 #endif /* HAVE_LWPSTATUS_T */
8398 #if defined (HAVE_PSTATUS_T)
8400 elfcore_write_pstatus (bfd *abfd,
8404 int cursig ATTRIBUTE_UNUSED,
8405 const void *gregs ATTRIBUTE_UNUSED)
8407 const char *note_name = "CORE";
8408 #if defined (HAVE_PSTATUS32_T)
8409 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8411 if (bed->s->elfclass == ELFCLASS32)
8415 memset (&pstat, 0, sizeof (pstat));
8416 pstat.pr_pid = pid & 0xffff;
8417 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8418 NT_PSTATUS, &pstat, sizeof (pstat));
8426 memset (&pstat, 0, sizeof (pstat));
8427 pstat.pr_pid = pid & 0xffff;
8428 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8429 NT_PSTATUS, &pstat, sizeof (pstat));
8433 #endif /* HAVE_PSTATUS_T */
8436 elfcore_write_prfpreg (bfd *abfd,
8442 const char *note_name = "CORE";
8443 return elfcore_write_note (abfd, buf, bufsiz,
8444 note_name, NT_FPREGSET, fpregs, size);
8448 elfcore_write_prxfpreg (bfd *abfd,
8451 const void *xfpregs,
8454 char *note_name = "LINUX";
8455 return elfcore_write_note (abfd, buf, bufsiz,
8456 note_name, NT_PRXFPREG, xfpregs, size);
8460 elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8468 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8471 buf = bfd_malloc (size);
8475 if (bfd_bread (buf, size, abfd) != size)
8483 while (p < buf + size)
8485 /* FIXME: bad alignment assumption. */
8486 Elf_External_Note *xnp = (Elf_External_Note *) p;
8487 Elf_Internal_Note in;
8489 in.type = H_GET_32 (abfd, xnp->type);
8491 in.namesz = H_GET_32 (abfd, xnp->namesz);
8492 in.namedata = xnp->name;
8494 in.descsz = H_GET_32 (abfd, xnp->descsz);
8495 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8496 in.descpos = offset + (in.descdata - buf);
8498 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8500 if (! elfcore_grok_netbsd_note (abfd, &in))
8503 else if (CONST_STRNEQ (in.namedata, "QNX"))
8505 if (! elfcore_grok_nto_note (abfd, &in))
8510 if (! elfcore_grok_note (abfd, &in))
8514 p = in.descdata + BFD_ALIGN (in.descsz, 4);
8521 /* Providing external access to the ELF program header table. */
8523 /* Return an upper bound on the number of bytes required to store a
8524 copy of ABFD's program header table entries. Return -1 if an error
8525 occurs; bfd_get_error will return an appropriate code. */
8528 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8530 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8532 bfd_set_error (bfd_error_wrong_format);
8536 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8539 /* Copy ABFD's program header table entries to *PHDRS. The entries
8540 will be stored as an array of Elf_Internal_Phdr structures, as
8541 defined in include/elf/internal.h. To find out how large the
8542 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8544 Return the number of program header table entries read, or -1 if an
8545 error occurs; bfd_get_error will return an appropriate code. */
8548 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8552 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8554 bfd_set_error (bfd_error_wrong_format);
8558 num_phdrs = elf_elfheader (abfd)->e_phnum;
8559 memcpy (phdrs, elf_tdata (abfd)->phdr,
8560 num_phdrs * sizeof (Elf_Internal_Phdr));
8566 _bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
8569 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
8571 i_ehdrp = elf_elfheader (abfd);
8572 if (i_ehdrp == NULL)
8573 sprintf_vma (buf, value);
8576 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8578 #if BFD_HOST_64BIT_LONG
8579 sprintf (buf, "%016lx", value);
8581 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
8582 _bfd_int64_low (value));
8586 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
8589 sprintf_vma (buf, value);
8594 _bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
8597 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
8599 i_ehdrp = elf_elfheader (abfd);
8600 if (i_ehdrp == NULL)
8601 fprintf_vma ((FILE *) stream, value);
8604 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
8606 #if BFD_HOST_64BIT_LONG
8607 fprintf ((FILE *) stream, "%016lx", value);
8609 fprintf ((FILE *) stream, "%08lx%08lx",
8610 _bfd_int64_high (value), _bfd_int64_low (value));
8614 fprintf ((FILE *) stream, "%08lx",
8615 (unsigned long) (value & 0xffffffff));
8618 fprintf_vma ((FILE *) stream, value);
8622 enum elf_reloc_type_class
8623 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8625 return reloc_class_normal;
8628 /* For RELA architectures, return the relocation value for a
8629 relocation against a local symbol. */
8632 _bfd_elf_rela_local_sym (bfd *abfd,
8633 Elf_Internal_Sym *sym,
8635 Elf_Internal_Rela *rel)
8637 asection *sec = *psec;
8640 relocation = (sec->output_section->vma
8641 + sec->output_offset
8643 if ((sec->flags & SEC_MERGE)
8644 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8645 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8648 _bfd_merged_section_offset (abfd, psec,
8649 elf_section_data (sec)->sec_info,
8650 sym->st_value + rel->r_addend);
8653 /* If we have changed the section, and our original section is
8654 marked with SEC_EXCLUDE, it means that the original
8655 SEC_MERGE section has been completely subsumed in some
8656 other SEC_MERGE section. In this case, we need to leave
8657 some info around for --emit-relocs. */
8658 if ((sec->flags & SEC_EXCLUDE) != 0)
8659 sec->kept_section = *psec;
8662 rel->r_addend -= relocation;
8663 rel->r_addend += sec->output_section->vma + sec->output_offset;
8669 _bfd_elf_rel_local_sym (bfd *abfd,
8670 Elf_Internal_Sym *sym,
8674 asection *sec = *psec;
8676 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8677 return sym->st_value + addend;
8679 return _bfd_merged_section_offset (abfd, psec,
8680 elf_section_data (sec)->sec_info,
8681 sym->st_value + addend);
8685 _bfd_elf_section_offset (bfd *abfd,
8686 struct bfd_link_info *info,
8690 switch (sec->sec_info_type)
8692 case ELF_INFO_TYPE_STABS:
8693 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8695 case ELF_INFO_TYPE_EH_FRAME:
8696 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8702 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8703 reconstruct an ELF file by reading the segments out of remote memory
8704 based on the ELF file header at EHDR_VMA and the ELF program headers it
8705 points to. If not null, *LOADBASEP is filled in with the difference
8706 between the VMAs from which the segments were read, and the VMAs the
8707 file headers (and hence BFD's idea of each section's VMA) put them at.
8709 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8710 remote memory at target address VMA into the local buffer at MYADDR; it
8711 should return zero on success or an `errno' code on failure. TEMPL must
8712 be a BFD for an ELF target with the word size and byte order found in
8713 the remote memory. */
8716 bfd_elf_bfd_from_remote_memory
8720 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8722 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8723 (templ, ehdr_vma, loadbasep, target_read_memory);
8727 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8728 long symcount ATTRIBUTE_UNUSED,
8729 asymbol **syms ATTRIBUTE_UNUSED,
8734 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8737 const char *relplt_name;
8738 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8742 Elf_Internal_Shdr *hdr;
8748 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8751 if (dynsymcount <= 0)
8754 if (!bed->plt_sym_val)
8757 relplt_name = bed->relplt_name;
8758 if (relplt_name == NULL)
8759 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8760 relplt = bfd_get_section_by_name (abfd, relplt_name);
8764 hdr = &elf_section_data (relplt)->this_hdr;
8765 if (hdr->sh_link != elf_dynsymtab (abfd)
8766 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8769 plt = bfd_get_section_by_name (abfd, ".plt");
8773 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8774 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8777 count = relplt->size / hdr->sh_entsize;
8778 size = count * sizeof (asymbol);
8779 p = relplt->relocation;
8780 for (i = 0; i < count; i++, s++, p++)
8781 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8783 s = *ret = bfd_malloc (size);
8787 names = (char *) (s + count);
8788 p = relplt->relocation;
8790 for (i = 0; i < count; i++, s++, p++)
8795 addr = bed->plt_sym_val (i, plt, p);
8796 if (addr == (bfd_vma) -1)
8799 *s = **p->sym_ptr_ptr;
8800 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8801 we are defining a symbol, ensure one of them is set. */
8802 if ((s->flags & BSF_LOCAL) == 0)
8803 s->flags |= BSF_GLOBAL;
8805 s->value = addr - plt->vma;
8807 len = strlen ((*p->sym_ptr_ptr)->name);
8808 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8810 memcpy (names, "@plt", sizeof ("@plt"));
8811 names += sizeof ("@plt");
8818 struct elf_symbuf_symbol
8820 unsigned long st_name; /* Symbol name, index in string tbl */
8821 unsigned char st_info; /* Type and binding attributes */
8822 unsigned char st_other; /* Visibilty, and target specific */
8825 struct elf_symbuf_head
8827 struct elf_symbuf_symbol *ssym;
8828 bfd_size_type count;
8829 unsigned int st_shndx;
8836 Elf_Internal_Sym *isym;
8837 struct elf_symbuf_symbol *ssym;
8842 /* Sort references to symbols by ascending section number. */
8845 elf_sort_elf_symbol (const void *arg1, const void *arg2)
8847 const Elf_Internal_Sym *s1 = *(const Elf_Internal_Sym **) arg1;
8848 const Elf_Internal_Sym *s2 = *(const Elf_Internal_Sym **) arg2;
8850 return s1->st_shndx - s2->st_shndx;
8854 elf_sym_name_compare (const void *arg1, const void *arg2)
8856 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8857 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8858 return strcmp (s1->name, s2->name);
8861 static struct elf_symbuf_head *
8862 elf_create_symbuf (bfd_size_type symcount, Elf_Internal_Sym *isymbuf)
8864 Elf_Internal_Sym **ind, **indbufend, **indbuf
8865 = bfd_malloc2 (symcount, sizeof (*indbuf));
8866 struct elf_symbuf_symbol *ssym;
8867 struct elf_symbuf_head *ssymbuf, *ssymhead;
8868 bfd_size_type i, shndx_count;
8873 for (ind = indbuf, i = 0; i < symcount; i++)
8874 if (isymbuf[i].st_shndx != SHN_UNDEF)
8875 *ind++ = &isymbuf[i];
8878 qsort (indbuf, indbufend - indbuf, sizeof (Elf_Internal_Sym *),
8879 elf_sort_elf_symbol);
8882 if (indbufend > indbuf)
8883 for (ind = indbuf, shndx_count++; ind < indbufend - 1; ind++)
8884 if (ind[0]->st_shndx != ind[1]->st_shndx)
8887 ssymbuf = bfd_malloc ((shndx_count + 1) * sizeof (*ssymbuf)
8888 + (indbufend - indbuf) * sizeof (*ssymbuf));
8889 if (ssymbuf == NULL)
8895 ssym = (struct elf_symbuf_symbol *) (ssymbuf + shndx_count);
8896 ssymbuf->ssym = NULL;
8897 ssymbuf->count = shndx_count;
8898 ssymbuf->st_shndx = 0;
8899 for (ssymhead = ssymbuf, ind = indbuf; ind < indbufend; ssym++, ind++)
8901 if (ind == indbuf || ssymhead->st_shndx != (*ind)->st_shndx)
8904 ssymhead->ssym = ssym;
8905 ssymhead->count = 0;
8906 ssymhead->st_shndx = (*ind)->st_shndx;
8908 ssym->st_name = (*ind)->st_name;
8909 ssym->st_info = (*ind)->st_info;
8910 ssym->st_other = (*ind)->st_other;
8913 BFD_ASSERT ((bfd_size_type) (ssymhead - ssymbuf) == shndx_count);
8919 /* Check if 2 sections define the same set of local and global
8923 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
8924 struct bfd_link_info *info)
8927 const struct elf_backend_data *bed1, *bed2;
8928 Elf_Internal_Shdr *hdr1, *hdr2;
8929 bfd_size_type symcount1, symcount2;
8930 Elf_Internal_Sym *isymbuf1, *isymbuf2;
8931 struct elf_symbuf_head *ssymbuf1, *ssymbuf2;
8932 Elf_Internal_Sym *isym, *isymend;
8933 struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
8934 bfd_size_type count1, count2, i;
8941 /* If both are .gnu.linkonce sections, they have to have the same
8943 if (CONST_STRNEQ (sec1->name, ".gnu.linkonce")
8944 && CONST_STRNEQ (sec2->name, ".gnu.linkonce"))
8945 return strcmp (sec1->name + sizeof ".gnu.linkonce",
8946 sec2->name + sizeof ".gnu.linkonce") == 0;
8948 /* Both sections have to be in ELF. */
8949 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8950 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8953 if (elf_section_type (sec1) != elf_section_type (sec2))
8956 if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8957 && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8959 /* If both are members of section groups, they have to have the
8961 if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8965 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8966 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8967 if (shndx1 == -1 || shndx2 == -1)
8970 bed1 = get_elf_backend_data (bfd1);
8971 bed2 = get_elf_backend_data (bfd2);
8972 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8973 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8974 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8975 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8977 if (symcount1 == 0 || symcount2 == 0)
8983 ssymbuf1 = elf_tdata (bfd1)->symbuf;
8984 ssymbuf2 = elf_tdata (bfd2)->symbuf;
8986 if (ssymbuf1 == NULL)
8988 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8990 if (isymbuf1 == NULL)
8993 if (!info->reduce_memory_overheads)
8994 elf_tdata (bfd1)->symbuf = ssymbuf1
8995 = elf_create_symbuf (symcount1, isymbuf1);
8998 if (ssymbuf1 == NULL || ssymbuf2 == NULL)
9000 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
9002 if (isymbuf2 == NULL)
9005 if (ssymbuf1 != NULL && !info->reduce_memory_overheads)
9006 elf_tdata (bfd2)->symbuf = ssymbuf2
9007 = elf_create_symbuf (symcount2, isymbuf2);
9010 if (ssymbuf1 != NULL && ssymbuf2 != NULL)
9012 /* Optimized faster version. */
9013 bfd_size_type lo, hi, mid;
9014 struct elf_symbol *symp;
9015 struct elf_symbuf_symbol *ssym, *ssymend;
9018 hi = ssymbuf1->count;
9023 mid = (lo + hi) / 2;
9024 if ((unsigned int) shndx1 < ssymbuf1[mid].st_shndx)
9026 else if ((unsigned int) shndx1 > ssymbuf1[mid].st_shndx)
9030 count1 = ssymbuf1[mid].count;
9037 hi = ssymbuf2->count;
9042 mid = (lo + hi) / 2;
9043 if ((unsigned int) shndx2 < ssymbuf2[mid].st_shndx)
9045 else if ((unsigned int) shndx2 > ssymbuf2[mid].st_shndx)
9049 count2 = ssymbuf2[mid].count;
9055 if (count1 == 0 || count2 == 0 || count1 != count2)
9058 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
9059 symtable2 = bfd_malloc (count2 * sizeof (struct elf_symbol));
9060 if (symtable1 == NULL || symtable2 == NULL)
9064 for (ssym = ssymbuf1->ssym, ssymend = ssym + count1;
9065 ssym < ssymend; ssym++, symp++)
9067 symp->u.ssym = ssym;
9068 symp->name = bfd_elf_string_from_elf_section (bfd1,
9074 for (ssym = ssymbuf2->ssym, ssymend = ssym + count2;
9075 ssym < ssymend; ssym++, symp++)
9077 symp->u.ssym = ssym;
9078 symp->name = bfd_elf_string_from_elf_section (bfd2,
9083 /* Sort symbol by name. */
9084 qsort (symtable1, count1, sizeof (struct elf_symbol),
9085 elf_sym_name_compare);
9086 qsort (symtable2, count1, sizeof (struct elf_symbol),
9087 elf_sym_name_compare);
9089 for (i = 0; i < count1; i++)
9090 /* Two symbols must have the same binding, type and name. */
9091 if (symtable1 [i].u.ssym->st_info != symtable2 [i].u.ssym->st_info
9092 || symtable1 [i].u.ssym->st_other != symtable2 [i].u.ssym->st_other
9093 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
9100 symtable1 = bfd_malloc (symcount1 * sizeof (struct elf_symbol));
9101 symtable2 = bfd_malloc (symcount2 * sizeof (struct elf_symbol));
9102 if (symtable1 == NULL || symtable2 == NULL)
9105 /* Count definitions in the section. */
9107 for (isym = isymbuf1, isymend = isym + symcount1; isym < isymend; isym++)
9108 if (isym->st_shndx == (unsigned int) shndx1)
9109 symtable1[count1++].u.isym = isym;
9112 for (isym = isymbuf2, isymend = isym + symcount2; isym < isymend; isym++)
9113 if (isym->st_shndx == (unsigned int) shndx2)
9114 symtable2[count2++].u.isym = isym;
9116 if (count1 == 0 || count2 == 0 || count1 != count2)
9119 for (i = 0; i < count1; i++)
9121 = bfd_elf_string_from_elf_section (bfd1, hdr1->sh_link,
9122 symtable1[i].u.isym->st_name);
9124 for (i = 0; i < count2; i++)
9126 = bfd_elf_string_from_elf_section (bfd2, hdr2->sh_link,
9127 symtable2[i].u.isym->st_name);
9129 /* Sort symbol by name. */
9130 qsort (symtable1, count1, sizeof (struct elf_symbol),
9131 elf_sym_name_compare);
9132 qsort (symtable2, count1, sizeof (struct elf_symbol),
9133 elf_sym_name_compare);
9135 for (i = 0; i < count1; i++)
9136 /* Two symbols must have the same binding, type and name. */
9137 if (symtable1 [i].u.isym->st_info != symtable2 [i].u.isym->st_info
9138 || symtable1 [i].u.isym->st_other != symtable2 [i].u.isym->st_other
9139 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
9157 /* It is only used by x86-64 so far. */
9158 asection _bfd_elf_large_com_section
9159 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
9160 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
9162 /* Return TRUE if 2 section types are compatible. */
9165 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
9166 bfd *bbfd, const asection *bsec)
9170 || abfd->xvec->flavour != bfd_target_elf_flavour
9171 || bbfd->xvec->flavour != bfd_target_elf_flavour)
9174 return elf_section_type (asec) == elf_section_type (bsec);
9178 _bfd_elf_set_osabi (bfd * abfd,
9179 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9181 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
9183 i_ehdrp = elf_elfheader (abfd);
9185 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
9189 /* Return TRUE for ELF symbol types that represent functions.
9190 This is the default version of this function, which is sufficient for
9191 most targets. It returns true if TYPE is STT_FUNC. */
9194 _bfd_elf_is_function_type (unsigned int type)
9196 return (type == STT_FUNC);