1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 BFD support for ELF formats is being worked on.
29 Currently, the best supported back ends are for sparc and i386
30 (running svr4 or Solaris 2).
32 Documentation of the internals of the support code still needs
33 to be written. The code is changing quickly enough that we
34 haven't bothered yet. */
36 /* For sparc64-cross-sparc32. */
44 #include "libiberty.h"
45 #include "safe-ctype.h"
47 static int elf_sort_sections (const void *, const void *);
48 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
49 static bfd_boolean prep_headers (bfd *);
50 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
51 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
52 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
55 /* Swap version information in and out. The version information is
56 currently size independent. If that ever changes, this code will
57 need to move into elfcode.h. */
59 /* Swap in a Verdef structure. */
62 _bfd_elf_swap_verdef_in (bfd *abfd,
63 const Elf_External_Verdef *src,
64 Elf_Internal_Verdef *dst)
66 dst->vd_version = H_GET_16 (abfd, src->vd_version);
67 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
68 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
69 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
70 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
71 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
72 dst->vd_next = H_GET_32 (abfd, src->vd_next);
75 /* Swap out a Verdef structure. */
78 _bfd_elf_swap_verdef_out (bfd *abfd,
79 const Elf_Internal_Verdef *src,
80 Elf_External_Verdef *dst)
82 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
83 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
84 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
85 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
86 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
87 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
88 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
91 /* Swap in a Verdaux structure. */
94 _bfd_elf_swap_verdaux_in (bfd *abfd,
95 const Elf_External_Verdaux *src,
96 Elf_Internal_Verdaux *dst)
98 dst->vda_name = H_GET_32 (abfd, src->vda_name);
99 dst->vda_next = H_GET_32 (abfd, src->vda_next);
102 /* Swap out a Verdaux structure. */
105 _bfd_elf_swap_verdaux_out (bfd *abfd,
106 const Elf_Internal_Verdaux *src,
107 Elf_External_Verdaux *dst)
109 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
110 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
113 /* Swap in a Verneed structure. */
116 _bfd_elf_swap_verneed_in (bfd *abfd,
117 const Elf_External_Verneed *src,
118 Elf_Internal_Verneed *dst)
120 dst->vn_version = H_GET_16 (abfd, src->vn_version);
121 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
122 dst->vn_file = H_GET_32 (abfd, src->vn_file);
123 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
124 dst->vn_next = H_GET_32 (abfd, src->vn_next);
127 /* Swap out a Verneed structure. */
130 _bfd_elf_swap_verneed_out (bfd *abfd,
131 const Elf_Internal_Verneed *src,
132 Elf_External_Verneed *dst)
134 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
135 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
136 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
137 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
138 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
141 /* Swap in a Vernaux structure. */
144 _bfd_elf_swap_vernaux_in (bfd *abfd,
145 const Elf_External_Vernaux *src,
146 Elf_Internal_Vernaux *dst)
148 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
149 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
150 dst->vna_other = H_GET_16 (abfd, src->vna_other);
151 dst->vna_name = H_GET_32 (abfd, src->vna_name);
152 dst->vna_next = H_GET_32 (abfd, src->vna_next);
155 /* Swap out a Vernaux structure. */
158 _bfd_elf_swap_vernaux_out (bfd *abfd,
159 const Elf_Internal_Vernaux *src,
160 Elf_External_Vernaux *dst)
162 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
163 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
164 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
165 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
166 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
169 /* Swap in a Versym structure. */
172 _bfd_elf_swap_versym_in (bfd *abfd,
173 const Elf_External_Versym *src,
174 Elf_Internal_Versym *dst)
176 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
179 /* Swap out a Versym structure. */
182 _bfd_elf_swap_versym_out (bfd *abfd,
183 const Elf_Internal_Versym *src,
184 Elf_External_Versym *dst)
186 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
189 /* Standard ELF hash function. Do not change this function; you will
190 cause invalid hash tables to be generated. */
193 bfd_elf_hash (const char *namearg)
195 const unsigned char *name = (const unsigned char *) namearg;
200 while ((ch = *name++) != '\0')
203 if ((g = (h & 0xf0000000)) != 0)
206 /* The ELF ABI says `h &= ~g', but this is equivalent in
207 this case and on some machines one insn instead of two. */
211 return h & 0xffffffff;
214 /* DT_GNU_HASH hash function. Do not change this function; you will
215 cause invalid hash tables to be generated. */
218 bfd_elf_gnu_hash (const char *namearg)
220 const unsigned char *name = (const unsigned char *) namearg;
221 unsigned long h = 5381;
224 while ((ch = *name++) != '\0')
225 h = (h << 5) + h + ch;
226 return h & 0xffffffff;
229 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
230 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
232 bfd_elf_allocate_object (bfd *abfd,
234 enum elf_object_id object_id)
236 BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
237 abfd->tdata.any = bfd_zalloc (abfd, object_size);
238 if (abfd->tdata.any == NULL)
241 elf_object_id (abfd) = object_id;
242 elf_program_header_size (abfd) = (bfd_size_type) -1;
248 bfd_elf_make_generic_object (bfd *abfd)
250 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
255 bfd_elf_mkcorefile (bfd *abfd)
257 /* I think this can be done just like an object file. */
258 return bfd_elf_make_generic_object (abfd);
262 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
264 Elf_Internal_Shdr **i_shdrp;
265 bfd_byte *shstrtab = NULL;
267 bfd_size_type shstrtabsize;
269 i_shdrp = elf_elfsections (abfd);
271 || shindex >= elf_numsections (abfd)
272 || i_shdrp[shindex] == 0)
275 shstrtab = i_shdrp[shindex]->contents;
276 if (shstrtab == NULL)
278 /* No cached one, attempt to read, and cache what we read. */
279 offset = i_shdrp[shindex]->sh_offset;
280 shstrtabsize = i_shdrp[shindex]->sh_size;
282 /* Allocate and clear an extra byte at the end, to prevent crashes
283 in case the string table is not terminated. */
284 if (shstrtabsize + 1 <= 1
285 || (shstrtab = bfd_alloc (abfd, shstrtabsize + 1)) == NULL
286 || bfd_seek (abfd, offset, SEEK_SET) != 0)
288 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
290 if (bfd_get_error () != bfd_error_system_call)
291 bfd_set_error (bfd_error_file_truncated);
293 /* Once we've failed to read it, make sure we don't keep
294 trying. Otherwise, we'll keep allocating space for
295 the string table over and over. */
296 i_shdrp[shindex]->sh_size = 0;
299 shstrtab[shstrtabsize] = '\0';
300 i_shdrp[shindex]->contents = shstrtab;
302 return (char *) shstrtab;
306 bfd_elf_string_from_elf_section (bfd *abfd,
307 unsigned int shindex,
308 unsigned int strindex)
310 Elf_Internal_Shdr *hdr;
315 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
318 hdr = elf_elfsections (abfd)[shindex];
320 if (hdr->contents == NULL
321 && bfd_elf_get_str_section (abfd, shindex) == NULL)
324 if (strindex >= hdr->sh_size)
326 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
327 (*_bfd_error_handler)
328 (_("%B: invalid string offset %u >= %lu for section `%s'"),
329 abfd, strindex, (unsigned long) hdr->sh_size,
330 (shindex == shstrndx && strindex == hdr->sh_name
332 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
336 return ((char *) hdr->contents) + strindex;
339 /* Read and convert symbols to internal format.
340 SYMCOUNT specifies the number of symbols to read, starting from
341 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
342 are non-NULL, they are used to store the internal symbols, external
343 symbols, and symbol section index extensions, respectively.
344 Returns a pointer to the internal symbol buffer (malloced if necessary)
345 or NULL if there were no symbols or some kind of problem. */
348 bfd_elf_get_elf_syms (bfd *ibfd,
349 Elf_Internal_Shdr *symtab_hdr,
352 Elf_Internal_Sym *intsym_buf,
354 Elf_External_Sym_Shndx *extshndx_buf)
356 Elf_Internal_Shdr *shndx_hdr;
358 const bfd_byte *esym;
359 Elf_External_Sym_Shndx *alloc_extshndx;
360 Elf_External_Sym_Shndx *shndx;
361 Elf_Internal_Sym *isym;
362 Elf_Internal_Sym *isymend;
363 const struct elf_backend_data *bed;
368 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
374 /* Normal syms might have section extension entries. */
376 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
377 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
379 /* Read the symbols. */
381 alloc_extshndx = NULL;
382 bed = get_elf_backend_data (ibfd);
383 extsym_size = bed->s->sizeof_sym;
384 amt = symcount * extsym_size;
385 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
386 if (extsym_buf == NULL)
388 alloc_ext = bfd_malloc2 (symcount, extsym_size);
389 extsym_buf = alloc_ext;
391 if (extsym_buf == NULL
392 || bfd_seek (ibfd, pos, SEEK_SET) != 0
393 || bfd_bread (extsym_buf, amt, ibfd) != amt)
399 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
403 amt = symcount * sizeof (Elf_External_Sym_Shndx);
404 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
405 if (extshndx_buf == NULL)
407 alloc_extshndx = bfd_malloc2 (symcount,
408 sizeof (Elf_External_Sym_Shndx));
409 extshndx_buf = alloc_extshndx;
411 if (extshndx_buf == NULL
412 || bfd_seek (ibfd, pos, SEEK_SET) != 0
413 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
420 if (intsym_buf == NULL)
422 intsym_buf = bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
423 if (intsym_buf == NULL)
427 /* Convert the symbols to internal form. */
428 isymend = intsym_buf + symcount;
429 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
431 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
432 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
434 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
435 (*_bfd_error_handler) (_("%B symbol number %lu references "
436 "nonexistent SHT_SYMTAB_SHNDX section"),
437 ibfd, (unsigned long) symoffset);
443 if (alloc_ext != NULL)
445 if (alloc_extshndx != NULL)
446 free (alloc_extshndx);
451 /* Look up a symbol name. */
453 bfd_elf_sym_name (bfd *abfd,
454 Elf_Internal_Shdr *symtab_hdr,
455 Elf_Internal_Sym *isym,
459 unsigned int iname = isym->st_name;
460 unsigned int shindex = symtab_hdr->sh_link;
462 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
463 /* Check for a bogus st_shndx to avoid crashing. */
464 && isym->st_shndx < elf_numsections (abfd))
466 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
467 shindex = elf_elfheader (abfd)->e_shstrndx;
470 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
473 else if (sym_sec && *name == '\0')
474 name = bfd_section_name (abfd, sym_sec);
479 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
480 sections. The first element is the flags, the rest are section
483 typedef union elf_internal_group {
484 Elf_Internal_Shdr *shdr;
486 } Elf_Internal_Group;
488 /* Return the name of the group signature symbol. Why isn't the
489 signature just a string? */
492 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
494 Elf_Internal_Shdr *hdr;
495 unsigned char esym[sizeof (Elf64_External_Sym)];
496 Elf_External_Sym_Shndx eshndx;
497 Elf_Internal_Sym isym;
499 /* First we need to ensure the symbol table is available. Make sure
500 that it is a symbol table section. */
501 if (ghdr->sh_link >= elf_numsections (abfd))
503 hdr = elf_elfsections (abfd) [ghdr->sh_link];
504 if (hdr->sh_type != SHT_SYMTAB
505 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
508 /* Go read the symbol. */
509 hdr = &elf_tdata (abfd)->symtab_hdr;
510 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
511 &isym, esym, &eshndx) == NULL)
514 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
517 /* Set next_in_group list pointer, and group name for NEWSECT. */
520 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
522 unsigned int num_group = elf_tdata (abfd)->num_group;
524 /* If num_group is zero, read in all SHT_GROUP sections. The count
525 is set to -1 if there are no SHT_GROUP sections. */
528 unsigned int i, shnum;
530 /* First count the number of groups. If we have a SHT_GROUP
531 section with just a flag word (ie. sh_size is 4), ignore it. */
532 shnum = elf_numsections (abfd);
535 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
536 ( (shdr)->sh_type == SHT_GROUP \
537 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
538 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
539 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
541 for (i = 0; i < shnum; i++)
543 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
545 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
551 num_group = (unsigned) -1;
552 elf_tdata (abfd)->num_group = num_group;
556 /* We keep a list of elf section headers for group sections,
557 so we can find them quickly. */
560 elf_tdata (abfd)->num_group = num_group;
561 elf_tdata (abfd)->group_sect_ptr
562 = bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
563 if (elf_tdata (abfd)->group_sect_ptr == NULL)
567 for (i = 0; i < shnum; i++)
569 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
571 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
574 Elf_Internal_Group *dest;
576 /* Add to list of sections. */
577 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
580 /* Read the raw contents. */
581 BFD_ASSERT (sizeof (*dest) >= 4);
582 amt = shdr->sh_size * sizeof (*dest) / 4;
583 shdr->contents = bfd_alloc2 (abfd, shdr->sh_size,
585 /* PR binutils/4110: Handle corrupt group headers. */
586 if (shdr->contents == NULL)
589 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
590 bfd_set_error (bfd_error_bad_value);
594 memset (shdr->contents, 0, amt);
596 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
597 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
601 /* Translate raw contents, a flag word followed by an
602 array of elf section indices all in target byte order,
603 to the flag word followed by an array of elf section
605 src = shdr->contents + shdr->sh_size;
606 dest = (Elf_Internal_Group *) (shdr->contents + amt);
613 idx = H_GET_32 (abfd, src);
614 if (src == shdr->contents)
617 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
618 shdr->bfd_section->flags
619 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
624 ((*_bfd_error_handler)
625 (_("%B: invalid SHT_GROUP entry"), abfd));
628 dest->shdr = elf_elfsections (abfd)[idx];
635 if (num_group != (unsigned) -1)
639 for (i = 0; i < num_group; i++)
641 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
642 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
643 unsigned int n_elt = shdr->sh_size / 4;
645 /* Look through this group's sections to see if current
646 section is a member. */
648 if ((++idx)->shdr == hdr)
652 /* We are a member of this group. Go looking through
653 other members to see if any others are linked via
655 idx = (Elf_Internal_Group *) shdr->contents;
656 n_elt = shdr->sh_size / 4;
658 if ((s = (++idx)->shdr->bfd_section) != NULL
659 && elf_next_in_group (s) != NULL)
663 /* Snarf the group name from other member, and
664 insert current section in circular list. */
665 elf_group_name (newsect) = elf_group_name (s);
666 elf_next_in_group (newsect) = elf_next_in_group (s);
667 elf_next_in_group (s) = newsect;
673 gname = group_signature (abfd, shdr);
676 elf_group_name (newsect) = gname;
678 /* Start a circular list with one element. */
679 elf_next_in_group (newsect) = newsect;
682 /* If the group section has been created, point to the
684 if (shdr->bfd_section != NULL)
685 elf_next_in_group (shdr->bfd_section) = newsect;
693 if (elf_group_name (newsect) == NULL)
695 (*_bfd_error_handler) (_("%B: no group info for section %A"),
702 _bfd_elf_setup_sections (bfd *abfd)
705 unsigned int num_group = elf_tdata (abfd)->num_group;
706 bfd_boolean result = TRUE;
709 /* Process SHF_LINK_ORDER. */
710 for (s = abfd->sections; s != NULL; s = s->next)
712 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
713 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
715 unsigned int elfsec = this_hdr->sh_link;
716 /* FIXME: The old Intel compiler and old strip/objcopy may
717 not set the sh_link or sh_info fields. Hence we could
718 get the situation where elfsec is 0. */
721 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
722 if (bed->link_order_error_handler)
723 bed->link_order_error_handler
724 (_("%B: warning: sh_link not set for section `%A'"),
729 asection *link = NULL;
731 if (elfsec < elf_numsections (abfd))
733 this_hdr = elf_elfsections (abfd)[elfsec];
734 link = this_hdr->bfd_section;
738 Some strip/objcopy may leave an incorrect value in
739 sh_link. We don't want to proceed. */
742 (*_bfd_error_handler)
743 (_("%B: sh_link [%d] in section `%A' is incorrect"),
744 s->owner, s, elfsec);
748 elf_linked_to_section (s) = link;
753 /* Process section groups. */
754 if (num_group == (unsigned) -1)
757 for (i = 0; i < num_group; i++)
759 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
760 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
761 unsigned int n_elt = shdr->sh_size / 4;
764 if ((++idx)->shdr->bfd_section)
765 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
766 else if (idx->shdr->sh_type == SHT_RELA
767 || idx->shdr->sh_type == SHT_REL)
768 /* We won't include relocation sections in section groups in
769 output object files. We adjust the group section size here
770 so that relocatable link will work correctly when
771 relocation sections are in section group in input object
773 shdr->bfd_section->size -= 4;
776 /* There are some unknown sections in the group. */
777 (*_bfd_error_handler)
778 (_("%B: unknown [%d] section `%s' in group [%s]"),
780 (unsigned int) idx->shdr->sh_type,
781 bfd_elf_string_from_elf_section (abfd,
782 (elf_elfheader (abfd)
785 shdr->bfd_section->name);
793 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
795 return elf_next_in_group (sec) != NULL;
798 /* Make a BFD section from an ELF section. We store a pointer to the
799 BFD section in the bfd_section field of the header. */
802 _bfd_elf_make_section_from_shdr (bfd *abfd,
803 Elf_Internal_Shdr *hdr,
809 const struct elf_backend_data *bed;
811 if (hdr->bfd_section != NULL)
813 BFD_ASSERT (strcmp (name,
814 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
818 newsect = bfd_make_section_anyway (abfd, name);
822 hdr->bfd_section = newsect;
823 elf_section_data (newsect)->this_hdr = *hdr;
824 elf_section_data (newsect)->this_idx = shindex;
826 /* Always use the real type/flags. */
827 elf_section_type (newsect) = hdr->sh_type;
828 elf_section_flags (newsect) = hdr->sh_flags;
830 newsect->filepos = hdr->sh_offset;
832 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
833 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
834 || ! bfd_set_section_alignment (abfd, newsect,
835 bfd_log2 (hdr->sh_addralign)))
838 flags = SEC_NO_FLAGS;
839 if (hdr->sh_type != SHT_NOBITS)
840 flags |= SEC_HAS_CONTENTS;
841 if (hdr->sh_type == SHT_GROUP)
842 flags |= SEC_GROUP | SEC_EXCLUDE;
843 if ((hdr->sh_flags & SHF_ALLOC) != 0)
846 if (hdr->sh_type != SHT_NOBITS)
849 if ((hdr->sh_flags & SHF_WRITE) == 0)
850 flags |= SEC_READONLY;
851 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
853 else if ((flags & SEC_LOAD) != 0)
855 if ((hdr->sh_flags & SHF_MERGE) != 0)
858 newsect->entsize = hdr->sh_entsize;
859 if ((hdr->sh_flags & SHF_STRINGS) != 0)
860 flags |= SEC_STRINGS;
862 if (hdr->sh_flags & SHF_GROUP)
863 if (!setup_group (abfd, hdr, newsect))
865 if ((hdr->sh_flags & SHF_TLS) != 0)
866 flags |= SEC_THREAD_LOCAL;
868 if ((flags & SEC_ALLOC) == 0)
870 /* The debugging sections appear to be recognized only by name,
871 not any sort of flag. Their SEC_ALLOC bits are cleared. */
876 } debug_sections [] =
878 { STRING_COMMA_LEN ("debug") }, /* 'd' */
879 { NULL, 0 }, /* 'e' */
880 { NULL, 0 }, /* 'f' */
881 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
882 { NULL, 0 }, /* 'h' */
883 { NULL, 0 }, /* 'i' */
884 { NULL, 0 }, /* 'j' */
885 { NULL, 0 }, /* 'k' */
886 { STRING_COMMA_LEN ("line") }, /* 'l' */
887 { NULL, 0 }, /* 'm' */
888 { NULL, 0 }, /* 'n' */
889 { NULL, 0 }, /* 'o' */
890 { NULL, 0 }, /* 'p' */
891 { NULL, 0 }, /* 'q' */
892 { NULL, 0 }, /* 'r' */
893 { STRING_COMMA_LEN ("stab") } /* 's' */
898 int i = name [1] - 'd';
900 && i < (int) ARRAY_SIZE (debug_sections)
901 && debug_sections [i].name != NULL
902 && strncmp (&name [1], debug_sections [i].name,
903 debug_sections [i].len) == 0)
904 flags |= SEC_DEBUGGING;
908 /* As a GNU extension, if the name begins with .gnu.linkonce, we
909 only link a single copy of the section. This is used to support
910 g++. g++ will emit each template expansion in its own section.
911 The symbols will be defined as weak, so that multiple definitions
912 are permitted. The GNU linker extension is to actually discard
913 all but one of the sections. */
914 if (CONST_STRNEQ (name, ".gnu.linkonce")
915 && elf_next_in_group (newsect) == NULL)
916 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
918 bed = get_elf_backend_data (abfd);
919 if (bed->elf_backend_section_flags)
920 if (! bed->elf_backend_section_flags (&flags, hdr))
923 if (! bfd_set_section_flags (abfd, newsect, flags))
926 /* We do not parse the PT_NOTE segments as we are interested even in the
927 separate debug info files which may have the segments offsets corrupted.
928 PT_NOTEs from the core files are currently not parsed using BFD. */
929 if (hdr->sh_type == SHT_NOTE)
933 contents = bfd_malloc (hdr->sh_size);
937 if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
939 || !elf_parse_notes (abfd, contents, hdr->sh_size, -1))
948 if ((flags & SEC_ALLOC) != 0)
950 Elf_Internal_Phdr *phdr;
953 phdr = elf_tdata (abfd)->phdr;
954 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
956 /* This section is part of this segment if its file
957 offset plus size lies within the segment's memory
958 span and, if the section is loaded, the extent of the
959 loaded data lies within the extent of the segment.
961 Note - we used to check the p_paddr field as well, and
962 refuse to set the LMA if it was 0. This is wrong
963 though, as a perfectly valid initialised segment can
964 have a p_paddr of zero. Some architectures, eg ARM,
965 place special significance on the address 0 and
966 executables need to be able to have a segment which
967 covers this address. */
968 if (phdr->p_type == PT_LOAD
969 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
970 && (hdr->sh_offset + hdr->sh_size
971 <= phdr->p_offset + phdr->p_memsz)
972 && ((flags & SEC_LOAD) == 0
973 || (hdr->sh_offset + hdr->sh_size
974 <= phdr->p_offset + phdr->p_filesz)))
976 if ((flags & SEC_LOAD) == 0)
977 newsect->lma = (phdr->p_paddr
978 + hdr->sh_addr - phdr->p_vaddr);
980 /* We used to use the same adjustment for SEC_LOAD
981 sections, but that doesn't work if the segment
982 is packed with code from multiple VMAs.
983 Instead we calculate the section LMA based on
984 the segment LMA. It is assumed that the
985 segment will contain sections with contiguous
986 LMAs, even if the VMAs are not. */
987 newsect->lma = (phdr->p_paddr
988 + hdr->sh_offset - phdr->p_offset);
990 /* With contiguous segments, we can't tell from file
991 offsets whether a section with zero size should
992 be placed at the end of one segment or the
993 beginning of the next. Decide based on vaddr. */
994 if (hdr->sh_addr >= phdr->p_vaddr
995 && (hdr->sh_addr + hdr->sh_size
996 <= phdr->p_vaddr + phdr->p_memsz))
1007 bfd_elf_find_section
1010 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
1013 Helper functions for GDB to locate the string tables.
1014 Since BFD hides string tables from callers, GDB needs to use an
1015 internal hook to find them. Sun's .stabstr, in particular,
1016 isn't even pointed to by the .stab section, so ordinary
1017 mechanisms wouldn't work to find it, even if we had some.
1020 struct elf_internal_shdr *
1021 bfd_elf_find_section (bfd *abfd, char *name)
1023 Elf_Internal_Shdr **i_shdrp;
1028 i_shdrp = elf_elfsections (abfd);
1029 if (i_shdrp != NULL)
1031 shstrtab = bfd_elf_get_str_section (abfd,
1032 elf_elfheader (abfd)->e_shstrndx);
1033 if (shstrtab != NULL)
1035 max = elf_numsections (abfd);
1036 for (i = 1; i < max; i++)
1037 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
1044 const char *const bfd_elf_section_type_names[] = {
1045 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1046 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1047 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1050 /* ELF relocs are against symbols. If we are producing relocatable
1051 output, and the reloc is against an external symbol, and nothing
1052 has given us any additional addend, the resulting reloc will also
1053 be against the same symbol. In such a case, we don't want to
1054 change anything about the way the reloc is handled, since it will
1055 all be done at final link time. Rather than put special case code
1056 into bfd_perform_relocation, all the reloc types use this howto
1057 function. It just short circuits the reloc if producing
1058 relocatable output against an external symbol. */
1060 bfd_reloc_status_type
1061 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1062 arelent *reloc_entry,
1064 void *data ATTRIBUTE_UNUSED,
1065 asection *input_section,
1067 char **error_message ATTRIBUTE_UNUSED)
1069 if (output_bfd != NULL
1070 && (symbol->flags & BSF_SECTION_SYM) == 0
1071 && (! reloc_entry->howto->partial_inplace
1072 || reloc_entry->addend == 0))
1074 reloc_entry->address += input_section->output_offset;
1075 return bfd_reloc_ok;
1078 return bfd_reloc_continue;
1081 /* Copy the program header and other data from one object module to
1085 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1087 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1088 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1091 BFD_ASSERT (!elf_flags_init (obfd)
1092 || (elf_elfheader (obfd)->e_flags
1093 == elf_elfheader (ibfd)->e_flags));
1095 elf_gp (obfd) = elf_gp (ibfd);
1096 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1097 elf_flags_init (obfd) = TRUE;
1099 /* Copy object attributes. */
1100 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1106 get_segment_type (unsigned int p_type)
1111 case PT_NULL: pt = "NULL"; break;
1112 case PT_LOAD: pt = "LOAD"; break;
1113 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1114 case PT_INTERP: pt = "INTERP"; break;
1115 case PT_NOTE: pt = "NOTE"; break;
1116 case PT_SHLIB: pt = "SHLIB"; break;
1117 case PT_PHDR: pt = "PHDR"; break;
1118 case PT_TLS: pt = "TLS"; break;
1119 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1120 case PT_GNU_STACK: pt = "STACK"; break;
1121 case PT_GNU_RELRO: pt = "RELRO"; break;
1122 default: pt = NULL; break;
1127 /* Print out the program headers. */
1130 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1133 Elf_Internal_Phdr *p;
1135 bfd_byte *dynbuf = NULL;
1137 p = elf_tdata (abfd)->phdr;
1142 fprintf (f, _("\nProgram Header:\n"));
1143 c = elf_elfheader (abfd)->e_phnum;
1144 for (i = 0; i < c; i++, p++)
1146 const char *pt = get_segment_type (p->p_type);
1151 sprintf (buf, "0x%lx", p->p_type);
1154 fprintf (f, "%8s off 0x", pt);
1155 bfd_fprintf_vma (abfd, f, p->p_offset);
1156 fprintf (f, " vaddr 0x");
1157 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1158 fprintf (f, " paddr 0x");
1159 bfd_fprintf_vma (abfd, f, p->p_paddr);
1160 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1161 fprintf (f, " filesz 0x");
1162 bfd_fprintf_vma (abfd, f, p->p_filesz);
1163 fprintf (f, " memsz 0x");
1164 bfd_fprintf_vma (abfd, f, p->p_memsz);
1165 fprintf (f, " flags %c%c%c",
1166 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1167 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1168 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1169 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1170 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1175 s = bfd_get_section_by_name (abfd, ".dynamic");
1178 unsigned int elfsec;
1179 unsigned long shlink;
1180 bfd_byte *extdyn, *extdynend;
1182 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1184 fprintf (f, _("\nDynamic Section:\n"));
1186 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1189 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1190 if (elfsec == SHN_BAD)
1192 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1194 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1195 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1198 extdynend = extdyn + s->size;
1199 for (; extdyn < extdynend; extdyn += extdynsize)
1201 Elf_Internal_Dyn dyn;
1202 const char *name = "";
1204 bfd_boolean stringp;
1205 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1207 (*swap_dyn_in) (abfd, extdyn, &dyn);
1209 if (dyn.d_tag == DT_NULL)
1216 if (bed->elf_backend_get_target_dtag)
1217 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1219 if (!strcmp (name, ""))
1221 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1226 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1227 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1228 case DT_PLTGOT: name = "PLTGOT"; break;
1229 case DT_HASH: name = "HASH"; break;
1230 case DT_STRTAB: name = "STRTAB"; break;
1231 case DT_SYMTAB: name = "SYMTAB"; break;
1232 case DT_RELA: name = "RELA"; break;
1233 case DT_RELASZ: name = "RELASZ"; break;
1234 case DT_RELAENT: name = "RELAENT"; break;
1235 case DT_STRSZ: name = "STRSZ"; break;
1236 case DT_SYMENT: name = "SYMENT"; break;
1237 case DT_INIT: name = "INIT"; break;
1238 case DT_FINI: name = "FINI"; break;
1239 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1240 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1241 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1242 case DT_REL: name = "REL"; break;
1243 case DT_RELSZ: name = "RELSZ"; break;
1244 case DT_RELENT: name = "RELENT"; break;
1245 case DT_PLTREL: name = "PLTREL"; break;
1246 case DT_DEBUG: name = "DEBUG"; break;
1247 case DT_TEXTREL: name = "TEXTREL"; break;
1248 case DT_JMPREL: name = "JMPREL"; break;
1249 case DT_BIND_NOW: name = "BIND_NOW"; break;
1250 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1251 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1252 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1253 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1254 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1255 case DT_FLAGS: name = "FLAGS"; break;
1256 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1257 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1258 case DT_CHECKSUM: name = "CHECKSUM"; break;
1259 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1260 case DT_MOVEENT: name = "MOVEENT"; break;
1261 case DT_MOVESZ: name = "MOVESZ"; break;
1262 case DT_FEATURE: name = "FEATURE"; break;
1263 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1264 case DT_SYMINSZ: name = "SYMINSZ"; break;
1265 case DT_SYMINENT: name = "SYMINENT"; break;
1266 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1267 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1268 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1269 case DT_PLTPAD: name = "PLTPAD"; break;
1270 case DT_MOVETAB: name = "MOVETAB"; break;
1271 case DT_SYMINFO: name = "SYMINFO"; break;
1272 case DT_RELACOUNT: name = "RELACOUNT"; break;
1273 case DT_RELCOUNT: name = "RELCOUNT"; break;
1274 case DT_FLAGS_1: name = "FLAGS_1"; break;
1275 case DT_VERSYM: name = "VERSYM"; break;
1276 case DT_VERDEF: name = "VERDEF"; break;
1277 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1278 case DT_VERNEED: name = "VERNEED"; break;
1279 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1280 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1281 case DT_USED: name = "USED"; break;
1282 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1283 case DT_GNU_HASH: name = "GNU_HASH"; break;
1286 fprintf (f, " %-20s ", name);
1290 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1295 unsigned int tagv = dyn.d_un.d_val;
1297 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1300 fprintf (f, "%s", string);
1309 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1310 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1312 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1316 if (elf_dynverdef (abfd) != 0)
1318 Elf_Internal_Verdef *t;
1320 fprintf (f, _("\nVersion definitions:\n"));
1321 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1323 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1324 t->vd_flags, t->vd_hash,
1325 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1326 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1328 Elf_Internal_Verdaux *a;
1331 for (a = t->vd_auxptr->vda_nextptr;
1335 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1341 if (elf_dynverref (abfd) != 0)
1343 Elf_Internal_Verneed *t;
1345 fprintf (f, _("\nVersion References:\n"));
1346 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1348 Elf_Internal_Vernaux *a;
1350 fprintf (f, _(" required from %s:\n"),
1351 t->vn_filename ? t->vn_filename : "<corrupt>");
1352 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1353 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1354 a->vna_flags, a->vna_other,
1355 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1367 /* Display ELF-specific fields of a symbol. */
1370 bfd_elf_print_symbol (bfd *abfd,
1373 bfd_print_symbol_type how)
1378 case bfd_print_symbol_name:
1379 fprintf (file, "%s", symbol->name);
1381 case bfd_print_symbol_more:
1382 fprintf (file, "elf ");
1383 bfd_fprintf_vma (abfd, file, symbol->value);
1384 fprintf (file, " %lx", (long) symbol->flags);
1386 case bfd_print_symbol_all:
1388 const char *section_name;
1389 const char *name = NULL;
1390 const struct elf_backend_data *bed;
1391 unsigned char st_other;
1394 section_name = symbol->section ? symbol->section->name : "(*none*)";
1396 bed = get_elf_backend_data (abfd);
1397 if (bed->elf_backend_print_symbol_all)
1398 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1402 name = symbol->name;
1403 bfd_print_symbol_vandf (abfd, file, symbol);
1406 fprintf (file, " %s\t", section_name);
1407 /* Print the "other" value for a symbol. For common symbols,
1408 we've already printed the size; now print the alignment.
1409 For other symbols, we have no specified alignment, and
1410 we've printed the address; now print the size. */
1411 if (symbol->section && bfd_is_com_section (symbol->section))
1412 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1414 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1415 bfd_fprintf_vma (abfd, file, val);
1417 /* If we have version information, print it. */
1418 if (elf_tdata (abfd)->dynversym_section != 0
1419 && (elf_tdata (abfd)->dynverdef_section != 0
1420 || elf_tdata (abfd)->dynverref_section != 0))
1422 unsigned int vernum;
1423 const char *version_string;
1425 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1428 version_string = "";
1429 else if (vernum == 1)
1430 version_string = "Base";
1431 else if (vernum <= elf_tdata (abfd)->cverdefs)
1433 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1436 Elf_Internal_Verneed *t;
1438 version_string = "";
1439 for (t = elf_tdata (abfd)->verref;
1443 Elf_Internal_Vernaux *a;
1445 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1447 if (a->vna_other == vernum)
1449 version_string = a->vna_nodename;
1456 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1457 fprintf (file, " %-11s", version_string);
1462 fprintf (file, " (%s)", version_string);
1463 for (i = 10 - strlen (version_string); i > 0; --i)
1468 /* If the st_other field is not zero, print it. */
1469 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1474 case STV_INTERNAL: fprintf (file, " .internal"); break;
1475 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1476 case STV_PROTECTED: fprintf (file, " .protected"); break;
1478 /* Some other non-defined flags are also present, so print
1480 fprintf (file, " 0x%02x", (unsigned int) st_other);
1483 fprintf (file, " %s", name);
1489 /* Allocate an ELF string table--force the first byte to be zero. */
1491 struct bfd_strtab_hash *
1492 _bfd_elf_stringtab_init (void)
1494 struct bfd_strtab_hash *ret;
1496 ret = _bfd_stringtab_init ();
1501 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1502 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1503 if (loc == (bfd_size_type) -1)
1505 _bfd_stringtab_free (ret);
1512 /* ELF .o/exec file reading */
1514 /* Create a new bfd section from an ELF section header. */
1517 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1519 Elf_Internal_Shdr *hdr;
1520 Elf_Internal_Ehdr *ehdr;
1521 const struct elf_backend_data *bed;
1524 if (shindex >= elf_numsections (abfd))
1527 hdr = elf_elfsections (abfd)[shindex];
1528 ehdr = elf_elfheader (abfd);
1529 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1534 bed = get_elf_backend_data (abfd);
1535 switch (hdr->sh_type)
1538 /* Inactive section. Throw it away. */
1541 case SHT_PROGBITS: /* Normal section with contents. */
1542 case SHT_NOBITS: /* .bss section. */
1543 case SHT_HASH: /* .hash section. */
1544 case SHT_NOTE: /* .note section. */
1545 case SHT_INIT_ARRAY: /* .init_array section. */
1546 case SHT_FINI_ARRAY: /* .fini_array section. */
1547 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1548 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1549 case SHT_GNU_HASH: /* .gnu.hash section. */
1550 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1552 case SHT_DYNAMIC: /* Dynamic linking information. */
1553 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1555 if (hdr->sh_link > elf_numsections (abfd)
1556 || elf_elfsections (abfd)[hdr->sh_link] == NULL)
1558 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1560 Elf_Internal_Shdr *dynsymhdr;
1562 /* The shared libraries distributed with hpux11 have a bogus
1563 sh_link field for the ".dynamic" section. Find the
1564 string table for the ".dynsym" section instead. */
1565 if (elf_dynsymtab (abfd) != 0)
1567 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1568 hdr->sh_link = dynsymhdr->sh_link;
1572 unsigned int i, num_sec;
1574 num_sec = elf_numsections (abfd);
1575 for (i = 1; i < num_sec; i++)
1577 dynsymhdr = elf_elfsections (abfd)[i];
1578 if (dynsymhdr->sh_type == SHT_DYNSYM)
1580 hdr->sh_link = dynsymhdr->sh_link;
1588 case SHT_SYMTAB: /* A symbol table */
1589 if (elf_onesymtab (abfd) == shindex)
1592 if (hdr->sh_entsize != bed->s->sizeof_sym)
1594 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1595 elf_onesymtab (abfd) = shindex;
1596 elf_tdata (abfd)->symtab_hdr = *hdr;
1597 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1598 abfd->flags |= HAS_SYMS;
1600 /* Sometimes a shared object will map in the symbol table. If
1601 SHF_ALLOC is set, and this is a shared object, then we also
1602 treat this section as a BFD section. We can not base the
1603 decision purely on SHF_ALLOC, because that flag is sometimes
1604 set in a relocatable object file, which would confuse the
1606 if ((hdr->sh_flags & SHF_ALLOC) != 0
1607 && (abfd->flags & DYNAMIC) != 0
1608 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1612 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1613 can't read symbols without that section loaded as well. It
1614 is most likely specified by the next section header. */
1615 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1617 unsigned int i, num_sec;
1619 num_sec = elf_numsections (abfd);
1620 for (i = shindex + 1; i < num_sec; i++)
1622 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1623 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1624 && hdr2->sh_link == shindex)
1628 for (i = 1; i < shindex; i++)
1630 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1631 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1632 && hdr2->sh_link == shindex)
1636 return bfd_section_from_shdr (abfd, i);
1640 case SHT_DYNSYM: /* A dynamic symbol table */
1641 if (elf_dynsymtab (abfd) == shindex)
1644 if (hdr->sh_entsize != bed->s->sizeof_sym)
1646 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1647 elf_dynsymtab (abfd) = shindex;
1648 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1649 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1650 abfd->flags |= HAS_SYMS;
1652 /* Besides being a symbol table, we also treat this as a regular
1653 section, so that objcopy can handle it. */
1654 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1656 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1657 if (elf_symtab_shndx (abfd) == shindex)
1660 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1661 elf_symtab_shndx (abfd) = shindex;
1662 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1663 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1666 case SHT_STRTAB: /* A string table */
1667 if (hdr->bfd_section != NULL)
1669 if (ehdr->e_shstrndx == shindex)
1671 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1672 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1675 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1678 elf_tdata (abfd)->strtab_hdr = *hdr;
1679 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1682 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1685 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1686 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1687 elf_elfsections (abfd)[shindex] = hdr;
1688 /* We also treat this as a regular section, so that objcopy
1690 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1694 /* If the string table isn't one of the above, then treat it as a
1695 regular section. We need to scan all the headers to be sure,
1696 just in case this strtab section appeared before the above. */
1697 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1699 unsigned int i, num_sec;
1701 num_sec = elf_numsections (abfd);
1702 for (i = 1; i < num_sec; i++)
1704 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1705 if (hdr2->sh_link == shindex)
1707 /* Prevent endless recursion on broken objects. */
1710 if (! bfd_section_from_shdr (abfd, i))
1712 if (elf_onesymtab (abfd) == i)
1714 if (elf_dynsymtab (abfd) == i)
1715 goto dynsymtab_strtab;
1719 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1723 /* *These* do a lot of work -- but build no sections! */
1725 asection *target_sect;
1726 Elf_Internal_Shdr *hdr2;
1727 unsigned int num_sec = elf_numsections (abfd);
1730 != (bfd_size_type) (hdr->sh_type == SHT_REL
1731 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1734 /* Check for a bogus link to avoid crashing. */
1735 if (hdr->sh_link >= num_sec)
1737 ((*_bfd_error_handler)
1738 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1739 abfd, hdr->sh_link, name, shindex));
1740 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1744 /* For some incomprehensible reason Oracle distributes
1745 libraries for Solaris in which some of the objects have
1746 bogus sh_link fields. It would be nice if we could just
1747 reject them, but, unfortunately, some people need to use
1748 them. We scan through the section headers; if we find only
1749 one suitable symbol table, we clobber the sh_link to point
1750 to it. I hope this doesn't break anything. */
1751 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1752 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1758 for (scan = 1; scan < num_sec; scan++)
1760 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1761 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1772 hdr->sh_link = found;
1775 /* Get the symbol table. */
1776 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1777 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1778 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1781 /* If this reloc section does not use the main symbol table we
1782 don't treat it as a reloc section. BFD can't adequately
1783 represent such a section, so at least for now, we don't
1784 try. We just present it as a normal section. We also
1785 can't use it as a reloc section if it points to the null
1786 section, an invalid section, or another reloc section. */
1787 if (hdr->sh_link != elf_onesymtab (abfd)
1788 || hdr->sh_info == SHN_UNDEF
1789 || hdr->sh_info >= num_sec
1790 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1791 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
1792 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1795 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1797 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1798 if (target_sect == NULL)
1801 if ((target_sect->flags & SEC_RELOC) == 0
1802 || target_sect->reloc_count == 0)
1803 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1807 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1808 amt = sizeof (*hdr2);
1809 hdr2 = bfd_alloc (abfd, amt);
1812 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1815 elf_elfsections (abfd)[shindex] = hdr2;
1816 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1817 target_sect->flags |= SEC_RELOC;
1818 target_sect->relocation = NULL;
1819 target_sect->rel_filepos = hdr->sh_offset;
1820 /* In the section to which the relocations apply, mark whether
1821 its relocations are of the REL or RELA variety. */
1822 if (hdr->sh_size != 0)
1823 target_sect->use_rela_p = hdr->sh_type == SHT_RELA;
1824 abfd->flags |= HAS_RELOC;
1828 case SHT_GNU_verdef:
1829 elf_dynverdef (abfd) = shindex;
1830 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1831 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1833 case SHT_GNU_versym:
1834 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1836 elf_dynversym (abfd) = shindex;
1837 elf_tdata (abfd)->dynversym_hdr = *hdr;
1838 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1840 case SHT_GNU_verneed:
1841 elf_dynverref (abfd) = shindex;
1842 elf_tdata (abfd)->dynverref_hdr = *hdr;
1843 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1849 /* We need a BFD section for objcopy and relocatable linking,
1850 and it's handy to have the signature available as the section
1852 if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
1854 name = group_signature (abfd, hdr);
1857 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1859 if (hdr->contents != NULL)
1861 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1862 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
1865 if (idx->flags & GRP_COMDAT)
1866 hdr->bfd_section->flags
1867 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1869 /* We try to keep the same section order as it comes in. */
1871 while (--n_elt != 0)
1875 if (idx->shdr != NULL
1876 && (s = idx->shdr->bfd_section) != NULL
1877 && elf_next_in_group (s) != NULL)
1879 elf_next_in_group (hdr->bfd_section) = s;
1887 /* Possibly an attributes section. */
1888 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1889 || hdr->sh_type == bed->obj_attrs_section_type)
1891 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1893 _bfd_elf_parse_attributes (abfd, hdr);
1897 /* Check for any processor-specific section types. */
1898 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1901 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1903 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1904 /* FIXME: How to properly handle allocated section reserved
1905 for applications? */
1906 (*_bfd_error_handler)
1907 (_("%B: don't know how to handle allocated, application "
1908 "specific section `%s' [0x%8x]"),
1909 abfd, name, hdr->sh_type);
1911 /* Allow sections reserved for applications. */
1912 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1915 else if (hdr->sh_type >= SHT_LOPROC
1916 && hdr->sh_type <= SHT_HIPROC)
1917 /* FIXME: We should handle this section. */
1918 (*_bfd_error_handler)
1919 (_("%B: don't know how to handle processor specific section "
1921 abfd, name, hdr->sh_type);
1922 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
1924 /* Unrecognised OS-specific sections. */
1925 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1926 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1927 required to correctly process the section and the file should
1928 be rejected with an error message. */
1929 (*_bfd_error_handler)
1930 (_("%B: don't know how to handle OS specific section "
1932 abfd, name, hdr->sh_type);
1934 /* Otherwise it should be processed. */
1935 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1938 /* FIXME: We should handle this section. */
1939 (*_bfd_error_handler)
1940 (_("%B: don't know how to handle section `%s' [0x%8x]"),
1941 abfd, name, hdr->sh_type);
1949 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1950 Return SEC for sections that have no elf section, and NULL on error. */
1953 bfd_section_from_r_symndx (bfd *abfd,
1954 struct sym_sec_cache *cache,
1956 unsigned long r_symndx)
1958 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
1961 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
1963 Elf_Internal_Shdr *symtab_hdr;
1964 unsigned char esym[sizeof (Elf64_External_Sym)];
1965 Elf_External_Sym_Shndx eshndx;
1966 Elf_Internal_Sym isym;
1968 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1969 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
1970 &isym, esym, &eshndx) == NULL)
1973 if (cache->abfd != abfd)
1975 memset (cache->indx, -1, sizeof (cache->indx));
1978 cache->indx[ent] = r_symndx;
1979 cache->shndx[ent] = isym.st_shndx;
1982 s = bfd_section_from_elf_index (abfd, cache->shndx[ent]);
1989 /* Given an ELF section number, retrieve the corresponding BFD
1993 bfd_section_from_elf_index (bfd *abfd, unsigned int index)
1995 if (index >= elf_numsections (abfd))
1997 return elf_elfsections (abfd)[index]->bfd_section;
2000 static const struct bfd_elf_special_section special_sections_b[] =
2002 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2003 { NULL, 0, 0, 0, 0 }
2006 static const struct bfd_elf_special_section special_sections_c[] =
2008 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2009 { NULL, 0, 0, 0, 0 }
2012 static const struct bfd_elf_special_section special_sections_d[] =
2014 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2015 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2016 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2017 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2018 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2019 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2020 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2021 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2022 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2023 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2024 { NULL, 0, 0, 0, 0 }
2027 static const struct bfd_elf_special_section special_sections_f[] =
2029 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2030 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2031 { NULL, 0, 0, 0, 0 }
2034 static const struct bfd_elf_special_section special_sections_g[] =
2036 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2037 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2038 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2039 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2040 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2041 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2042 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2043 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2044 { NULL, 0, 0, 0, 0 }
2047 static const struct bfd_elf_special_section special_sections_h[] =
2049 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2050 { NULL, 0, 0, 0, 0 }
2053 static const struct bfd_elf_special_section special_sections_i[] =
2055 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2056 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2057 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2058 { NULL, 0, 0, 0, 0 }
2061 static const struct bfd_elf_special_section special_sections_l[] =
2063 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2064 { NULL, 0, 0, 0, 0 }
2067 static const struct bfd_elf_special_section special_sections_n[] =
2069 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2070 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2071 { NULL, 0, 0, 0, 0 }
2074 static const struct bfd_elf_special_section special_sections_p[] =
2076 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2077 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2078 { NULL, 0, 0, 0, 0 }
2081 static const struct bfd_elf_special_section special_sections_r[] =
2083 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2084 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2085 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2086 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2087 { NULL, 0, 0, 0, 0 }
2090 static const struct bfd_elf_special_section special_sections_s[] =
2092 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2093 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2094 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2095 /* See struct bfd_elf_special_section declaration for the semantics of
2096 this special case where .prefix_length != strlen (.prefix). */
2097 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2098 { NULL, 0, 0, 0, 0 }
2101 static const struct bfd_elf_special_section special_sections_t[] =
2103 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2104 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2105 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2106 { NULL, 0, 0, 0, 0 }
2109 static const struct bfd_elf_special_section *special_sections[] =
2111 special_sections_b, /* 'b' */
2112 special_sections_c, /* 'c' */
2113 special_sections_d, /* 'd' */
2115 special_sections_f, /* 'f' */
2116 special_sections_g, /* 'g' */
2117 special_sections_h, /* 'h' */
2118 special_sections_i, /* 'i' */
2121 special_sections_l, /* 'l' */
2123 special_sections_n, /* 'n' */
2125 special_sections_p, /* 'p' */
2127 special_sections_r, /* 'r' */
2128 special_sections_s, /* 's' */
2129 special_sections_t, /* 't' */
2132 const struct bfd_elf_special_section *
2133 _bfd_elf_get_special_section (const char *name,
2134 const struct bfd_elf_special_section *spec,
2140 len = strlen (name);
2142 for (i = 0; spec[i].prefix != NULL; i++)
2145 int prefix_len = spec[i].prefix_length;
2147 if (len < prefix_len)
2149 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2152 suffix_len = spec[i].suffix_length;
2153 if (suffix_len <= 0)
2155 if (name[prefix_len] != 0)
2157 if (suffix_len == 0)
2159 if (name[prefix_len] != '.'
2160 && (suffix_len == -2
2161 || (rela && spec[i].type == SHT_REL)))
2167 if (len < prefix_len + suffix_len)
2169 if (memcmp (name + len - suffix_len,
2170 spec[i].prefix + prefix_len,
2180 const struct bfd_elf_special_section *
2181 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2184 const struct bfd_elf_special_section *spec;
2185 const struct elf_backend_data *bed;
2187 /* See if this is one of the special sections. */
2188 if (sec->name == NULL)
2191 bed = get_elf_backend_data (abfd);
2192 spec = bed->special_sections;
2195 spec = _bfd_elf_get_special_section (sec->name,
2196 bed->special_sections,
2202 if (sec->name[0] != '.')
2205 i = sec->name[1] - 'b';
2206 if (i < 0 || i > 't' - 'b')
2209 spec = special_sections[i];
2214 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2218 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2220 struct bfd_elf_section_data *sdata;
2221 const struct elf_backend_data *bed;
2222 const struct bfd_elf_special_section *ssect;
2224 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2227 sdata = bfd_zalloc (abfd, sizeof (*sdata));
2230 sec->used_by_bfd = sdata;
2233 /* Indicate whether or not this section should use RELA relocations. */
2234 bed = get_elf_backend_data (abfd);
2235 sec->use_rela_p = bed->default_use_rela_p;
2237 /* When we read a file, we don't need to set ELF section type and
2238 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2239 anyway. We will set ELF section type and flags for all linker
2240 created sections. If user specifies BFD section flags, we will
2241 set ELF section type and flags based on BFD section flags in
2242 elf_fake_sections. */
2243 if ((!sec->flags && abfd->direction != read_direction)
2244 || (sec->flags & SEC_LINKER_CREATED) != 0)
2246 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2249 elf_section_type (sec) = ssect->type;
2250 elf_section_flags (sec) = ssect->attr;
2254 return _bfd_generic_new_section_hook (abfd, sec);
2257 /* Create a new bfd section from an ELF program header.
2259 Since program segments have no names, we generate a synthetic name
2260 of the form segment<NUM>, where NUM is generally the index in the
2261 program header table. For segments that are split (see below) we
2262 generate the names segment<NUM>a and segment<NUM>b.
2264 Note that some program segments may have a file size that is different than
2265 (less than) the memory size. All this means is that at execution the
2266 system must allocate the amount of memory specified by the memory size,
2267 but only initialize it with the first "file size" bytes read from the
2268 file. This would occur for example, with program segments consisting
2269 of combined data+bss.
2271 To handle the above situation, this routine generates TWO bfd sections
2272 for the single program segment. The first has the length specified by
2273 the file size of the segment, and the second has the length specified
2274 by the difference between the two sizes. In effect, the segment is split
2275 into its initialized and uninitialized parts.
2280 _bfd_elf_make_section_from_phdr (bfd *abfd,
2281 Elf_Internal_Phdr *hdr,
2283 const char *typename)
2291 split = ((hdr->p_memsz > 0)
2292 && (hdr->p_filesz > 0)
2293 && (hdr->p_memsz > hdr->p_filesz));
2295 if (hdr->p_filesz > 0)
2297 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2298 len = strlen (namebuf) + 1;
2299 name = bfd_alloc (abfd, len);
2302 memcpy (name, namebuf, len);
2303 newsect = bfd_make_section (abfd, name);
2304 if (newsect == NULL)
2306 newsect->vma = hdr->p_vaddr;
2307 newsect->lma = hdr->p_paddr;
2308 newsect->size = hdr->p_filesz;
2309 newsect->filepos = hdr->p_offset;
2310 newsect->flags |= SEC_HAS_CONTENTS;
2311 newsect->alignment_power = bfd_log2 (hdr->p_align);
2312 if (hdr->p_type == PT_LOAD)
2314 newsect->flags |= SEC_ALLOC;
2315 newsect->flags |= SEC_LOAD;
2316 if (hdr->p_flags & PF_X)
2318 /* FIXME: all we known is that it has execute PERMISSION,
2320 newsect->flags |= SEC_CODE;
2323 if (!(hdr->p_flags & PF_W))
2325 newsect->flags |= SEC_READONLY;
2329 if (hdr->p_memsz > hdr->p_filesz)
2333 sprintf (namebuf, "%s%d%s", typename, index, split ? "b" : "");
2334 len = strlen (namebuf) + 1;
2335 name = bfd_alloc (abfd, len);
2338 memcpy (name, namebuf, len);
2339 newsect = bfd_make_section (abfd, name);
2340 if (newsect == NULL)
2342 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2343 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2344 newsect->size = hdr->p_memsz - hdr->p_filesz;
2345 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2346 align = newsect->vma & -newsect->vma;
2347 if (align == 0 || align > hdr->p_align)
2348 align = hdr->p_align;
2349 newsect->alignment_power = bfd_log2 (align);
2350 if (hdr->p_type == PT_LOAD)
2352 /* Hack for gdb. Segments that have not been modified do
2353 not have their contents written to a core file, on the
2354 assumption that a debugger can find the contents in the
2355 executable. We flag this case by setting the fake
2356 section size to zero. Note that "real" bss sections will
2357 always have their contents dumped to the core file. */
2358 if (bfd_get_format (abfd) == bfd_core)
2360 newsect->flags |= SEC_ALLOC;
2361 if (hdr->p_flags & PF_X)
2362 newsect->flags |= SEC_CODE;
2364 if (!(hdr->p_flags & PF_W))
2365 newsect->flags |= SEC_READONLY;
2372 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
2374 const struct elf_backend_data *bed;
2376 switch (hdr->p_type)
2379 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2382 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2385 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2388 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2391 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2393 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2398 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2401 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2403 case PT_GNU_EH_FRAME:
2404 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2408 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
2411 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2414 /* Check for any processor-specific program segment types. */
2415 bed = get_elf_backend_data (abfd);
2416 return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
2420 /* Initialize REL_HDR, the section-header for new section, containing
2421 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
2422 relocations; otherwise, we use REL relocations. */
2425 _bfd_elf_init_reloc_shdr (bfd *abfd,
2426 Elf_Internal_Shdr *rel_hdr,
2428 bfd_boolean use_rela_p)
2431 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2432 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2434 name = bfd_alloc (abfd, amt);
2437 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2439 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2441 if (rel_hdr->sh_name == (unsigned int) -1)
2443 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2444 rel_hdr->sh_entsize = (use_rela_p
2445 ? bed->s->sizeof_rela
2446 : bed->s->sizeof_rel);
2447 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2448 rel_hdr->sh_flags = 0;
2449 rel_hdr->sh_addr = 0;
2450 rel_hdr->sh_size = 0;
2451 rel_hdr->sh_offset = 0;
2456 /* Set up an ELF internal section header for a section. */
2459 elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
2461 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2462 bfd_boolean *failedptr = failedptrarg;
2463 Elf_Internal_Shdr *this_hdr;
2464 unsigned int sh_type;
2468 /* We already failed; just get out of the bfd_map_over_sections
2473 this_hdr = &elf_section_data (asect)->this_hdr;
2475 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2476 asect->name, FALSE);
2477 if (this_hdr->sh_name == (unsigned int) -1)
2483 /* Don't clear sh_flags. Assembler may set additional bits. */
2485 if ((asect->flags & SEC_ALLOC) != 0
2486 || asect->user_set_vma)
2487 this_hdr->sh_addr = asect->vma;
2489 this_hdr->sh_addr = 0;
2491 this_hdr->sh_offset = 0;
2492 this_hdr->sh_size = asect->size;
2493 this_hdr->sh_link = 0;
2494 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2495 /* The sh_entsize and sh_info fields may have been set already by
2496 copy_private_section_data. */
2498 this_hdr->bfd_section = asect;
2499 this_hdr->contents = NULL;
2501 /* If the section type is unspecified, we set it based on
2503 if ((asect->flags & SEC_GROUP) != 0)
2504 sh_type = SHT_GROUP;
2505 else if ((asect->flags & SEC_ALLOC) != 0
2506 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2507 || (asect->flags & SEC_NEVER_LOAD) != 0))
2508 sh_type = SHT_NOBITS;
2510 sh_type = SHT_PROGBITS;
2512 if (this_hdr->sh_type == SHT_NULL)
2513 this_hdr->sh_type = sh_type;
2514 else if (this_hdr->sh_type == SHT_NOBITS
2515 && sh_type == SHT_PROGBITS
2516 && (asect->flags & SEC_ALLOC) != 0)
2518 /* Warn if we are changing a NOBITS section to PROGBITS, but
2519 allow the link to proceed. This can happen when users link
2520 non-bss input sections to bss output sections, or emit data
2521 to a bss output section via a linker script. */
2522 (*_bfd_error_handler)
2523 (_("warning: section `%A' type changed to PROGBITS"), asect);
2524 this_hdr->sh_type = sh_type;
2527 switch (this_hdr->sh_type)
2533 case SHT_INIT_ARRAY:
2534 case SHT_FINI_ARRAY:
2535 case SHT_PREINIT_ARRAY:
2542 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2546 this_hdr->sh_entsize = bed->s->sizeof_sym;
2550 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2554 if (get_elf_backend_data (abfd)->may_use_rela_p)
2555 this_hdr->sh_entsize = bed->s->sizeof_rela;
2559 if (get_elf_backend_data (abfd)->may_use_rel_p)
2560 this_hdr->sh_entsize = bed->s->sizeof_rel;
2563 case SHT_GNU_versym:
2564 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2567 case SHT_GNU_verdef:
2568 this_hdr->sh_entsize = 0;
2569 /* objcopy or strip will copy over sh_info, but may not set
2570 cverdefs. The linker will set cverdefs, but sh_info will be
2572 if (this_hdr->sh_info == 0)
2573 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2575 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2576 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2579 case SHT_GNU_verneed:
2580 this_hdr->sh_entsize = 0;
2581 /* objcopy or strip will copy over sh_info, but may not set
2582 cverrefs. The linker will set cverrefs, but sh_info will be
2584 if (this_hdr->sh_info == 0)
2585 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2587 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2588 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2592 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2596 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2600 if ((asect->flags & SEC_ALLOC) != 0)
2601 this_hdr->sh_flags |= SHF_ALLOC;
2602 if ((asect->flags & SEC_READONLY) == 0)
2603 this_hdr->sh_flags |= SHF_WRITE;
2604 if ((asect->flags & SEC_CODE) != 0)
2605 this_hdr->sh_flags |= SHF_EXECINSTR;
2606 if ((asect->flags & SEC_MERGE) != 0)
2608 this_hdr->sh_flags |= SHF_MERGE;
2609 this_hdr->sh_entsize = asect->entsize;
2610 if ((asect->flags & SEC_STRINGS) != 0)
2611 this_hdr->sh_flags |= SHF_STRINGS;
2613 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2614 this_hdr->sh_flags |= SHF_GROUP;
2615 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2617 this_hdr->sh_flags |= SHF_TLS;
2618 if (asect->size == 0
2619 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2621 struct bfd_link_order *o = asect->map_tail.link_order;
2623 this_hdr->sh_size = 0;
2626 this_hdr->sh_size = o->offset + o->size;
2627 if (this_hdr->sh_size != 0)
2628 this_hdr->sh_type = SHT_NOBITS;
2633 /* Check for processor-specific section types. */
2634 sh_type = this_hdr->sh_type;
2635 if (bed->elf_backend_fake_sections
2636 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2639 if (sh_type == SHT_NOBITS && asect->size != 0)
2641 /* Don't change the header type from NOBITS if we are being
2642 called for objcopy --only-keep-debug. */
2643 this_hdr->sh_type = sh_type;
2646 /* If the section has relocs, set up a section header for the
2647 SHT_REL[A] section. If two relocation sections are required for
2648 this section, it is up to the processor-specific back-end to
2649 create the other. */
2650 if ((asect->flags & SEC_RELOC) != 0
2651 && !_bfd_elf_init_reloc_shdr (abfd,
2652 &elf_section_data (asect)->rel_hdr,
2658 /* Fill in the contents of a SHT_GROUP section. */
2661 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2663 bfd_boolean *failedptr = failedptrarg;
2664 unsigned long symindx;
2665 asection *elt, *first;
2669 /* Ignore linker created group section. See elfNN_ia64_object_p in
2671 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2676 if (elf_group_id (sec) != NULL)
2677 symindx = elf_group_id (sec)->udata.i;
2681 /* If called from the assembler, swap_out_syms will have set up
2682 elf_section_syms; If called for "ld -r", use target_index. */
2683 if (elf_section_syms (abfd) != NULL)
2684 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2686 symindx = sec->target_index;
2688 elf_section_data (sec)->this_hdr.sh_info = symindx;
2690 /* The contents won't be allocated for "ld -r" or objcopy. */
2692 if (sec->contents == NULL)
2695 sec->contents = bfd_alloc (abfd, sec->size);
2697 /* Arrange for the section to be written out. */
2698 elf_section_data (sec)->this_hdr.contents = sec->contents;
2699 if (sec->contents == NULL)
2706 loc = sec->contents + sec->size;
2708 /* Get the pointer to the first section in the group that gas
2709 squirreled away here. objcopy arranges for this to be set to the
2710 start of the input section group. */
2711 first = elt = elf_next_in_group (sec);
2713 /* First element is a flag word. Rest of section is elf section
2714 indices for all the sections of the group. Write them backwards
2715 just to keep the group in the same order as given in .section
2716 directives, not that it matters. */
2725 s = s->output_section;
2728 idx = elf_section_data (s)->this_idx;
2729 H_PUT_32 (abfd, idx, loc);
2730 elt = elf_next_in_group (elt);
2735 if ((loc -= 4) != sec->contents)
2738 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2741 /* Assign all ELF section numbers. The dummy first section is handled here
2742 too. The link/info pointers for the standard section types are filled
2743 in here too, while we're at it. */
2746 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2748 struct elf_obj_tdata *t = elf_tdata (abfd);
2750 unsigned int section_number, secn;
2751 Elf_Internal_Shdr **i_shdrp;
2752 struct bfd_elf_section_data *d;
2756 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2758 /* SHT_GROUP sections are in relocatable files only. */
2759 if (link_info == NULL || link_info->relocatable)
2761 /* Put SHT_GROUP sections first. */
2762 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2764 d = elf_section_data (sec);
2766 if (d->this_hdr.sh_type == SHT_GROUP)
2768 if (sec->flags & SEC_LINKER_CREATED)
2770 /* Remove the linker created SHT_GROUP sections. */
2771 bfd_section_list_remove (abfd, sec);
2772 abfd->section_count--;
2775 d->this_idx = section_number++;
2780 for (sec = abfd->sections; sec; sec = sec->next)
2782 d = elf_section_data (sec);
2784 if (d->this_hdr.sh_type != SHT_GROUP)
2785 d->this_idx = section_number++;
2786 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2787 if ((sec->flags & SEC_RELOC) == 0)
2791 d->rel_idx = section_number++;
2792 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2797 d->rel_idx2 = section_number++;
2798 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2804 t->shstrtab_section = section_number++;
2805 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2806 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2808 if (bfd_get_symcount (abfd) > 0)
2810 t->symtab_section = section_number++;
2811 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2812 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2814 t->symtab_shndx_section = section_number++;
2815 t->symtab_shndx_hdr.sh_name
2816 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2817 ".symtab_shndx", FALSE);
2818 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2821 t->strtab_section = section_number++;
2822 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2825 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2826 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2828 elf_numsections (abfd) = section_number;
2829 elf_elfheader (abfd)->e_shnum = section_number;
2831 /* Set up the list of section header pointers, in agreement with the
2833 i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
2834 if (i_shdrp == NULL)
2837 i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
2838 if (i_shdrp[0] == NULL)
2840 bfd_release (abfd, i_shdrp);
2844 elf_elfsections (abfd) = i_shdrp;
2846 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2847 if (bfd_get_symcount (abfd) > 0)
2849 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2850 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
2852 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2853 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2855 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2856 t->symtab_hdr.sh_link = t->strtab_section;
2859 for (sec = abfd->sections; sec; sec = sec->next)
2861 struct bfd_elf_section_data *d = elf_section_data (sec);
2865 i_shdrp[d->this_idx] = &d->this_hdr;
2866 if (d->rel_idx != 0)
2867 i_shdrp[d->rel_idx] = &d->rel_hdr;
2868 if (d->rel_idx2 != 0)
2869 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2871 /* Fill in the sh_link and sh_info fields while we're at it. */
2873 /* sh_link of a reloc section is the section index of the symbol
2874 table. sh_info is the section index of the section to which
2875 the relocation entries apply. */
2876 if (d->rel_idx != 0)
2878 d->rel_hdr.sh_link = t->symtab_section;
2879 d->rel_hdr.sh_info = d->this_idx;
2881 if (d->rel_idx2 != 0)
2883 d->rel_hdr2->sh_link = t->symtab_section;
2884 d->rel_hdr2->sh_info = d->this_idx;
2887 /* We need to set up sh_link for SHF_LINK_ORDER. */
2888 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2890 s = elf_linked_to_section (sec);
2893 /* elf_linked_to_section points to the input section. */
2894 if (link_info != NULL)
2896 /* Check discarded linkonce section. */
2897 if (elf_discarded_section (s))
2900 (*_bfd_error_handler)
2901 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2902 abfd, d->this_hdr.bfd_section,
2904 /* Point to the kept section if it has the same
2905 size as the discarded one. */
2906 kept = _bfd_elf_check_kept_section (s, link_info);
2909 bfd_set_error (bfd_error_bad_value);
2915 s = s->output_section;
2916 BFD_ASSERT (s != NULL);
2920 /* Handle objcopy. */
2921 if (s->output_section == NULL)
2923 (*_bfd_error_handler)
2924 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2925 abfd, d->this_hdr.bfd_section, s, s->owner);
2926 bfd_set_error (bfd_error_bad_value);
2929 s = s->output_section;
2931 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2936 The Intel C compiler generates SHT_IA_64_UNWIND with
2937 SHF_LINK_ORDER. But it doesn't set the sh_link or
2938 sh_info fields. Hence we could get the situation
2940 const struct elf_backend_data *bed
2941 = get_elf_backend_data (abfd);
2942 if (bed->link_order_error_handler)
2943 bed->link_order_error_handler
2944 (_("%B: warning: sh_link not set for section `%A'"),
2949 switch (d->this_hdr.sh_type)
2953 /* A reloc section which we are treating as a normal BFD
2954 section. sh_link is the section index of the symbol
2955 table. sh_info is the section index of the section to
2956 which the relocation entries apply. We assume that an
2957 allocated reloc section uses the dynamic symbol table.
2958 FIXME: How can we be sure? */
2959 s = bfd_get_section_by_name (abfd, ".dynsym");
2961 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2963 /* We look up the section the relocs apply to by name. */
2965 if (d->this_hdr.sh_type == SHT_REL)
2969 s = bfd_get_section_by_name (abfd, name);
2971 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2975 /* We assume that a section named .stab*str is a stabs
2976 string section. We look for a section with the same name
2977 but without the trailing ``str'', and set its sh_link
2978 field to point to this section. */
2979 if (CONST_STRNEQ (sec->name, ".stab")
2980 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2985 len = strlen (sec->name);
2986 alc = bfd_malloc (len - 2);
2989 memcpy (alc, sec->name, len - 3);
2990 alc[len - 3] = '\0';
2991 s = bfd_get_section_by_name (abfd, alc);
2995 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2997 /* This is a .stab section. */
2998 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2999 elf_section_data (s)->this_hdr.sh_entsize
3000 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3007 case SHT_GNU_verneed:
3008 case SHT_GNU_verdef:
3009 /* sh_link is the section header index of the string table
3010 used for the dynamic entries, or the symbol table, or the
3012 s = bfd_get_section_by_name (abfd, ".dynstr");
3014 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3017 case SHT_GNU_LIBLIST:
3018 /* sh_link is the section header index of the prelink library
3019 list used for the dynamic entries, or the symbol table, or
3020 the version strings. */
3021 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3022 ? ".dynstr" : ".gnu.libstr");
3024 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3029 case SHT_GNU_versym:
3030 /* sh_link is the section header index of the symbol table
3031 this hash table or version table is for. */
3032 s = bfd_get_section_by_name (abfd, ".dynsym");
3034 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3038 d->this_hdr.sh_link = t->symtab_section;
3042 for (secn = 1; secn < section_number; ++secn)
3043 if (i_shdrp[secn] == NULL)
3044 i_shdrp[secn] = i_shdrp[0];
3046 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3047 i_shdrp[secn]->sh_name);
3051 /* Map symbol from it's internal number to the external number, moving
3052 all local symbols to be at the head of the list. */
3055 sym_is_global (bfd *abfd, asymbol *sym)
3057 /* If the backend has a special mapping, use it. */
3058 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3059 if (bed->elf_backend_sym_is_global)
3060 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3062 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3063 || bfd_is_und_section (bfd_get_section (sym))
3064 || bfd_is_com_section (bfd_get_section (sym)));
3067 /* Don't output section symbols for sections that are not going to be
3068 output. Also, don't output section symbols for reloc and other
3069 special sections. */
3072 ignore_section_sym (bfd *abfd, asymbol *sym)
3074 return ((sym->flags & BSF_SECTION_SYM) != 0
3076 || (sym->section->owner != abfd
3077 && (sym->section->output_section->owner != abfd
3078 || sym->section->output_offset != 0))));
3082 elf_map_symbols (bfd *abfd)
3084 unsigned int symcount = bfd_get_symcount (abfd);
3085 asymbol **syms = bfd_get_outsymbols (abfd);
3086 asymbol **sect_syms;
3087 unsigned int num_locals = 0;
3088 unsigned int num_globals = 0;
3089 unsigned int num_locals2 = 0;
3090 unsigned int num_globals2 = 0;
3097 fprintf (stderr, "elf_map_symbols\n");
3101 for (asect = abfd->sections; asect; asect = asect->next)
3103 if (max_index < asect->index)
3104 max_index = asect->index;
3108 sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3109 if (sect_syms == NULL)
3111 elf_section_syms (abfd) = sect_syms;
3112 elf_num_section_syms (abfd) = max_index;
3114 /* Init sect_syms entries for any section symbols we have already
3115 decided to output. */
3116 for (idx = 0; idx < symcount; idx++)
3118 asymbol *sym = syms[idx];
3120 if ((sym->flags & BSF_SECTION_SYM) != 0
3121 && !ignore_section_sym (abfd, sym))
3123 asection *sec = sym->section;
3125 if (sec->owner != abfd)
3126 sec = sec->output_section;
3128 sect_syms[sec->index] = syms[idx];
3132 /* Classify all of the symbols. */
3133 for (idx = 0; idx < symcount; idx++)
3135 if (ignore_section_sym (abfd, syms[idx]))
3137 if (!sym_is_global (abfd, syms[idx]))
3143 /* We will be adding a section symbol for each normal BFD section. Most
3144 sections will already have a section symbol in outsymbols, but
3145 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3146 at least in that case. */
3147 for (asect = abfd->sections; asect; asect = asect->next)
3149 if (sect_syms[asect->index] == NULL)
3151 if (!sym_is_global (abfd, asect->symbol))
3158 /* Now sort the symbols so the local symbols are first. */
3159 new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
3161 if (new_syms == NULL)
3164 for (idx = 0; idx < symcount; idx++)
3166 asymbol *sym = syms[idx];
3169 if (ignore_section_sym (abfd, sym))
3171 if (!sym_is_global (abfd, sym))
3174 i = num_locals + num_globals2++;
3176 sym->udata.i = i + 1;
3178 for (asect = abfd->sections; asect; asect = asect->next)
3180 if (sect_syms[asect->index] == NULL)
3182 asymbol *sym = asect->symbol;
3185 sect_syms[asect->index] = sym;
3186 if (!sym_is_global (abfd, sym))
3189 i = num_locals + num_globals2++;
3191 sym->udata.i = i + 1;
3195 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3197 elf_num_locals (abfd) = num_locals;
3198 elf_num_globals (abfd) = num_globals;
3202 /* Align to the maximum file alignment that could be required for any
3203 ELF data structure. */
3205 static inline file_ptr
3206 align_file_position (file_ptr off, int align)
3208 return (off + align - 1) & ~(align - 1);
3211 /* Assign a file position to a section, optionally aligning to the
3212 required section alignment. */
3215 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3219 if (align && i_shdrp->sh_addralign > 1)
3220 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3221 i_shdrp->sh_offset = offset;
3222 if (i_shdrp->bfd_section != NULL)
3223 i_shdrp->bfd_section->filepos = offset;
3224 if (i_shdrp->sh_type != SHT_NOBITS)
3225 offset += i_shdrp->sh_size;
3229 /* Compute the file positions we are going to put the sections at, and
3230 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3231 is not NULL, this is being called by the ELF backend linker. */
3234 _bfd_elf_compute_section_file_positions (bfd *abfd,
3235 struct bfd_link_info *link_info)
3237 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3239 struct bfd_strtab_hash *strtab = NULL;
3240 Elf_Internal_Shdr *shstrtab_hdr;
3242 if (abfd->output_has_begun)
3245 /* Do any elf backend specific processing first. */
3246 if (bed->elf_backend_begin_write_processing)
3247 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3249 if (! prep_headers (abfd))
3252 /* Post process the headers if necessary. */
3253 if (bed->elf_backend_post_process_headers)
3254 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3257 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3261 if (!assign_section_numbers (abfd, link_info))
3264 /* The backend linker builds symbol table information itself. */
3265 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3267 /* Non-zero if doing a relocatable link. */
3268 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3270 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3274 if (link_info == NULL)
3276 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3281 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3282 /* sh_name was set in prep_headers. */
3283 shstrtab_hdr->sh_type = SHT_STRTAB;
3284 shstrtab_hdr->sh_flags = 0;
3285 shstrtab_hdr->sh_addr = 0;
3286 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3287 shstrtab_hdr->sh_entsize = 0;
3288 shstrtab_hdr->sh_link = 0;
3289 shstrtab_hdr->sh_info = 0;
3290 /* sh_offset is set in assign_file_positions_except_relocs. */
3291 shstrtab_hdr->sh_addralign = 1;
3293 if (!assign_file_positions_except_relocs (abfd, link_info))
3296 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3299 Elf_Internal_Shdr *hdr;
3301 off = elf_tdata (abfd)->next_file_pos;
3303 hdr = &elf_tdata (abfd)->symtab_hdr;
3304 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3306 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3307 if (hdr->sh_size != 0)
3308 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3310 hdr = &elf_tdata (abfd)->strtab_hdr;
3311 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3313 elf_tdata (abfd)->next_file_pos = off;
3315 /* Now that we know where the .strtab section goes, write it
3317 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3318 || ! _bfd_stringtab_emit (abfd, strtab))
3320 _bfd_stringtab_free (strtab);
3323 abfd->output_has_begun = TRUE;
3328 /* Make an initial estimate of the size of the program header. If we
3329 get the number wrong here, we'll redo section placement. */
3331 static bfd_size_type
3332 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3336 const struct elf_backend_data *bed;
3338 /* Assume we will need exactly two PT_LOAD segments: one for text
3339 and one for data. */
3342 s = bfd_get_section_by_name (abfd, ".interp");
3343 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3345 /* If we have a loadable interpreter section, we need a
3346 PT_INTERP segment. In this case, assume we also need a
3347 PT_PHDR segment, although that may not be true for all
3352 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3354 /* We need a PT_DYNAMIC segment. */
3360 /* We need a PT_GNU_RELRO segment. */
3364 if (elf_tdata (abfd)->eh_frame_hdr)
3366 /* We need a PT_GNU_EH_FRAME segment. */
3370 if (elf_tdata (abfd)->stack_flags)
3372 /* We need a PT_GNU_STACK segment. */
3376 for (s = abfd->sections; s != NULL; s = s->next)
3378 if ((s->flags & SEC_LOAD) != 0
3379 && CONST_STRNEQ (s->name, ".note"))
3381 /* We need a PT_NOTE segment. */
3383 /* Try to create just one PT_NOTE segment
3384 for all adjacent loadable .note* sections.
3385 gABI requires that within a PT_NOTE segment
3386 (and also inside of each SHT_NOTE section)
3387 each note is padded to a multiple of 4 size,
3388 so we check whether the sections are correctly
3390 if (s->alignment_power == 2)
3391 while (s->next != NULL
3392 && s->next->alignment_power == 2
3393 && (s->next->flags & SEC_LOAD) != 0
3394 && CONST_STRNEQ (s->next->name, ".note"))
3399 for (s = abfd->sections; s != NULL; s = s->next)
3401 if (s->flags & SEC_THREAD_LOCAL)
3403 /* We need a PT_TLS segment. */
3409 /* Let the backend count up any program headers it might need. */
3410 bed = get_elf_backend_data (abfd);
3411 if (bed->elf_backend_additional_program_headers)
3415 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3421 return segs * bed->s->sizeof_phdr;
3424 /* Find the segment that contains the output_section of section. */
3427 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3429 struct elf_segment_map *m;
3430 Elf_Internal_Phdr *p;
3432 for (m = elf_tdata (abfd)->segment_map,
3433 p = elf_tdata (abfd)->phdr;
3439 for (i = m->count - 1; i >= 0; i--)
3440 if (m->sections[i] == section)
3447 /* Create a mapping from a set of sections to a program segment. */
3449 static struct elf_segment_map *
3450 make_mapping (bfd *abfd,
3451 asection **sections,
3456 struct elf_segment_map *m;
3461 amt = sizeof (struct elf_segment_map);
3462 amt += (to - from - 1) * sizeof (asection *);
3463 m = bfd_zalloc (abfd, amt);
3467 m->p_type = PT_LOAD;
3468 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3469 m->sections[i - from] = *hdrpp;
3470 m->count = to - from;
3472 if (from == 0 && phdr)
3474 /* Include the headers in the first PT_LOAD segment. */
3475 m->includes_filehdr = 1;
3476 m->includes_phdrs = 1;
3482 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3485 struct elf_segment_map *
3486 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3488 struct elf_segment_map *m;
3490 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3494 m->p_type = PT_DYNAMIC;
3496 m->sections[0] = dynsec;
3501 /* Possibly add or remove segments from the segment map. */
3504 elf_modify_segment_map (bfd *abfd,
3505 struct bfd_link_info *info,
3506 bfd_boolean remove_empty_load)
3508 struct elf_segment_map **m;
3509 const struct elf_backend_data *bed;
3511 /* The placement algorithm assumes that non allocated sections are
3512 not in PT_LOAD segments. We ensure this here by removing such
3513 sections from the segment map. We also remove excluded
3514 sections. Finally, any PT_LOAD segment without sections is
3516 m = &elf_tdata (abfd)->segment_map;
3519 unsigned int i, new_count;
3521 for (new_count = 0, i = 0; i < (*m)->count; i++)
3523 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3524 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3525 || (*m)->p_type != PT_LOAD))
3527 (*m)->sections[new_count] = (*m)->sections[i];
3531 (*m)->count = new_count;
3533 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3539 bed = get_elf_backend_data (abfd);
3540 if (bed->elf_backend_modify_segment_map != NULL)
3542 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3549 /* Set up a mapping from BFD sections to program segments. */
3552 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3555 struct elf_segment_map *m;
3556 asection **sections = NULL;
3557 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3558 bfd_boolean no_user_phdrs;
3560 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3561 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3565 struct elf_segment_map *mfirst;
3566 struct elf_segment_map **pm;
3569 unsigned int phdr_index;
3570 bfd_vma maxpagesize;
3572 bfd_boolean phdr_in_segment = TRUE;
3573 bfd_boolean writable;
3575 asection *first_tls = NULL;
3576 asection *dynsec, *eh_frame_hdr;
3579 /* Select the allocated sections, and sort them. */
3581 sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3582 if (sections == NULL)
3586 for (s = abfd->sections; s != NULL; s = s->next)
3588 if ((s->flags & SEC_ALLOC) != 0)
3594 BFD_ASSERT (i <= bfd_count_sections (abfd));
3597 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3599 /* Build the mapping. */
3604 /* If we have a .interp section, then create a PT_PHDR segment for
3605 the program headers and a PT_INTERP segment for the .interp
3607 s = bfd_get_section_by_name (abfd, ".interp");
3608 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3610 amt = sizeof (struct elf_segment_map);
3611 m = bfd_zalloc (abfd, amt);
3615 m->p_type = PT_PHDR;
3616 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3617 m->p_flags = PF_R | PF_X;
3618 m->p_flags_valid = 1;
3619 m->includes_phdrs = 1;
3624 amt = sizeof (struct elf_segment_map);
3625 m = bfd_zalloc (abfd, amt);
3629 m->p_type = PT_INTERP;
3637 /* Look through the sections. We put sections in the same program
3638 segment when the start of the second section can be placed within
3639 a few bytes of the end of the first section. */
3643 maxpagesize = bed->maxpagesize;
3645 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3647 && (dynsec->flags & SEC_LOAD) == 0)
3650 /* Deal with -Ttext or something similar such that the first section
3651 is not adjacent to the program headers. This is an
3652 approximation, since at this point we don't know exactly how many
3653 program headers we will need. */
3656 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3658 if (phdr_size == (bfd_size_type) -1)
3659 phdr_size = get_program_header_size (abfd, info);
3660 if ((abfd->flags & D_PAGED) == 0
3661 || sections[0]->lma < phdr_size
3662 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3663 phdr_in_segment = FALSE;
3666 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3669 bfd_boolean new_segment;
3673 /* See if this section and the last one will fit in the same
3676 if (last_hdr == NULL)
3678 /* If we don't have a segment yet, then we don't need a new
3679 one (we build the last one after this loop). */
3680 new_segment = FALSE;
3682 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3684 /* If this section has a different relation between the
3685 virtual address and the load address, then we need a new
3689 else if (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize)
3690 < BFD_ALIGN (hdr->lma, maxpagesize))
3692 /* If putting this section in this segment would force us to
3693 skip a page in the segment, then we need a new segment. */
3696 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3697 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3699 /* We don't want to put a loadable section after a
3700 nonloadable section in the same segment.
3701 Consider .tbss sections as loadable for this purpose. */
3704 else if ((abfd->flags & D_PAGED) == 0)
3706 /* If the file is not demand paged, which means that we
3707 don't require the sections to be correctly aligned in the
3708 file, then there is no other reason for a new segment. */
3709 new_segment = FALSE;
3712 && (hdr->flags & SEC_READONLY) == 0
3713 && (((last_hdr->lma + last_size - 1)
3714 & ~(maxpagesize - 1))
3715 != (hdr->lma & ~(maxpagesize - 1))))
3717 /* We don't want to put a writable section in a read only
3718 segment, unless they are on the same page in memory
3719 anyhow. We already know that the last section does not
3720 bring us past the current section on the page, so the
3721 only case in which the new section is not on the same
3722 page as the previous section is when the previous section
3723 ends precisely on a page boundary. */
3728 /* Otherwise, we can use the same segment. */
3729 new_segment = FALSE;
3732 /* Allow interested parties a chance to override our decision. */
3733 if (last_hdr && info->callbacks->override_segment_assignment)
3734 new_segment = info->callbacks->override_segment_assignment (info, abfd, hdr, last_hdr, new_segment);
3738 if ((hdr->flags & SEC_READONLY) == 0)
3741 /* .tbss sections effectively have zero size. */
3742 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3743 != SEC_THREAD_LOCAL)
3744 last_size = hdr->size;
3750 /* We need a new program segment. We must create a new program
3751 header holding all the sections from phdr_index until hdr. */
3753 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3760 if ((hdr->flags & SEC_READONLY) == 0)
3766 /* .tbss sections effectively have zero size. */
3767 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3768 last_size = hdr->size;
3772 phdr_in_segment = FALSE;
3775 /* Create a final PT_LOAD program segment. */
3776 if (last_hdr != NULL)
3778 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3786 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3789 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3796 /* For each batch of consecutive loadable .note sections,
3797 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3798 because if we link together nonloadable .note sections and
3799 loadable .note sections, we will generate two .note sections
3800 in the output file. FIXME: Using names for section types is
3802 for (s = abfd->sections; s != NULL; s = s->next)
3804 if ((s->flags & SEC_LOAD) != 0
3805 && CONST_STRNEQ (s->name, ".note"))
3809 amt = sizeof (struct elf_segment_map);
3810 if (s->alignment_power == 2)
3811 for (s2 = s; s2->next != NULL; s2 = s2->next)
3813 if (s2->next->alignment_power == 2
3814 && (s2->next->flags & SEC_LOAD) != 0
3815 && CONST_STRNEQ (s2->next->name, ".note")
3816 && align_power (s2->vma + s2->size, 2)
3822 amt += (count - 1) * sizeof (asection *);
3823 m = bfd_zalloc (abfd, amt);
3827 m->p_type = PT_NOTE;
3831 m->sections[m->count - count--] = s;
3832 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3835 m->sections[m->count - 1] = s;
3836 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3840 if (s->flags & SEC_THREAD_LOCAL)
3848 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3853 amt = sizeof (struct elf_segment_map);
3854 amt += (tls_count - 1) * sizeof (asection *);
3855 m = bfd_zalloc (abfd, amt);
3860 m->count = tls_count;
3861 /* Mandated PF_R. */
3863 m->p_flags_valid = 1;
3864 for (i = 0; i < tls_count; ++i)
3866 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3867 m->sections[i] = first_tls;
3868 first_tls = first_tls->next;
3875 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3877 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3878 if (eh_frame_hdr != NULL
3879 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
3881 amt = sizeof (struct elf_segment_map);
3882 m = bfd_zalloc (abfd, amt);
3886 m->p_type = PT_GNU_EH_FRAME;
3888 m->sections[0] = eh_frame_hdr->output_section;
3894 if (elf_tdata (abfd)->stack_flags)
3896 amt = sizeof (struct elf_segment_map);
3897 m = bfd_zalloc (abfd, amt);
3901 m->p_type = PT_GNU_STACK;
3902 m->p_flags = elf_tdata (abfd)->stack_flags;
3903 m->p_flags_valid = 1;
3911 for (m = mfirst; m != NULL; m = m->next)
3913 if (m->p_type == PT_LOAD)
3915 asection *last = m->sections[m->count - 1];
3916 bfd_vma vaddr = m->sections[0]->vma;
3917 bfd_vma filesz = last->vma - vaddr + last->size;
3919 if (vaddr < info->relro_end
3920 && vaddr >= info->relro_start
3921 && (vaddr + filesz) >= info->relro_end)
3926 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3929 amt = sizeof (struct elf_segment_map);
3930 m = bfd_zalloc (abfd, amt);
3934 m->p_type = PT_GNU_RELRO;
3936 m->p_flags_valid = 1;
3944 elf_tdata (abfd)->segment_map = mfirst;
3947 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
3950 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3952 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
3957 if (sections != NULL)
3962 /* Sort sections by address. */
3965 elf_sort_sections (const void *arg1, const void *arg2)
3967 const asection *sec1 = *(const asection **) arg1;
3968 const asection *sec2 = *(const asection **) arg2;
3969 bfd_size_type size1, size2;
3971 /* Sort by LMA first, since this is the address used to
3972 place the section into a segment. */
3973 if (sec1->lma < sec2->lma)
3975 else if (sec1->lma > sec2->lma)
3978 /* Then sort by VMA. Normally the LMA and the VMA will be
3979 the same, and this will do nothing. */
3980 if (sec1->vma < sec2->vma)
3982 else if (sec1->vma > sec2->vma)
3985 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3987 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
3993 /* If the indicies are the same, do not return 0
3994 here, but continue to try the next comparison. */
3995 if (sec1->target_index - sec2->target_index != 0)
3996 return sec1->target_index - sec2->target_index;
4001 else if (TOEND (sec2))
4006 /* Sort by size, to put zero sized sections
4007 before others at the same address. */
4009 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4010 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4017 return sec1->target_index - sec2->target_index;
4020 /* Ian Lance Taylor writes:
4022 We shouldn't be using % with a negative signed number. That's just
4023 not good. We have to make sure either that the number is not
4024 negative, or that the number has an unsigned type. When the types
4025 are all the same size they wind up as unsigned. When file_ptr is a
4026 larger signed type, the arithmetic winds up as signed long long,
4029 What we're trying to say here is something like ``increase OFF by
4030 the least amount that will cause it to be equal to the VMA modulo
4032 /* In other words, something like:
4034 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4035 off_offset = off % bed->maxpagesize;
4036 if (vma_offset < off_offset)
4037 adjustment = vma_offset + bed->maxpagesize - off_offset;
4039 adjustment = vma_offset - off_offset;
4041 which can can be collapsed into the expression below. */
4044 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4046 return ((vma - off) % maxpagesize);
4050 print_segment_map (const struct elf_segment_map *m)
4053 const char *pt = get_segment_type (m->p_type);
4058 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4059 sprintf (buf, "LOPROC+%7.7x",
4060 (unsigned int) (m->p_type - PT_LOPROC));
4061 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4062 sprintf (buf, "LOOS+%7.7x",
4063 (unsigned int) (m->p_type - PT_LOOS));
4065 snprintf (buf, sizeof (buf), "%8.8x",
4066 (unsigned int) m->p_type);
4069 fprintf (stderr, "%s:", pt);
4070 for (j = 0; j < m->count; j++)
4071 fprintf (stderr, " %s", m->sections [j]->name);
4075 /* Assign file positions to the sections based on the mapping from
4076 sections to segments. This function also sets up some fields in
4080 assign_file_positions_for_load_sections (bfd *abfd,
4081 struct bfd_link_info *link_info)
4083 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4084 struct elf_segment_map *m;
4085 Elf_Internal_Phdr *phdrs;
4086 Elf_Internal_Phdr *p;
4088 bfd_size_type maxpagesize;
4092 if (link_info == NULL
4093 && !elf_modify_segment_map (abfd, link_info, FALSE))
4097 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4100 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4101 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4102 elf_elfheader (abfd)->e_phnum = alloc;
4104 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4105 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4107 BFD_ASSERT (elf_tdata (abfd)->program_header_size
4108 >= alloc * bed->s->sizeof_phdr);
4112 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4116 phdrs = bfd_alloc2 (abfd, alloc, sizeof (Elf_Internal_Phdr));
4117 elf_tdata (abfd)->phdr = phdrs;
4122 if ((abfd->flags & D_PAGED) != 0)
4123 maxpagesize = bed->maxpagesize;
4125 off = bed->s->sizeof_ehdr;
4126 off += alloc * bed->s->sizeof_phdr;
4128 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4130 m = m->next, p++, j++)
4134 bfd_boolean no_contents;
4136 /* If elf_segment_map is not from map_sections_to_segments, the
4137 sections may not be correctly ordered. NOTE: sorting should
4138 not be done to the PT_NOTE section of a corefile, which may
4139 contain several pseudo-sections artificially created by bfd.
4140 Sorting these pseudo-sections breaks things badly. */
4142 && !(elf_elfheader (abfd)->e_type == ET_CORE
4143 && m->p_type == PT_NOTE))
4144 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4147 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4148 number of sections with contents contributing to both p_filesz
4149 and p_memsz, followed by a number of sections with no contents
4150 that just contribute to p_memsz. In this loop, OFF tracks next
4151 available file offset for PT_LOAD and PT_NOTE segments. */
4152 p->p_type = m->p_type;
4153 p->p_flags = m->p_flags;
4158 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4160 if (m->p_paddr_valid)
4161 p->p_paddr = m->p_paddr;
4162 else if (m->count == 0)
4165 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4167 if (p->p_type == PT_LOAD
4168 && (abfd->flags & D_PAGED) != 0)
4170 /* p_align in demand paged PT_LOAD segments effectively stores
4171 the maximum page size. When copying an executable with
4172 objcopy, we set m->p_align from the input file. Use this
4173 value for maxpagesize rather than bed->maxpagesize, which
4174 may be different. Note that we use maxpagesize for PT_TLS
4175 segment alignment later in this function, so we are relying
4176 on at least one PT_LOAD segment appearing before a PT_TLS
4178 if (m->p_align_valid)
4179 maxpagesize = m->p_align;
4181 p->p_align = maxpagesize;
4183 else if (m->p_align_valid)
4184 p->p_align = m->p_align;
4185 else if (m->count == 0)
4186 p->p_align = 1 << bed->s->log_file_align;
4190 no_contents = FALSE;
4192 if (p->p_type == PT_LOAD
4195 bfd_size_type align;
4196 unsigned int align_power = 0;
4198 if (m->p_align_valid)
4202 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4204 unsigned int secalign;
4206 secalign = bfd_get_section_alignment (abfd, *secpp);
4207 if (secalign > align_power)
4208 align_power = secalign;
4210 align = (bfd_size_type) 1 << align_power;
4211 if (align < maxpagesize)
4212 align = maxpagesize;
4215 for (i = 0; i < m->count; i++)
4216 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4217 /* If we aren't making room for this section, then
4218 it must be SHT_NOBITS regardless of what we've
4219 set via struct bfd_elf_special_section. */
4220 elf_section_type (m->sections[i]) = SHT_NOBITS;
4222 /* Find out whether this segment contains any loadable
4223 sections. If the first section isn't loadable, the same
4224 holds for any other sections. */
4226 while (elf_section_type (m->sections[i]) == SHT_NOBITS)
4228 /* If a segment starts with .tbss, we need to look
4229 at the next section to decide whether the segment
4230 has any loadable sections. */
4231 if ((elf_section_flags (m->sections[i]) & SHF_TLS) == 0
4239 off_adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4243 /* We shouldn't need to align the segment on disk since
4244 the segment doesn't need file space, but the gABI
4245 arguably requires the alignment and glibc ld.so
4246 checks it. So to comply with the alignment
4247 requirement but not waste file space, we adjust
4248 p_offset for just this segment. (OFF_ADJUST is
4249 subtracted from OFF later.) This may put p_offset
4250 past the end of file, but that shouldn't matter. */
4255 /* Make sure the .dynamic section is the first section in the
4256 PT_DYNAMIC segment. */
4257 else if (p->p_type == PT_DYNAMIC
4259 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4262 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4264 bfd_set_error (bfd_error_bad_value);
4267 /* Set the note section type to SHT_NOTE. */
4268 else if (p->p_type == PT_NOTE)
4269 for (i = 0; i < m->count; i++)
4270 elf_section_type (m->sections[i]) = SHT_NOTE;
4276 if (m->includes_filehdr)
4278 if (!m->p_flags_valid)
4280 p->p_filesz = bed->s->sizeof_ehdr;
4281 p->p_memsz = bed->s->sizeof_ehdr;
4284 BFD_ASSERT (p->p_type == PT_LOAD);
4286 if (p->p_vaddr < (bfd_vma) off)
4288 (*_bfd_error_handler)
4289 (_("%B: Not enough room for program headers, try linking with -N"),
4291 bfd_set_error (bfd_error_bad_value);
4296 if (!m->p_paddr_valid)
4301 if (m->includes_phdrs)
4303 if (!m->p_flags_valid)
4306 if (!m->includes_filehdr)
4308 p->p_offset = bed->s->sizeof_ehdr;
4312 BFD_ASSERT (p->p_type == PT_LOAD);
4313 p->p_vaddr -= off - p->p_offset;
4314 if (!m->p_paddr_valid)
4315 p->p_paddr -= off - p->p_offset;
4319 p->p_filesz += alloc * bed->s->sizeof_phdr;
4320 p->p_memsz += alloc * bed->s->sizeof_phdr;
4323 if (p->p_type == PT_LOAD
4324 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4326 if (!m->includes_filehdr && !m->includes_phdrs)
4332 adjust = off - (p->p_offset + p->p_filesz);
4334 p->p_filesz += adjust;
4335 p->p_memsz += adjust;
4339 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4340 maps. Set filepos for sections in PT_LOAD segments, and in
4341 core files, for sections in PT_NOTE segments.
4342 assign_file_positions_for_non_load_sections will set filepos
4343 for other sections and update p_filesz for other segments. */
4344 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4347 bfd_size_type align;
4348 Elf_Internal_Shdr *this_hdr;
4351 this_hdr = &elf_section_data (sec)->this_hdr;
4352 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4354 if ((p->p_type == PT_LOAD
4355 || p->p_type == PT_TLS)
4356 && (this_hdr->sh_type != SHT_NOBITS
4357 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4358 && ((this_hdr->sh_flags & SHF_TLS) == 0
4359 || p->p_type == PT_TLS))))
4361 bfd_signed_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
4365 (*_bfd_error_handler)
4366 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4367 abfd, sec, (unsigned long) sec->lma);
4370 p->p_memsz += adjust;
4372 if (this_hdr->sh_type != SHT_NOBITS)
4375 p->p_filesz += adjust;
4379 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4381 /* The section at i == 0 is the one that actually contains
4385 this_hdr->sh_offset = sec->filepos = off;
4386 off += this_hdr->sh_size;
4387 p->p_filesz = this_hdr->sh_size;
4393 /* The rest are fake sections that shouldn't be written. */
4402 if (p->p_type == PT_LOAD)
4404 this_hdr->sh_offset = sec->filepos = off;
4405 if (this_hdr->sh_type != SHT_NOBITS)
4406 off += this_hdr->sh_size;
4409 if (this_hdr->sh_type != SHT_NOBITS)
4411 p->p_filesz += this_hdr->sh_size;
4412 /* A load section without SHF_ALLOC is something like
4413 a note section in a PT_NOTE segment. These take
4414 file space but are not loaded into memory. */
4415 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4416 p->p_memsz += this_hdr->sh_size;
4418 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4420 if (p->p_type == PT_TLS)
4421 p->p_memsz += this_hdr->sh_size;
4423 /* .tbss is special. It doesn't contribute to p_memsz of
4425 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4426 p->p_memsz += this_hdr->sh_size;
4429 if (align > p->p_align
4430 && !m->p_align_valid
4431 && (p->p_type != PT_LOAD
4432 || (abfd->flags & D_PAGED) == 0))
4436 if (!m->p_flags_valid)
4439 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4441 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4447 /* Check that all sections are in a PT_LOAD segment.
4448 Don't check funky gdb generated core files. */
4449 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4450 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4452 Elf_Internal_Shdr *this_hdr;
4456 this_hdr = &(elf_section_data(sec)->this_hdr);
4457 if (this_hdr->sh_size != 0
4458 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4460 (*_bfd_error_handler)
4461 (_("%B: section `%A' can't be allocated in segment %d"),
4463 print_segment_map (m);
4464 bfd_set_error (bfd_error_bad_value);
4470 elf_tdata (abfd)->next_file_pos = off;
4474 /* Assign file positions for the other sections. */
4477 assign_file_positions_for_non_load_sections (bfd *abfd,
4478 struct bfd_link_info *link_info)
4480 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4481 Elf_Internal_Shdr **i_shdrpp;
4482 Elf_Internal_Shdr **hdrpp;
4483 Elf_Internal_Phdr *phdrs;
4484 Elf_Internal_Phdr *p;
4485 struct elf_segment_map *m;
4486 bfd_vma filehdr_vaddr, filehdr_paddr;
4487 bfd_vma phdrs_vaddr, phdrs_paddr;
4489 unsigned int num_sec;
4493 i_shdrpp = elf_elfsections (abfd);
4494 num_sec = elf_numsections (abfd);
4495 off = elf_tdata (abfd)->next_file_pos;
4496 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4498 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4499 Elf_Internal_Shdr *hdr;
4502 if (hdr->bfd_section != NULL
4503 && (hdr->bfd_section->filepos != 0
4504 || (hdr->sh_type == SHT_NOBITS
4505 && hdr->contents == NULL)))
4506 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4507 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4509 if (hdr->sh_size != 0)
4510 ((*_bfd_error_handler)
4511 (_("%B: warning: allocated section `%s' not in segment"),
4513 (hdr->bfd_section == NULL
4515 : hdr->bfd_section->name)));
4516 /* We don't need to page align empty sections. */
4517 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4518 off += vma_page_aligned_bias (hdr->sh_addr, off,
4521 off += vma_page_aligned_bias (hdr->sh_addr, off,
4523 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4526 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4527 && hdr->bfd_section == NULL)
4528 || hdr == i_shdrpp[tdata->symtab_section]
4529 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4530 || hdr == i_shdrpp[tdata->strtab_section])
4531 hdr->sh_offset = -1;
4533 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4536 /* Now that we have set the section file positions, we can set up
4537 the file positions for the non PT_LOAD segments. */
4541 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4543 phdrs = elf_tdata (abfd)->phdr;
4544 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4549 if (p->p_type != PT_LOAD)
4552 if (m->includes_filehdr)
4554 filehdr_vaddr = p->p_vaddr;
4555 filehdr_paddr = p->p_paddr;
4557 if (m->includes_phdrs)
4559 phdrs_vaddr = p->p_vaddr;
4560 phdrs_paddr = p->p_paddr;
4561 if (m->includes_filehdr)
4563 phdrs_vaddr += bed->s->sizeof_ehdr;
4564 phdrs_paddr += bed->s->sizeof_ehdr;
4569 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4575 if (p->p_type != PT_LOAD
4576 && (p->p_type != PT_NOTE
4577 || bfd_get_format (abfd) != bfd_core))
4579 Elf_Internal_Shdr *hdr;
4582 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4584 sect = m->sections[m->count - 1];
4585 hdr = &elf_section_data (sect)->this_hdr;
4586 p->p_filesz = sect->filepos - m->sections[0]->filepos;
4587 if (hdr->sh_type != SHT_NOBITS)
4588 p->p_filesz += hdr->sh_size;
4590 if (p->p_type == PT_GNU_RELRO)
4592 /* When we get here, we are copying executable
4593 or shared library. But we need to use the same
4595 Elf_Internal_Phdr *lp;
4597 for (lp = phdrs; lp < phdrs + count; ++lp)
4599 if (lp->p_type == PT_LOAD
4600 && lp->p_paddr == p->p_paddr)
4604 if (lp < phdrs + count)
4606 /* We should use p_size if it is valid since it
4607 may contain the first few bytes of the next
4608 SEC_ALLOC section. */
4609 if (m->p_size_valid)
4610 p->p_filesz = m->p_size;
4613 p->p_vaddr = lp->p_vaddr;
4614 p->p_offset = lp->p_offset;
4615 p->p_memsz = p->p_filesz;
4622 p->p_offset = m->sections[0]->filepos;
4627 if (m->includes_filehdr)
4629 p->p_vaddr = filehdr_vaddr;
4630 if (! m->p_paddr_valid)
4631 p->p_paddr = filehdr_paddr;
4633 else if (m->includes_phdrs)
4635 p->p_vaddr = phdrs_vaddr;
4636 if (! m->p_paddr_valid)
4637 p->p_paddr = phdrs_paddr;
4639 else if (p->p_type == PT_GNU_RELRO)
4641 Elf_Internal_Phdr *lp;
4643 for (lp = phdrs; lp < phdrs + count; ++lp)
4645 if (lp->p_type == PT_LOAD
4646 && lp->p_vaddr <= link_info->relro_end
4647 && lp->p_vaddr >= link_info->relro_start
4648 && (lp->p_vaddr + lp->p_filesz
4649 >= link_info->relro_end))
4653 if (lp < phdrs + count
4654 && link_info->relro_end > lp->p_vaddr)
4656 p->p_vaddr = lp->p_vaddr;
4657 p->p_paddr = lp->p_paddr;
4658 p->p_offset = lp->p_offset;
4659 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4660 p->p_memsz = p->p_filesz;
4662 p->p_flags = (lp->p_flags & ~PF_W);
4666 memset (p, 0, sizeof *p);
4667 p->p_type = PT_NULL;
4673 elf_tdata (abfd)->next_file_pos = off;
4678 /* Work out the file positions of all the sections. This is called by
4679 _bfd_elf_compute_section_file_positions. All the section sizes and
4680 VMAs must be known before this is called.
4682 Reloc sections come in two flavours: Those processed specially as
4683 "side-channel" data attached to a section to which they apply, and
4684 those that bfd doesn't process as relocations. The latter sort are
4685 stored in a normal bfd section by bfd_section_from_shdr. We don't
4686 consider the former sort here, unless they form part of the loadable
4687 image. Reloc sections not assigned here will be handled later by
4688 assign_file_positions_for_relocs.
4690 We also don't set the positions of the .symtab and .strtab here. */
4693 assign_file_positions_except_relocs (bfd *abfd,
4694 struct bfd_link_info *link_info)
4696 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4697 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4699 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4701 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4702 && bfd_get_format (abfd) != bfd_core)
4704 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4705 unsigned int num_sec = elf_numsections (abfd);
4706 Elf_Internal_Shdr **hdrpp;
4709 /* Start after the ELF header. */
4710 off = i_ehdrp->e_ehsize;
4712 /* We are not creating an executable, which means that we are
4713 not creating a program header, and that the actual order of
4714 the sections in the file is unimportant. */
4715 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4717 Elf_Internal_Shdr *hdr;
4720 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4721 && hdr->bfd_section == NULL)
4722 || i == tdata->symtab_section
4723 || i == tdata->symtab_shndx_section
4724 || i == tdata->strtab_section)
4726 hdr->sh_offset = -1;
4729 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4736 /* Assign file positions for the loaded sections based on the
4737 assignment of sections to segments. */
4738 if (!assign_file_positions_for_load_sections (abfd, link_info))
4741 /* And for non-load sections. */
4742 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4745 if (bed->elf_backend_modify_program_headers != NULL)
4747 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4751 /* Write out the program headers. */
4752 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4753 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4754 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
4757 off = tdata->next_file_pos;
4760 /* Place the section headers. */
4761 off = align_file_position (off, 1 << bed->s->log_file_align);
4762 i_ehdrp->e_shoff = off;
4763 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4765 tdata->next_file_pos = off;
4771 prep_headers (bfd *abfd)
4773 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4774 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4775 struct elf_strtab_hash *shstrtab;
4776 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4778 i_ehdrp = elf_elfheader (abfd);
4780 shstrtab = _bfd_elf_strtab_init ();
4781 if (shstrtab == NULL)
4784 elf_shstrtab (abfd) = shstrtab;
4786 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4787 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4788 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4789 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4791 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4792 i_ehdrp->e_ident[EI_DATA] =
4793 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4794 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4796 if ((abfd->flags & DYNAMIC) != 0)
4797 i_ehdrp->e_type = ET_DYN;
4798 else if ((abfd->flags & EXEC_P) != 0)
4799 i_ehdrp->e_type = ET_EXEC;
4800 else if (bfd_get_format (abfd) == bfd_core)
4801 i_ehdrp->e_type = ET_CORE;
4803 i_ehdrp->e_type = ET_REL;
4805 switch (bfd_get_arch (abfd))
4807 case bfd_arch_unknown:
4808 i_ehdrp->e_machine = EM_NONE;
4811 /* There used to be a long list of cases here, each one setting
4812 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4813 in the corresponding bfd definition. To avoid duplication,
4814 the switch was removed. Machines that need special handling
4815 can generally do it in elf_backend_final_write_processing(),
4816 unless they need the information earlier than the final write.
4817 Such need can generally be supplied by replacing the tests for
4818 e_machine with the conditions used to determine it. */
4820 i_ehdrp->e_machine = bed->elf_machine_code;
4823 i_ehdrp->e_version = bed->s->ev_current;
4824 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4826 /* No program header, for now. */
4827 i_ehdrp->e_phoff = 0;
4828 i_ehdrp->e_phentsize = 0;
4829 i_ehdrp->e_phnum = 0;
4831 /* Each bfd section is section header entry. */
4832 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4833 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4835 /* If we're building an executable, we'll need a program header table. */
4836 if (abfd->flags & EXEC_P)
4837 /* It all happens later. */
4841 i_ehdrp->e_phentsize = 0;
4843 i_ehdrp->e_phoff = 0;
4846 elf_tdata (abfd)->symtab_hdr.sh_name =
4847 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
4848 elf_tdata (abfd)->strtab_hdr.sh_name =
4849 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
4850 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4851 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
4852 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4853 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4854 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4860 /* Assign file positions for all the reloc sections which are not part
4861 of the loadable file image. */
4864 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
4867 unsigned int i, num_sec;
4868 Elf_Internal_Shdr **shdrpp;
4870 off = elf_tdata (abfd)->next_file_pos;
4872 num_sec = elf_numsections (abfd);
4873 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4875 Elf_Internal_Shdr *shdrp;
4878 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4879 && shdrp->sh_offset == -1)
4880 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
4883 elf_tdata (abfd)->next_file_pos = off;
4887 _bfd_elf_write_object_contents (bfd *abfd)
4889 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4890 Elf_Internal_Ehdr *i_ehdrp;
4891 Elf_Internal_Shdr **i_shdrp;
4893 unsigned int count, num_sec;
4895 if (! abfd->output_has_begun
4896 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
4899 i_shdrp = elf_elfsections (abfd);
4900 i_ehdrp = elf_elfheader (abfd);
4903 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4907 _bfd_elf_assign_file_positions_for_relocs (abfd);
4909 /* After writing the headers, we need to write the sections too... */
4910 num_sec = elf_numsections (abfd);
4911 for (count = 1; count < num_sec; count++)
4913 if (bed->elf_backend_section_processing)
4914 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4915 if (i_shdrp[count]->contents)
4917 bfd_size_type amt = i_shdrp[count]->sh_size;
4919 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4920 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4925 /* Write out the section header names. */
4926 if (elf_shstrtab (abfd) != NULL
4927 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4928 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
4931 if (bed->elf_backend_final_write_processing)
4932 (*bed->elf_backend_final_write_processing) (abfd,
4933 elf_tdata (abfd)->linker);
4935 if (!bed->s->write_shdrs_and_ehdr (abfd))
4938 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
4939 if (elf_tdata (abfd)->after_write_object_contents)
4940 return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
4946 _bfd_elf_write_corefile_contents (bfd *abfd)
4948 /* Hopefully this can be done just like an object file. */
4949 return _bfd_elf_write_object_contents (abfd);
4952 /* Given a section, search the header to find them. */
4955 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
4957 const struct elf_backend_data *bed;
4960 if (elf_section_data (asect) != NULL
4961 && elf_section_data (asect)->this_idx != 0)
4962 return elf_section_data (asect)->this_idx;
4964 if (bfd_is_abs_section (asect))
4966 else if (bfd_is_com_section (asect))
4968 else if (bfd_is_und_section (asect))
4973 bed = get_elf_backend_data (abfd);
4974 if (bed->elf_backend_section_from_bfd_section)
4978 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4982 if (index == SHN_BAD)
4983 bfd_set_error (bfd_error_nonrepresentable_section);
4988 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4992 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
4994 asymbol *asym_ptr = *asym_ptr_ptr;
4996 flagword flags = asym_ptr->flags;
4998 /* When gas creates relocations against local labels, it creates its
4999 own symbol for the section, but does put the symbol into the
5000 symbol chain, so udata is 0. When the linker is generating
5001 relocatable output, this section symbol may be for one of the
5002 input sections rather than the output section. */
5003 if (asym_ptr->udata.i == 0
5004 && (flags & BSF_SECTION_SYM)
5005 && asym_ptr->section)
5010 sec = asym_ptr->section;
5011 if (sec->owner != abfd && sec->output_section != NULL)
5012 sec = sec->output_section;
5013 if (sec->owner == abfd
5014 && (indx = sec->index) < elf_num_section_syms (abfd)
5015 && elf_section_syms (abfd)[indx] != NULL)
5016 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5019 idx = asym_ptr->udata.i;
5023 /* This case can occur when using --strip-symbol on a symbol
5024 which is used in a relocation entry. */
5025 (*_bfd_error_handler)
5026 (_("%B: symbol `%s' required but not present"),
5027 abfd, bfd_asymbol_name (asym_ptr));
5028 bfd_set_error (bfd_error_no_symbols);
5035 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
5036 (long) asym_ptr, asym_ptr->name, idx, flags,
5037 elf_symbol_flags (flags));
5045 /* Rewrite program header information. */
5048 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5050 Elf_Internal_Ehdr *iehdr;
5051 struct elf_segment_map *map;
5052 struct elf_segment_map *map_first;
5053 struct elf_segment_map **pointer_to_map;
5054 Elf_Internal_Phdr *segment;
5057 unsigned int num_segments;
5058 bfd_boolean phdr_included = FALSE;
5059 bfd_boolean p_paddr_valid;
5060 bfd_vma maxpagesize;
5061 struct elf_segment_map *phdr_adjust_seg = NULL;
5062 unsigned int phdr_adjust_num = 0;
5063 const struct elf_backend_data *bed;
5065 bed = get_elf_backend_data (ibfd);
5066 iehdr = elf_elfheader (ibfd);
5069 pointer_to_map = &map_first;
5071 num_segments = elf_elfheader (ibfd)->e_phnum;
5072 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5074 /* Returns the end address of the segment + 1. */
5075 #define SEGMENT_END(segment, start) \
5076 (start + (segment->p_memsz > segment->p_filesz \
5077 ? segment->p_memsz : segment->p_filesz))
5079 #define SECTION_SIZE(section, segment) \
5080 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5081 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5082 ? section->size : 0)
5084 /* Returns TRUE if the given section is contained within
5085 the given segment. VMA addresses are compared. */
5086 #define IS_CONTAINED_BY_VMA(section, segment) \
5087 (section->vma >= segment->p_vaddr \
5088 && (section->vma + SECTION_SIZE (section, segment) \
5089 <= (SEGMENT_END (segment, segment->p_vaddr))))
5091 /* Returns TRUE if the given section is contained within
5092 the given segment. LMA addresses are compared. */
5093 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5094 (section->lma >= base \
5095 && (section->lma + SECTION_SIZE (section, segment) \
5096 <= SEGMENT_END (segment, base)))
5098 /* Handle PT_NOTE segment. */
5099 #define IS_NOTE(p, s) \
5100 (p->p_type == PT_NOTE \
5101 && elf_section_type (s) == SHT_NOTE \
5102 && (bfd_vma) s->filepos >= p->p_offset \
5103 && ((bfd_vma) s->filepos + s->size \
5104 <= p->p_offset + p->p_filesz))
5106 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5108 #define IS_COREFILE_NOTE(p, s) \
5110 && bfd_get_format (ibfd) == bfd_core \
5114 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5115 linker, which generates a PT_INTERP section with p_vaddr and
5116 p_memsz set to 0. */
5117 #define IS_SOLARIS_PT_INTERP(p, s) \
5119 && p->p_paddr == 0 \
5120 && p->p_memsz == 0 \
5121 && p->p_filesz > 0 \
5122 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5124 && (bfd_vma) s->filepos >= p->p_offset \
5125 && ((bfd_vma) s->filepos + s->size \
5126 <= p->p_offset + p->p_filesz))
5128 /* Decide if the given section should be included in the given segment.
5129 A section will be included if:
5130 1. It is within the address space of the segment -- we use the LMA
5131 if that is set for the segment and the VMA otherwise,
5132 2. It is an allocated section or a NOTE section in a PT_NOTE
5134 3. There is an output section associated with it,
5135 4. The section has not already been allocated to a previous segment.
5136 5. PT_GNU_STACK segments do not include any sections.
5137 6. PT_TLS segment includes only SHF_TLS sections.
5138 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5139 8. PT_DYNAMIC should not contain empty sections at the beginning
5140 (with the possible exception of .dynamic). */
5141 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5142 ((((segment->p_paddr \
5143 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5144 : IS_CONTAINED_BY_VMA (section, segment)) \
5145 && (section->flags & SEC_ALLOC) != 0) \
5146 || IS_NOTE (segment, section)) \
5147 && segment->p_type != PT_GNU_STACK \
5148 && (segment->p_type != PT_TLS \
5149 || (section->flags & SEC_THREAD_LOCAL)) \
5150 && (segment->p_type == PT_LOAD \
5151 || segment->p_type == PT_TLS \
5152 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5153 && (segment->p_type != PT_DYNAMIC \
5154 || SECTION_SIZE (section, segment) > 0 \
5155 || (segment->p_paddr \
5156 ? segment->p_paddr != section->lma \
5157 : segment->p_vaddr != section->vma) \
5158 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5160 && !section->segment_mark)
5162 /* If the output section of a section in the input segment is NULL,
5163 it is removed from the corresponding output segment. */
5164 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5165 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5166 && section->output_section != NULL)
5168 /* Returns TRUE iff seg1 starts after the end of seg2. */
5169 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5170 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5172 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5173 their VMA address ranges and their LMA address ranges overlap.
5174 It is possible to have overlapping VMA ranges without overlapping LMA
5175 ranges. RedBoot images for example can have both .data and .bss mapped
5176 to the same VMA range, but with the .data section mapped to a different
5178 #define SEGMENT_OVERLAPS(seg1, seg2) \
5179 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5180 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5181 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5182 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5184 /* Initialise the segment mark field. */
5185 for (section = ibfd->sections; section != NULL; section = section->next)
5186 section->segment_mark = FALSE;
5188 /* The Solaris linker creates program headers in which all the
5189 p_paddr fields are zero. When we try to objcopy or strip such a
5190 file, we get confused. Check for this case, and if we find it
5191 don't set the p_paddr_valid fields. */
5192 p_paddr_valid = FALSE;
5193 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5196 if (segment->p_paddr != 0)
5198 p_paddr_valid = TRUE;
5202 /* Scan through the segments specified in the program header
5203 of the input BFD. For this first scan we look for overlaps
5204 in the loadable segments. These can be created by weird
5205 parameters to objcopy. Also, fix some solaris weirdness. */
5206 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5211 Elf_Internal_Phdr *segment2;
5213 if (segment->p_type == PT_INTERP)
5214 for (section = ibfd->sections; section; section = section->next)
5215 if (IS_SOLARIS_PT_INTERP (segment, section))
5217 /* Mininal change so that the normal section to segment
5218 assignment code will work. */
5219 segment->p_vaddr = section->vma;
5223 if (segment->p_type != PT_LOAD)
5225 /* Remove PT_GNU_RELRO segment. */
5226 if (segment->p_type == PT_GNU_RELRO)
5227 segment->p_type = PT_NULL;
5231 /* Determine if this segment overlaps any previous segments. */
5232 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5234 bfd_signed_vma extra_length;
5236 if (segment2->p_type != PT_LOAD
5237 || !SEGMENT_OVERLAPS (segment, segment2))
5240 /* Merge the two segments together. */
5241 if (segment2->p_vaddr < segment->p_vaddr)
5243 /* Extend SEGMENT2 to include SEGMENT and then delete
5245 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5246 - SEGMENT_END (segment2, segment2->p_vaddr));
5248 if (extra_length > 0)
5250 segment2->p_memsz += extra_length;
5251 segment2->p_filesz += extra_length;
5254 segment->p_type = PT_NULL;
5256 /* Since we have deleted P we must restart the outer loop. */
5258 segment = elf_tdata (ibfd)->phdr;
5263 /* Extend SEGMENT to include SEGMENT2 and then delete
5265 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5266 - SEGMENT_END (segment, segment->p_vaddr));
5268 if (extra_length > 0)
5270 segment->p_memsz += extra_length;
5271 segment->p_filesz += extra_length;
5274 segment2->p_type = PT_NULL;
5279 /* The second scan attempts to assign sections to segments. */
5280 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5284 unsigned int section_count;
5285 asection **sections;
5286 asection *output_section;
5288 bfd_vma matching_lma;
5289 bfd_vma suggested_lma;
5292 asection *first_section;
5293 bfd_boolean first_matching_lma;
5294 bfd_boolean first_suggested_lma;
5296 if (segment->p_type == PT_NULL)
5299 first_section = NULL;
5300 /* Compute how many sections might be placed into this segment. */
5301 for (section = ibfd->sections, section_count = 0;
5303 section = section->next)
5305 /* Find the first section in the input segment, which may be
5306 removed from the corresponding output segment. */
5307 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5309 if (first_section == NULL)
5310 first_section = section;
5311 if (section->output_section != NULL)
5316 /* Allocate a segment map big enough to contain
5317 all of the sections we have selected. */
5318 amt = sizeof (struct elf_segment_map);
5319 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5320 map = bfd_zalloc (obfd, amt);
5324 /* Initialise the fields of the segment map. Default to
5325 using the physical address of the segment in the input BFD. */
5327 map->p_type = segment->p_type;
5328 map->p_flags = segment->p_flags;
5329 map->p_flags_valid = 1;
5331 /* If the first section in the input segment is removed, there is
5332 no need to preserve segment physical address in the corresponding
5334 if (!first_section || first_section->output_section != NULL)
5336 map->p_paddr = segment->p_paddr;
5337 map->p_paddr_valid = p_paddr_valid;
5340 /* Determine if this segment contains the ELF file header
5341 and if it contains the program headers themselves. */
5342 map->includes_filehdr = (segment->p_offset == 0
5343 && segment->p_filesz >= iehdr->e_ehsize);
5344 map->includes_phdrs = 0;
5346 if (!phdr_included || segment->p_type != PT_LOAD)
5348 map->includes_phdrs =
5349 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5350 && (segment->p_offset + segment->p_filesz
5351 >= ((bfd_vma) iehdr->e_phoff
5352 + iehdr->e_phnum * iehdr->e_phentsize)));
5354 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5355 phdr_included = TRUE;
5358 if (section_count == 0)
5360 /* Special segments, such as the PT_PHDR segment, may contain
5361 no sections, but ordinary, loadable segments should contain
5362 something. They are allowed by the ELF spec however, so only
5363 a warning is produced. */
5364 if (segment->p_type == PT_LOAD)
5365 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5366 " detected, is this intentional ?\n"),
5370 *pointer_to_map = map;
5371 pointer_to_map = &map->next;
5376 /* Now scan the sections in the input BFD again and attempt
5377 to add their corresponding output sections to the segment map.
5378 The problem here is how to handle an output section which has
5379 been moved (ie had its LMA changed). There are four possibilities:
5381 1. None of the sections have been moved.
5382 In this case we can continue to use the segment LMA from the
5385 2. All of the sections have been moved by the same amount.
5386 In this case we can change the segment's LMA to match the LMA
5387 of the first section.
5389 3. Some of the sections have been moved, others have not.
5390 In this case those sections which have not been moved can be
5391 placed in the current segment which will have to have its size,
5392 and possibly its LMA changed, and a new segment or segments will
5393 have to be created to contain the other sections.
5395 4. The sections have been moved, but not by the same amount.
5396 In this case we can change the segment's LMA to match the LMA
5397 of the first section and we will have to create a new segment
5398 or segments to contain the other sections.
5400 In order to save time, we allocate an array to hold the section
5401 pointers that we are interested in. As these sections get assigned
5402 to a segment, they are removed from this array. */
5404 sections = bfd_malloc2 (section_count, sizeof (asection *));
5405 if (sections == NULL)
5408 /* Step One: Scan for segment vs section LMA conflicts.
5409 Also add the sections to the section array allocated above.
5410 Also add the sections to the current segment. In the common
5411 case, where the sections have not been moved, this means that
5412 we have completely filled the segment, and there is nothing
5417 first_matching_lma = TRUE;
5418 first_suggested_lma = TRUE;
5420 for (section = ibfd->sections;
5422 section = section->next)
5423 if (section == first_section)
5426 for (j = 0; section != NULL; section = section->next)
5428 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5430 output_section = section->output_section;
5432 sections[j++] = section;
5434 /* The Solaris native linker always sets p_paddr to 0.
5435 We try to catch that case here, and set it to the
5436 correct value. Note - some backends require that
5437 p_paddr be left as zero. */
5439 && segment->p_vaddr != 0
5440 && !bed->want_p_paddr_set_to_zero
5442 && output_section->lma != 0
5443 && output_section->vma == (segment->p_vaddr
5444 + (map->includes_filehdr
5447 + (map->includes_phdrs
5449 * iehdr->e_phentsize)
5451 map->p_paddr = segment->p_vaddr;
5453 /* Match up the physical address of the segment with the
5454 LMA address of the output section. */
5455 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5456 || IS_COREFILE_NOTE (segment, section)
5457 || (bed->want_p_paddr_set_to_zero
5458 && IS_CONTAINED_BY_VMA (output_section, segment)))
5460 if (first_matching_lma || output_section->lma < matching_lma)
5462 matching_lma = output_section->lma;
5463 first_matching_lma = FALSE;
5466 /* We assume that if the section fits within the segment
5467 then it does not overlap any other section within that
5469 map->sections[isec++] = output_section;
5471 else if (first_suggested_lma)
5473 suggested_lma = output_section->lma;
5474 first_suggested_lma = FALSE;
5477 if (j == section_count)
5482 BFD_ASSERT (j == section_count);
5484 /* Step Two: Adjust the physical address of the current segment,
5486 if (isec == section_count)
5488 /* All of the sections fitted within the segment as currently
5489 specified. This is the default case. Add the segment to
5490 the list of built segments and carry on to process the next
5491 program header in the input BFD. */
5492 map->count = section_count;
5493 *pointer_to_map = map;
5494 pointer_to_map = &map->next;
5497 && !bed->want_p_paddr_set_to_zero
5498 && matching_lma != map->p_paddr
5499 && !map->includes_filehdr
5500 && !map->includes_phdrs)
5501 /* There is some padding before the first section in the
5502 segment. So, we must account for that in the output
5504 map->p_vaddr_offset = matching_lma - map->p_paddr;
5511 if (!first_matching_lma)
5513 /* At least one section fits inside the current segment.
5514 Keep it, but modify its physical address to match the
5515 LMA of the first section that fitted. */
5516 map->p_paddr = matching_lma;
5520 /* None of the sections fitted inside the current segment.
5521 Change the current segment's physical address to match
5522 the LMA of the first section. */
5523 map->p_paddr = suggested_lma;
5526 /* Offset the segment physical address from the lma
5527 to allow for space taken up by elf headers. */
5528 if (map->includes_filehdr)
5529 map->p_paddr -= iehdr->e_ehsize;
5531 if (map->includes_phdrs)
5533 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5535 /* iehdr->e_phnum is just an estimate of the number
5536 of program headers that we will need. Make a note
5537 here of the number we used and the segment we chose
5538 to hold these headers, so that we can adjust the
5539 offset when we know the correct value. */
5540 phdr_adjust_num = iehdr->e_phnum;
5541 phdr_adjust_seg = map;
5545 /* Step Three: Loop over the sections again, this time assigning
5546 those that fit to the current segment and removing them from the
5547 sections array; but making sure not to leave large gaps. Once all
5548 possible sections have been assigned to the current segment it is
5549 added to the list of built segments and if sections still remain
5550 to be assigned, a new segment is constructed before repeating
5557 first_suggested_lma = TRUE;
5559 /* Fill the current segment with sections that fit. */
5560 for (j = 0; j < section_count; j++)
5562 section = sections[j];
5564 if (section == NULL)
5567 output_section = section->output_section;
5569 BFD_ASSERT (output_section != NULL);
5571 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5572 || IS_COREFILE_NOTE (segment, section))
5574 if (map->count == 0)
5576 /* If the first section in a segment does not start at
5577 the beginning of the segment, then something is
5579 if (output_section->lma
5581 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5582 + (map->includes_phdrs
5583 ? iehdr->e_phnum * iehdr->e_phentsize
5591 prev_sec = map->sections[map->count - 1];
5593 /* If the gap between the end of the previous section
5594 and the start of this section is more than
5595 maxpagesize then we need to start a new segment. */
5596 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5598 < BFD_ALIGN (output_section->lma, maxpagesize))
5599 || (prev_sec->lma + prev_sec->size
5600 > output_section->lma))
5602 if (first_suggested_lma)
5604 suggested_lma = output_section->lma;
5605 first_suggested_lma = FALSE;
5612 map->sections[map->count++] = output_section;
5615 section->segment_mark = TRUE;
5617 else if (first_suggested_lma)
5619 suggested_lma = output_section->lma;
5620 first_suggested_lma = FALSE;
5624 BFD_ASSERT (map->count > 0);
5626 /* Add the current segment to the list of built segments. */
5627 *pointer_to_map = map;
5628 pointer_to_map = &map->next;
5630 if (isec < section_count)
5632 /* We still have not allocated all of the sections to
5633 segments. Create a new segment here, initialise it
5634 and carry on looping. */
5635 amt = sizeof (struct elf_segment_map);
5636 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5637 map = bfd_alloc (obfd, amt);
5644 /* Initialise the fields of the segment map. Set the physical
5645 physical address to the LMA of the first section that has
5646 not yet been assigned. */
5648 map->p_type = segment->p_type;
5649 map->p_flags = segment->p_flags;
5650 map->p_flags_valid = 1;
5651 map->p_paddr = suggested_lma;
5652 map->p_paddr_valid = p_paddr_valid;
5653 map->includes_filehdr = 0;
5654 map->includes_phdrs = 0;
5657 while (isec < section_count);
5662 elf_tdata (obfd)->segment_map = map_first;
5664 /* If we had to estimate the number of program headers that were
5665 going to be needed, then check our estimate now and adjust
5666 the offset if necessary. */
5667 if (phdr_adjust_seg != NULL)
5671 for (count = 0, map = map_first; map != NULL; map = map->next)
5674 if (count > phdr_adjust_num)
5675 phdr_adjust_seg->p_paddr
5676 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5681 #undef IS_CONTAINED_BY_VMA
5682 #undef IS_CONTAINED_BY_LMA
5684 #undef IS_COREFILE_NOTE
5685 #undef IS_SOLARIS_PT_INTERP
5686 #undef IS_SECTION_IN_INPUT_SEGMENT
5687 #undef INCLUDE_SECTION_IN_SEGMENT
5688 #undef SEGMENT_AFTER_SEGMENT
5689 #undef SEGMENT_OVERLAPS
5693 /* Copy ELF program header information. */
5696 copy_elf_program_header (bfd *ibfd, bfd *obfd)
5698 Elf_Internal_Ehdr *iehdr;
5699 struct elf_segment_map *map;
5700 struct elf_segment_map *map_first;
5701 struct elf_segment_map **pointer_to_map;
5702 Elf_Internal_Phdr *segment;
5704 unsigned int num_segments;
5705 bfd_boolean phdr_included = FALSE;
5706 bfd_boolean p_paddr_valid;
5708 iehdr = elf_elfheader (ibfd);
5711 pointer_to_map = &map_first;
5713 /* If all the segment p_paddr fields are zero, don't set
5714 map->p_paddr_valid. */
5715 p_paddr_valid = FALSE;
5716 num_segments = elf_elfheader (ibfd)->e_phnum;
5717 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5720 if (segment->p_paddr != 0)
5722 p_paddr_valid = TRUE;
5726 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5731 unsigned int section_count;
5733 Elf_Internal_Shdr *this_hdr;
5734 asection *first_section = NULL;
5735 asection *lowest_section = NULL;
5737 /* Compute how many sections are in this segment. */
5738 for (section = ibfd->sections, section_count = 0;
5740 section = section->next)
5742 this_hdr = &(elf_section_data(section)->this_hdr);
5743 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5746 first_section = lowest_section = section;
5747 if (section->lma < lowest_section->lma)
5748 lowest_section = section;
5753 /* Allocate a segment map big enough to contain
5754 all of the sections we have selected. */
5755 amt = sizeof (struct elf_segment_map);
5756 if (section_count != 0)
5757 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5758 map = bfd_zalloc (obfd, amt);
5762 /* Initialize the fields of the output segment map with the
5765 map->p_type = segment->p_type;
5766 map->p_flags = segment->p_flags;
5767 map->p_flags_valid = 1;
5768 map->p_paddr = segment->p_paddr;
5769 map->p_paddr_valid = p_paddr_valid;
5770 map->p_align = segment->p_align;
5771 map->p_align_valid = 1;
5772 map->p_vaddr_offset = 0;
5774 if (map->p_type == PT_GNU_RELRO
5775 && segment->p_filesz == segment->p_memsz)
5777 /* The PT_GNU_RELRO segment may contain the first a few
5778 bytes in the .got.plt section even if the whole .got.plt
5779 section isn't in the PT_GNU_RELRO segment. We won't
5780 change the size of the PT_GNU_RELRO segment. */
5781 map->p_size = segment->p_filesz;
5782 map->p_size_valid = 1;
5785 /* Determine if this segment contains the ELF file header
5786 and if it contains the program headers themselves. */
5787 map->includes_filehdr = (segment->p_offset == 0
5788 && segment->p_filesz >= iehdr->e_ehsize);
5790 map->includes_phdrs = 0;
5791 if (! phdr_included || segment->p_type != PT_LOAD)
5793 map->includes_phdrs =
5794 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5795 && (segment->p_offset + segment->p_filesz
5796 >= ((bfd_vma) iehdr->e_phoff
5797 + iehdr->e_phnum * iehdr->e_phentsize)));
5799 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5800 phdr_included = TRUE;
5803 if (!map->includes_phdrs
5804 && !map->includes_filehdr
5805 && map->p_paddr_valid)
5806 /* There is some other padding before the first section. */
5807 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
5808 - segment->p_paddr);
5810 if (section_count != 0)
5812 unsigned int isec = 0;
5814 for (section = first_section;
5816 section = section->next)
5818 this_hdr = &(elf_section_data(section)->this_hdr);
5819 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5821 map->sections[isec++] = section->output_section;
5822 if (isec == section_count)
5828 map->count = section_count;
5829 *pointer_to_map = map;
5830 pointer_to_map = &map->next;
5833 elf_tdata (obfd)->segment_map = map_first;
5837 /* Copy private BFD data. This copies or rewrites ELF program header
5841 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5843 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5844 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5847 if (elf_tdata (ibfd)->phdr == NULL)
5850 if (ibfd->xvec == obfd->xvec)
5852 /* Check to see if any sections in the input BFD
5853 covered by ELF program header have changed. */
5854 Elf_Internal_Phdr *segment;
5855 asection *section, *osec;
5856 unsigned int i, num_segments;
5857 Elf_Internal_Shdr *this_hdr;
5858 const struct elf_backend_data *bed;
5860 bed = get_elf_backend_data (ibfd);
5862 /* Regenerate the segment map if p_paddr is set to 0. */
5863 if (bed->want_p_paddr_set_to_zero)
5866 /* Initialize the segment mark field. */
5867 for (section = obfd->sections; section != NULL;
5868 section = section->next)
5869 section->segment_mark = FALSE;
5871 num_segments = elf_elfheader (ibfd)->e_phnum;
5872 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5876 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5877 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5878 which severly confuses things, so always regenerate the segment
5879 map in this case. */
5880 if (segment->p_paddr == 0
5881 && segment->p_memsz == 0
5882 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
5885 for (section = ibfd->sections;
5886 section != NULL; section = section->next)
5888 /* We mark the output section so that we know it comes
5889 from the input BFD. */
5890 osec = section->output_section;
5892 osec->segment_mark = TRUE;
5894 /* Check if this section is covered by the segment. */
5895 this_hdr = &(elf_section_data(section)->this_hdr);
5896 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5898 /* FIXME: Check if its output section is changed or
5899 removed. What else do we need to check? */
5901 || section->flags != osec->flags
5902 || section->lma != osec->lma
5903 || section->vma != osec->vma
5904 || section->size != osec->size
5905 || section->rawsize != osec->rawsize
5906 || section->alignment_power != osec->alignment_power)
5912 /* Check to see if any output section do not come from the
5914 for (section = obfd->sections; section != NULL;
5915 section = section->next)
5917 if (section->segment_mark == FALSE)
5920 section->segment_mark = FALSE;
5923 return copy_elf_program_header (ibfd, obfd);
5927 return rewrite_elf_program_header (ibfd, obfd);
5930 /* Initialize private output section information from input section. */
5933 _bfd_elf_init_private_section_data (bfd *ibfd,
5937 struct bfd_link_info *link_info)
5940 Elf_Internal_Shdr *ihdr, *ohdr;
5941 bfd_boolean need_group = link_info == NULL || link_info->relocatable;
5943 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5944 || obfd->xvec->flavour != bfd_target_elf_flavour)
5947 /* Don't copy the output ELF section type from input if the
5948 output BFD section flags have been set to something different.
5949 elf_fake_sections will set ELF section type based on BFD
5951 if (elf_section_type (osec) == SHT_NULL
5952 && (osec->flags == isec->flags || !osec->flags))
5953 elf_section_type (osec) = elf_section_type (isec);
5955 /* FIXME: Is this correct for all OS/PROC specific flags? */
5956 elf_section_flags (osec) |= (elf_section_flags (isec)
5957 & (SHF_MASKOS | SHF_MASKPROC));
5959 /* Set things up for objcopy and relocatable link. The output
5960 SHT_GROUP section will have its elf_next_in_group pointing back
5961 to the input group members. Ignore linker created group section.
5962 See elfNN_ia64_object_p in elfxx-ia64.c. */
5965 if (elf_sec_group (isec) == NULL
5966 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5968 if (elf_section_flags (isec) & SHF_GROUP)
5969 elf_section_flags (osec) |= SHF_GROUP;
5970 elf_next_in_group (osec) = elf_next_in_group (isec);
5971 elf_group_name (osec) = elf_group_name (isec);
5975 ihdr = &elf_section_data (isec)->this_hdr;
5977 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
5978 don't use the output section of the linked-to section since it
5979 may be NULL at this point. */
5980 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
5982 ohdr = &elf_section_data (osec)->this_hdr;
5983 ohdr->sh_flags |= SHF_LINK_ORDER;
5984 elf_linked_to_section (osec) = elf_linked_to_section (isec);
5987 osec->use_rela_p = isec->use_rela_p;
5992 /* Copy private section information. This copies over the entsize
5993 field, and sometimes the info field. */
5996 _bfd_elf_copy_private_section_data (bfd *ibfd,
6001 Elf_Internal_Shdr *ihdr, *ohdr;
6003 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6004 || obfd->xvec->flavour != bfd_target_elf_flavour)
6007 ihdr = &elf_section_data (isec)->this_hdr;
6008 ohdr = &elf_section_data (osec)->this_hdr;
6010 ohdr->sh_entsize = ihdr->sh_entsize;
6012 if (ihdr->sh_type == SHT_SYMTAB
6013 || ihdr->sh_type == SHT_DYNSYM
6014 || ihdr->sh_type == SHT_GNU_verneed
6015 || ihdr->sh_type == SHT_GNU_verdef)
6016 ohdr->sh_info = ihdr->sh_info;
6018 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6022 /* Copy private header information. */
6025 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6029 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6030 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6033 /* Copy over private BFD data if it has not already been copied.
6034 This must be done here, rather than in the copy_private_bfd_data
6035 entry point, because the latter is called after the section
6036 contents have been set, which means that the program headers have
6037 already been worked out. */
6038 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6040 if (! copy_private_bfd_data (ibfd, obfd))
6044 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6045 but this might be wrong if we deleted the group section. */
6046 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6047 if (elf_section_type (isec) == SHT_GROUP
6048 && isec->output_section == NULL)
6050 asection *first = elf_next_in_group (isec);
6051 asection *s = first;
6054 if (s->output_section != NULL)
6056 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6057 elf_group_name (s->output_section) = NULL;
6059 s = elf_next_in_group (s);
6068 /* Copy private symbol information. If this symbol is in a section
6069 which we did not map into a BFD section, try to map the section
6070 index correctly. We use special macro definitions for the mapped
6071 section indices; these definitions are interpreted by the
6072 swap_out_syms function. */
6074 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6075 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6076 #define MAP_STRTAB (SHN_HIOS + 3)
6077 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6078 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6081 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6086 elf_symbol_type *isym, *osym;
6088 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6089 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6092 isym = elf_symbol_from (ibfd, isymarg);
6093 osym = elf_symbol_from (obfd, osymarg);
6096 && isym->internal_elf_sym.st_shndx != 0
6098 && bfd_is_abs_section (isym->symbol.section))
6102 shndx = isym->internal_elf_sym.st_shndx;
6103 if (shndx == elf_onesymtab (ibfd))
6104 shndx = MAP_ONESYMTAB;
6105 else if (shndx == elf_dynsymtab (ibfd))
6106 shndx = MAP_DYNSYMTAB;
6107 else if (shndx == elf_tdata (ibfd)->strtab_section)
6109 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6110 shndx = MAP_SHSTRTAB;
6111 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6112 shndx = MAP_SYM_SHNDX;
6113 osym->internal_elf_sym.st_shndx = shndx;
6119 /* Swap out the symbols. */
6122 swap_out_syms (bfd *abfd,
6123 struct bfd_strtab_hash **sttp,
6126 const struct elf_backend_data *bed;
6129 struct bfd_strtab_hash *stt;
6130 Elf_Internal_Shdr *symtab_hdr;
6131 Elf_Internal_Shdr *symtab_shndx_hdr;
6132 Elf_Internal_Shdr *symstrtab_hdr;
6133 bfd_byte *outbound_syms;
6134 bfd_byte *outbound_shndx;
6137 bfd_boolean name_local_sections;
6139 if (!elf_map_symbols (abfd))
6142 /* Dump out the symtabs. */
6143 stt = _bfd_elf_stringtab_init ();
6147 bed = get_elf_backend_data (abfd);
6148 symcount = bfd_get_symcount (abfd);
6149 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6150 symtab_hdr->sh_type = SHT_SYMTAB;
6151 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6152 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6153 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6154 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6156 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6157 symstrtab_hdr->sh_type = SHT_STRTAB;
6159 outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
6160 if (outbound_syms == NULL)
6162 _bfd_stringtab_free (stt);
6165 symtab_hdr->contents = outbound_syms;
6167 outbound_shndx = NULL;
6168 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6169 if (symtab_shndx_hdr->sh_name != 0)
6171 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6172 outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6173 sizeof (Elf_External_Sym_Shndx));
6174 if (outbound_shndx == NULL)
6176 _bfd_stringtab_free (stt);
6180 symtab_shndx_hdr->contents = outbound_shndx;
6181 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6182 symtab_shndx_hdr->sh_size = amt;
6183 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6184 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6187 /* Now generate the data (for "contents"). */
6189 /* Fill in zeroth symbol and swap it out. */
6190 Elf_Internal_Sym sym;
6196 sym.st_shndx = SHN_UNDEF;
6197 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6198 outbound_syms += bed->s->sizeof_sym;
6199 if (outbound_shndx != NULL)
6200 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6204 = (bed->elf_backend_name_local_section_symbols
6205 && bed->elf_backend_name_local_section_symbols (abfd));
6207 syms = bfd_get_outsymbols (abfd);
6208 for (idx = 0; idx < symcount; idx++)
6210 Elf_Internal_Sym sym;
6211 bfd_vma value = syms[idx]->value;
6212 elf_symbol_type *type_ptr;
6213 flagword flags = syms[idx]->flags;
6216 if (!name_local_sections
6217 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6219 /* Local section symbols have no name. */
6224 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6227 if (sym.st_name == (unsigned long) -1)
6229 _bfd_stringtab_free (stt);
6234 type_ptr = elf_symbol_from (abfd, syms[idx]);
6236 if ((flags & BSF_SECTION_SYM) == 0
6237 && bfd_is_com_section (syms[idx]->section))
6239 /* ELF common symbols put the alignment into the `value' field,
6240 and the size into the `size' field. This is backwards from
6241 how BFD handles it, so reverse it here. */
6242 sym.st_size = value;
6243 if (type_ptr == NULL
6244 || type_ptr->internal_elf_sym.st_value == 0)
6245 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6247 sym.st_value = type_ptr->internal_elf_sym.st_value;
6248 sym.st_shndx = _bfd_elf_section_from_bfd_section
6249 (abfd, syms[idx]->section);
6253 asection *sec = syms[idx]->section;
6256 if (sec->output_section)
6258 value += sec->output_offset;
6259 sec = sec->output_section;
6262 /* Don't add in the section vma for relocatable output. */
6263 if (! relocatable_p)
6265 sym.st_value = value;
6266 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6268 if (bfd_is_abs_section (sec)
6270 && type_ptr->internal_elf_sym.st_shndx != 0)
6272 /* This symbol is in a real ELF section which we did
6273 not create as a BFD section. Undo the mapping done
6274 by copy_private_symbol_data. */
6275 shndx = type_ptr->internal_elf_sym.st_shndx;
6279 shndx = elf_onesymtab (abfd);
6282 shndx = elf_dynsymtab (abfd);
6285 shndx = elf_tdata (abfd)->strtab_section;
6288 shndx = elf_tdata (abfd)->shstrtab_section;
6291 shndx = elf_tdata (abfd)->symtab_shndx_section;
6299 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6301 if (shndx == SHN_BAD)
6305 /* Writing this would be a hell of a lot easier if
6306 we had some decent documentation on bfd, and
6307 knew what to expect of the library, and what to
6308 demand of applications. For example, it
6309 appears that `objcopy' might not set the
6310 section of a symbol to be a section that is
6311 actually in the output file. */
6312 sec2 = bfd_get_section_by_name (abfd, sec->name);
6315 _bfd_error_handler (_("\
6316 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6317 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6319 bfd_set_error (bfd_error_invalid_operation);
6320 _bfd_stringtab_free (stt);
6324 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6325 BFD_ASSERT (shndx != SHN_BAD);
6329 sym.st_shndx = shndx;
6332 if ((flags & BSF_THREAD_LOCAL) != 0)
6334 else if ((flags & BSF_FUNCTION) != 0)
6336 else if ((flags & BSF_OBJECT) != 0)
6338 else if ((flags & BSF_RELC) != 0)
6340 else if ((flags & BSF_SRELC) != 0)
6345 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6348 /* Processor-specific types. */
6349 if (type_ptr != NULL
6350 && bed->elf_backend_get_symbol_type)
6351 type = ((*bed->elf_backend_get_symbol_type)
6352 (&type_ptr->internal_elf_sym, type));
6354 if (flags & BSF_SECTION_SYM)
6356 if (flags & BSF_GLOBAL)
6357 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6359 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6361 else if (bfd_is_com_section (syms[idx]->section))
6363 #ifdef USE_STT_COMMON
6364 if (type == STT_OBJECT)
6365 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6368 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6371 else if (bfd_is_und_section (syms[idx]->section))
6372 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6376 else if (flags & BSF_FILE)
6377 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6380 int bind = STB_LOCAL;
6382 if (flags & BSF_LOCAL)
6384 else if (flags & BSF_WEAK)
6386 else if (flags & BSF_GLOBAL)
6389 sym.st_info = ELF_ST_INFO (bind, type);
6392 if (type_ptr != NULL)
6393 sym.st_other = type_ptr->internal_elf_sym.st_other;
6397 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6398 outbound_syms += bed->s->sizeof_sym;
6399 if (outbound_shndx != NULL)
6400 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6404 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6405 symstrtab_hdr->sh_type = SHT_STRTAB;
6407 symstrtab_hdr->sh_flags = 0;
6408 symstrtab_hdr->sh_addr = 0;
6409 symstrtab_hdr->sh_entsize = 0;
6410 symstrtab_hdr->sh_link = 0;
6411 symstrtab_hdr->sh_info = 0;
6412 symstrtab_hdr->sh_addralign = 1;
6417 /* Return the number of bytes required to hold the symtab vector.
6419 Note that we base it on the count plus 1, since we will null terminate
6420 the vector allocated based on this size. However, the ELF symbol table
6421 always has a dummy entry as symbol #0, so it ends up even. */
6424 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6428 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6430 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6431 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6433 symtab_size -= sizeof (asymbol *);
6439 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6443 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6445 if (elf_dynsymtab (abfd) == 0)
6447 bfd_set_error (bfd_error_invalid_operation);
6451 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6452 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6454 symtab_size -= sizeof (asymbol *);
6460 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6463 return (asect->reloc_count + 1) * sizeof (arelent *);
6466 /* Canonicalize the relocs. */
6469 _bfd_elf_canonicalize_reloc (bfd *abfd,
6476 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6478 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6481 tblptr = section->relocation;
6482 for (i = 0; i < section->reloc_count; i++)
6483 *relptr++ = tblptr++;
6487 return section->reloc_count;
6491 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6493 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6494 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6497 bfd_get_symcount (abfd) = symcount;
6502 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6503 asymbol **allocation)
6505 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6506 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6509 bfd_get_dynamic_symcount (abfd) = symcount;
6513 /* Return the size required for the dynamic reloc entries. Any loadable
6514 section that was actually installed in the BFD, and has type SHT_REL
6515 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6516 dynamic reloc section. */
6519 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6524 if (elf_dynsymtab (abfd) == 0)
6526 bfd_set_error (bfd_error_invalid_operation);
6530 ret = sizeof (arelent *);
6531 for (s = abfd->sections; s != NULL; s = s->next)
6532 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6533 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6534 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6535 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6536 * sizeof (arelent *));
6541 /* Canonicalize the dynamic relocation entries. Note that we return the
6542 dynamic relocations as a single block, although they are actually
6543 associated with particular sections; the interface, which was
6544 designed for SunOS style shared libraries, expects that there is only
6545 one set of dynamic relocs. Any loadable section that was actually
6546 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6547 dynamic symbol table, is considered to be a dynamic reloc section. */
6550 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6554 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6558 if (elf_dynsymtab (abfd) == 0)
6560 bfd_set_error (bfd_error_invalid_operation);
6564 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6566 for (s = abfd->sections; s != NULL; s = s->next)
6568 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6569 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6570 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6575 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6577 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6579 for (i = 0; i < count; i++)
6590 /* Read in the version information. */
6593 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6595 bfd_byte *contents = NULL;
6596 unsigned int freeidx = 0;
6598 if (elf_dynverref (abfd) != 0)
6600 Elf_Internal_Shdr *hdr;
6601 Elf_External_Verneed *everneed;
6602 Elf_Internal_Verneed *iverneed;
6604 bfd_byte *contents_end;
6606 hdr = &elf_tdata (abfd)->dynverref_hdr;
6608 elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6609 sizeof (Elf_Internal_Verneed));
6610 if (elf_tdata (abfd)->verref == NULL)
6613 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6615 contents = bfd_malloc (hdr->sh_size);
6616 if (contents == NULL)
6618 error_return_verref:
6619 elf_tdata (abfd)->verref = NULL;
6620 elf_tdata (abfd)->cverrefs = 0;
6623 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6624 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6625 goto error_return_verref;
6627 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6628 goto error_return_verref;
6630 BFD_ASSERT (sizeof (Elf_External_Verneed)
6631 == sizeof (Elf_External_Vernaux));
6632 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
6633 everneed = (Elf_External_Verneed *) contents;
6634 iverneed = elf_tdata (abfd)->verref;
6635 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6637 Elf_External_Vernaux *evernaux;
6638 Elf_Internal_Vernaux *ivernaux;
6641 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6643 iverneed->vn_bfd = abfd;
6645 iverneed->vn_filename =
6646 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6648 if (iverneed->vn_filename == NULL)
6649 goto error_return_verref;
6651 if (iverneed->vn_cnt == 0)
6652 iverneed->vn_auxptr = NULL;
6655 iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6656 sizeof (Elf_Internal_Vernaux));
6657 if (iverneed->vn_auxptr == NULL)
6658 goto error_return_verref;
6661 if (iverneed->vn_aux
6662 > (size_t) (contents_end - (bfd_byte *) everneed))
6663 goto error_return_verref;
6665 evernaux = ((Elf_External_Vernaux *)
6666 ((bfd_byte *) everneed + iverneed->vn_aux));
6667 ivernaux = iverneed->vn_auxptr;
6668 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6670 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6672 ivernaux->vna_nodename =
6673 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6674 ivernaux->vna_name);
6675 if (ivernaux->vna_nodename == NULL)
6676 goto error_return_verref;
6678 if (j + 1 < iverneed->vn_cnt)
6679 ivernaux->vna_nextptr = ivernaux + 1;
6681 ivernaux->vna_nextptr = NULL;
6683 if (ivernaux->vna_next
6684 > (size_t) (contents_end - (bfd_byte *) evernaux))
6685 goto error_return_verref;
6687 evernaux = ((Elf_External_Vernaux *)
6688 ((bfd_byte *) evernaux + ivernaux->vna_next));
6690 if (ivernaux->vna_other > freeidx)
6691 freeidx = ivernaux->vna_other;
6694 if (i + 1 < hdr->sh_info)
6695 iverneed->vn_nextref = iverneed + 1;
6697 iverneed->vn_nextref = NULL;
6699 if (iverneed->vn_next
6700 > (size_t) (contents_end - (bfd_byte *) everneed))
6701 goto error_return_verref;
6703 everneed = ((Elf_External_Verneed *)
6704 ((bfd_byte *) everneed + iverneed->vn_next));
6711 if (elf_dynverdef (abfd) != 0)
6713 Elf_Internal_Shdr *hdr;
6714 Elf_External_Verdef *everdef;
6715 Elf_Internal_Verdef *iverdef;
6716 Elf_Internal_Verdef *iverdefarr;
6717 Elf_Internal_Verdef iverdefmem;
6719 unsigned int maxidx;
6720 bfd_byte *contents_end_def, *contents_end_aux;
6722 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6724 contents = bfd_malloc (hdr->sh_size);
6725 if (contents == NULL)
6727 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6728 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
6731 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6734 BFD_ASSERT (sizeof (Elf_External_Verdef)
6735 >= sizeof (Elf_External_Verdaux));
6736 contents_end_def = contents + hdr->sh_size
6737 - sizeof (Elf_External_Verdef);
6738 contents_end_aux = contents + hdr->sh_size
6739 - sizeof (Elf_External_Verdaux);
6741 /* We know the number of entries in the section but not the maximum
6742 index. Therefore we have to run through all entries and find
6744 everdef = (Elf_External_Verdef *) contents;
6746 for (i = 0; i < hdr->sh_info; ++i)
6748 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6750 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6751 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
6753 if (iverdefmem.vd_next
6754 > (size_t) (contents_end_def - (bfd_byte *) everdef))
6757 everdef = ((Elf_External_Verdef *)
6758 ((bfd_byte *) everdef + iverdefmem.vd_next));
6761 if (default_imported_symver)
6763 if (freeidx > maxidx)
6768 elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6769 sizeof (Elf_Internal_Verdef));
6770 if (elf_tdata (abfd)->verdef == NULL)
6773 elf_tdata (abfd)->cverdefs = maxidx;
6775 everdef = (Elf_External_Verdef *) contents;
6776 iverdefarr = elf_tdata (abfd)->verdef;
6777 for (i = 0; i < hdr->sh_info; i++)
6779 Elf_External_Verdaux *everdaux;
6780 Elf_Internal_Verdaux *iverdaux;
6783 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6785 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6787 error_return_verdef:
6788 elf_tdata (abfd)->verdef = NULL;
6789 elf_tdata (abfd)->cverdefs = 0;
6793 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6794 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
6796 iverdef->vd_bfd = abfd;
6798 if (iverdef->vd_cnt == 0)
6799 iverdef->vd_auxptr = NULL;
6802 iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6803 sizeof (Elf_Internal_Verdaux));
6804 if (iverdef->vd_auxptr == NULL)
6805 goto error_return_verdef;
6809 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6810 goto error_return_verdef;
6812 everdaux = ((Elf_External_Verdaux *)
6813 ((bfd_byte *) everdef + iverdef->vd_aux));
6814 iverdaux = iverdef->vd_auxptr;
6815 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6817 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6819 iverdaux->vda_nodename =
6820 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6821 iverdaux->vda_name);
6822 if (iverdaux->vda_nodename == NULL)
6823 goto error_return_verdef;
6825 if (j + 1 < iverdef->vd_cnt)
6826 iverdaux->vda_nextptr = iverdaux + 1;
6828 iverdaux->vda_nextptr = NULL;
6830 if (iverdaux->vda_next
6831 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6832 goto error_return_verdef;
6834 everdaux = ((Elf_External_Verdaux *)
6835 ((bfd_byte *) everdaux + iverdaux->vda_next));
6838 if (iverdef->vd_cnt)
6839 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6841 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
6842 iverdef->vd_nextdef = iverdef + 1;
6844 iverdef->vd_nextdef = NULL;
6846 everdef = ((Elf_External_Verdef *)
6847 ((bfd_byte *) everdef + iverdef->vd_next));
6853 else if (default_imported_symver)
6860 elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6861 sizeof (Elf_Internal_Verdef));
6862 if (elf_tdata (abfd)->verdef == NULL)
6865 elf_tdata (abfd)->cverdefs = freeidx;
6868 /* Create a default version based on the soname. */
6869 if (default_imported_symver)
6871 Elf_Internal_Verdef *iverdef;
6872 Elf_Internal_Verdaux *iverdaux;
6874 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
6876 iverdef->vd_version = VER_DEF_CURRENT;
6877 iverdef->vd_flags = 0;
6878 iverdef->vd_ndx = freeidx;
6879 iverdef->vd_cnt = 1;
6881 iverdef->vd_bfd = abfd;
6883 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6884 if (iverdef->vd_nodename == NULL)
6885 goto error_return_verdef;
6886 iverdef->vd_nextdef = NULL;
6887 iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6888 if (iverdef->vd_auxptr == NULL)
6889 goto error_return_verdef;
6891 iverdaux = iverdef->vd_auxptr;
6892 iverdaux->vda_nodename = iverdef->vd_nodename;
6893 iverdaux->vda_nextptr = NULL;
6899 if (contents != NULL)
6905 _bfd_elf_make_empty_symbol (bfd *abfd)
6907 elf_symbol_type *newsym;
6908 bfd_size_type amt = sizeof (elf_symbol_type);
6910 newsym = bfd_zalloc (abfd, amt);
6915 newsym->symbol.the_bfd = abfd;
6916 return &newsym->symbol;
6921 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6925 bfd_symbol_info (symbol, ret);
6928 /* Return whether a symbol name implies a local symbol. Most targets
6929 use this function for the is_local_label_name entry point, but some
6933 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6936 /* Normal local symbols start with ``.L''. */
6937 if (name[0] == '.' && name[1] == 'L')
6940 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6941 DWARF debugging symbols starting with ``..''. */
6942 if (name[0] == '.' && name[1] == '.')
6945 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6946 emitting DWARF debugging output. I suspect this is actually a
6947 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6948 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6949 underscore to be emitted on some ELF targets). For ease of use,
6950 we treat such symbols as local. */
6951 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
6958 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6959 asymbol *symbol ATTRIBUTE_UNUSED)
6966 _bfd_elf_set_arch_mach (bfd *abfd,
6967 enum bfd_architecture arch,
6968 unsigned long machine)
6970 /* If this isn't the right architecture for this backend, and this
6971 isn't the generic backend, fail. */
6972 if (arch != get_elf_backend_data (abfd)->arch
6973 && arch != bfd_arch_unknown
6974 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
6977 return bfd_default_set_arch_mach (abfd, arch, machine);
6980 /* Find the function to a particular section and offset,
6981 for error reporting. */
6984 elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6988 const char **filename_ptr,
6989 const char **functionname_ptr)
6991 const char *filename;
6992 asymbol *func, *file;
6995 /* ??? Given multiple file symbols, it is impossible to reliably
6996 choose the right file name for global symbols. File symbols are
6997 local symbols, and thus all file symbols must sort before any
6998 global symbols. The ELF spec may be interpreted to say that a
6999 file symbol must sort before other local symbols, but currently
7000 ld -r doesn't do this. So, for ld -r output, it is possible to
7001 make a better choice of file name for local symbols by ignoring
7002 file symbols appearing after a given local symbol. */
7003 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7009 state = nothing_seen;
7011 for (p = symbols; *p != NULL; p++)
7015 q = (elf_symbol_type *) *p;
7017 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7023 if (state == symbol_seen)
7024 state = file_after_symbol_seen;
7028 if (bfd_get_section (&q->symbol) == section
7029 && q->symbol.value >= low_func
7030 && q->symbol.value <= offset)
7032 func = (asymbol *) q;
7033 low_func = q->symbol.value;
7036 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7037 || state != file_after_symbol_seen))
7038 filename = bfd_asymbol_name (file);
7042 if (state == nothing_seen)
7043 state = symbol_seen;
7050 *filename_ptr = filename;
7051 if (functionname_ptr)
7052 *functionname_ptr = bfd_asymbol_name (func);
7057 /* Find the nearest line to a particular section and offset,
7058 for error reporting. */
7061 _bfd_elf_find_nearest_line (bfd *abfd,
7065 const char **filename_ptr,
7066 const char **functionname_ptr,
7067 unsigned int *line_ptr)
7071 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7072 filename_ptr, functionname_ptr,
7075 if (!*functionname_ptr)
7076 elf_find_function (abfd, section, symbols, offset,
7077 *filename_ptr ? NULL : filename_ptr,
7083 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
7084 filename_ptr, functionname_ptr,
7086 &elf_tdata (abfd)->dwarf2_find_line_info))
7088 if (!*functionname_ptr)
7089 elf_find_function (abfd, section, symbols, offset,
7090 *filename_ptr ? NULL : filename_ptr,
7096 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7097 &found, filename_ptr,
7098 functionname_ptr, line_ptr,
7099 &elf_tdata (abfd)->line_info))
7101 if (found && (*functionname_ptr || *line_ptr))
7104 if (symbols == NULL)
7107 if (! elf_find_function (abfd, section, symbols, offset,
7108 filename_ptr, functionname_ptr))
7115 /* Find the line for a symbol. */
7118 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7119 const char **filename_ptr, unsigned int *line_ptr)
7121 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7122 filename_ptr, line_ptr, 0,
7123 &elf_tdata (abfd)->dwarf2_find_line_info);
7126 /* After a call to bfd_find_nearest_line, successive calls to
7127 bfd_find_inliner_info can be used to get source information about
7128 each level of function inlining that terminated at the address
7129 passed to bfd_find_nearest_line. Currently this is only supported
7130 for DWARF2 with appropriate DWARF3 extensions. */
7133 _bfd_elf_find_inliner_info (bfd *abfd,
7134 const char **filename_ptr,
7135 const char **functionname_ptr,
7136 unsigned int *line_ptr)
7139 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7140 functionname_ptr, line_ptr,
7141 & elf_tdata (abfd)->dwarf2_find_line_info);
7146 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7148 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7149 int ret = bed->s->sizeof_ehdr;
7151 if (!info->relocatable)
7153 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7155 if (phdr_size == (bfd_size_type) -1)
7157 struct elf_segment_map *m;
7160 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7161 phdr_size += bed->s->sizeof_phdr;
7164 phdr_size = get_program_header_size (abfd, info);
7167 elf_tdata (abfd)->program_header_size = phdr_size;
7175 _bfd_elf_set_section_contents (bfd *abfd,
7177 const void *location,
7179 bfd_size_type count)
7181 Elf_Internal_Shdr *hdr;
7184 if (! abfd->output_has_begun
7185 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7188 hdr = &elf_section_data (section)->this_hdr;
7189 pos = hdr->sh_offset + offset;
7190 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7191 || bfd_bwrite (location, count, abfd) != count)
7198 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7199 arelent *cache_ptr ATTRIBUTE_UNUSED,
7200 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7205 /* Try to convert a non-ELF reloc into an ELF one. */
7208 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7210 /* Check whether we really have an ELF howto. */
7212 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7214 bfd_reloc_code_real_type code;
7215 reloc_howto_type *howto;
7217 /* Alien reloc: Try to determine its type to replace it with an
7218 equivalent ELF reloc. */
7220 if (areloc->howto->pc_relative)
7222 switch (areloc->howto->bitsize)
7225 code = BFD_RELOC_8_PCREL;
7228 code = BFD_RELOC_12_PCREL;
7231 code = BFD_RELOC_16_PCREL;
7234 code = BFD_RELOC_24_PCREL;
7237 code = BFD_RELOC_32_PCREL;
7240 code = BFD_RELOC_64_PCREL;
7246 howto = bfd_reloc_type_lookup (abfd, code);
7248 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7250 if (howto->pcrel_offset)
7251 areloc->addend += areloc->address;
7253 areloc->addend -= areloc->address; /* addend is unsigned!! */
7258 switch (areloc->howto->bitsize)
7264 code = BFD_RELOC_14;
7267 code = BFD_RELOC_16;
7270 code = BFD_RELOC_26;
7273 code = BFD_RELOC_32;
7276 code = BFD_RELOC_64;
7282 howto = bfd_reloc_type_lookup (abfd, code);
7286 areloc->howto = howto;
7294 (*_bfd_error_handler)
7295 (_("%B: unsupported relocation type %s"),
7296 abfd, areloc->howto->name);
7297 bfd_set_error (bfd_error_bad_value);
7302 _bfd_elf_close_and_cleanup (bfd *abfd)
7304 if (bfd_get_format (abfd) == bfd_object)
7306 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
7307 _bfd_elf_strtab_free (elf_shstrtab (abfd));
7308 _bfd_dwarf2_cleanup_debug_info (abfd);
7311 return _bfd_generic_close_and_cleanup (abfd);
7314 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7315 in the relocation's offset. Thus we cannot allow any sort of sanity
7316 range-checking to interfere. There is nothing else to do in processing
7319 bfd_reloc_status_type
7320 _bfd_elf_rel_vtable_reloc_fn
7321 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7322 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7323 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7324 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7326 return bfd_reloc_ok;
7329 /* Elf core file support. Much of this only works on native
7330 toolchains, since we rely on knowing the
7331 machine-dependent procfs structure in order to pick
7332 out details about the corefile. */
7334 #ifdef HAVE_SYS_PROCFS_H
7335 # include <sys/procfs.h>
7338 /* FIXME: this is kinda wrong, but it's what gdb wants. */
7341 elfcore_make_pid (bfd *abfd)
7343 return ((elf_tdata (abfd)->core_lwpid << 16)
7344 + (elf_tdata (abfd)->core_pid));
7347 /* If there isn't a section called NAME, make one, using
7348 data from SECT. Note, this function will generate a
7349 reference to NAME, so you shouldn't deallocate or
7353 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7357 if (bfd_get_section_by_name (abfd, name) != NULL)
7360 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7364 sect2->size = sect->size;
7365 sect2->filepos = sect->filepos;
7366 sect2->alignment_power = sect->alignment_power;
7370 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7371 actually creates up to two pseudosections:
7372 - For the single-threaded case, a section named NAME, unless
7373 such a section already exists.
7374 - For the multi-threaded case, a section named "NAME/PID", where
7375 PID is elfcore_make_pid (abfd).
7376 Both pseudosections have identical contents. */
7378 _bfd_elfcore_make_pseudosection (bfd *abfd,
7384 char *threaded_name;
7388 /* Build the section name. */
7390 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7391 len = strlen (buf) + 1;
7392 threaded_name = bfd_alloc (abfd, len);
7393 if (threaded_name == NULL)
7395 memcpy (threaded_name, buf, len);
7397 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7402 sect->filepos = filepos;
7403 sect->alignment_power = 2;
7405 return elfcore_maybe_make_sect (abfd, name, sect);
7408 /* prstatus_t exists on:
7410 linux 2.[01] + glibc
7414 #if defined (HAVE_PRSTATUS_T)
7417 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7422 if (note->descsz == sizeof (prstatus_t))
7426 size = sizeof (prstat.pr_reg);
7427 offset = offsetof (prstatus_t, pr_reg);
7428 memcpy (&prstat, note->descdata, sizeof (prstat));
7430 /* Do not overwrite the core signal if it
7431 has already been set by another thread. */
7432 if (elf_tdata (abfd)->core_signal == 0)
7433 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7434 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7436 /* pr_who exists on:
7439 pr_who doesn't exist on:
7442 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7443 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7446 #if defined (HAVE_PRSTATUS32_T)
7447 else if (note->descsz == sizeof (prstatus32_t))
7449 /* 64-bit host, 32-bit corefile */
7450 prstatus32_t prstat;
7452 size = sizeof (prstat.pr_reg);
7453 offset = offsetof (prstatus32_t, pr_reg);
7454 memcpy (&prstat, note->descdata, sizeof (prstat));
7456 /* Do not overwrite the core signal if it
7457 has already been set by another thread. */
7458 if (elf_tdata (abfd)->core_signal == 0)
7459 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7460 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7462 /* pr_who exists on:
7465 pr_who doesn't exist on:
7468 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7469 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7472 #endif /* HAVE_PRSTATUS32_T */
7475 /* Fail - we don't know how to handle any other
7476 note size (ie. data object type). */
7480 /* Make a ".reg/999" section and a ".reg" section. */
7481 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7482 size, note->descpos + offset);
7484 #endif /* defined (HAVE_PRSTATUS_T) */
7486 /* Create a pseudosection containing the exact contents of NOTE. */
7488 elfcore_make_note_pseudosection (bfd *abfd,
7490 Elf_Internal_Note *note)
7492 return _bfd_elfcore_make_pseudosection (abfd, name,
7493 note->descsz, note->descpos);
7496 /* There isn't a consistent prfpregset_t across platforms,
7497 but it doesn't matter, because we don't have to pick this
7498 data structure apart. */
7501 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7503 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7506 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7507 type of NT_PRXFPREG. Just include the whole note's contents
7511 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7513 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7517 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7519 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7523 #if defined (HAVE_PRPSINFO_T)
7524 typedef prpsinfo_t elfcore_psinfo_t;
7525 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
7526 typedef prpsinfo32_t elfcore_psinfo32_t;
7530 #if defined (HAVE_PSINFO_T)
7531 typedef psinfo_t elfcore_psinfo_t;
7532 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
7533 typedef psinfo32_t elfcore_psinfo32_t;
7537 /* return a malloc'ed copy of a string at START which is at
7538 most MAX bytes long, possibly without a terminating '\0'.
7539 the copy will always have a terminating '\0'. */
7542 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
7545 char *end = memchr (start, '\0', max);
7553 dups = bfd_alloc (abfd, len + 1);
7557 memcpy (dups, start, len);
7563 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7565 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
7567 if (note->descsz == sizeof (elfcore_psinfo_t))
7569 elfcore_psinfo_t psinfo;
7571 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7573 elf_tdata (abfd)->core_program
7574 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7575 sizeof (psinfo.pr_fname));
7577 elf_tdata (abfd)->core_command
7578 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7579 sizeof (psinfo.pr_psargs));
7581 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
7582 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7584 /* 64-bit host, 32-bit corefile */
7585 elfcore_psinfo32_t psinfo;
7587 memcpy (&psinfo, note->descdata, sizeof (psinfo));
7589 elf_tdata (abfd)->core_program
7590 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7591 sizeof (psinfo.pr_fname));
7593 elf_tdata (abfd)->core_command
7594 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7595 sizeof (psinfo.pr_psargs));
7601 /* Fail - we don't know how to handle any other
7602 note size (ie. data object type). */
7606 /* Note that for some reason, a spurious space is tacked
7607 onto the end of the args in some (at least one anyway)
7608 implementations, so strip it off if it exists. */
7611 char *command = elf_tdata (abfd)->core_command;
7612 int n = strlen (command);
7614 if (0 < n && command[n - 1] == ' ')
7615 command[n - 1] = '\0';
7620 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7622 #if defined (HAVE_PSTATUS_T)
7624 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
7626 if (note->descsz == sizeof (pstatus_t)
7627 #if defined (HAVE_PXSTATUS_T)
7628 || note->descsz == sizeof (pxstatus_t)
7634 memcpy (&pstat, note->descdata, sizeof (pstat));
7636 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7638 #if defined (HAVE_PSTATUS32_T)
7639 else if (note->descsz == sizeof (pstatus32_t))
7641 /* 64-bit host, 32-bit corefile */
7644 memcpy (&pstat, note->descdata, sizeof (pstat));
7646 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7649 /* Could grab some more details from the "representative"
7650 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
7651 NT_LWPSTATUS note, presumably. */
7655 #endif /* defined (HAVE_PSTATUS_T) */
7657 #if defined (HAVE_LWPSTATUS_T)
7659 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
7661 lwpstatus_t lwpstat;
7667 if (note->descsz != sizeof (lwpstat)
7668 #if defined (HAVE_LWPXSTATUS_T)
7669 && note->descsz != sizeof (lwpxstatus_t)
7674 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7676 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7677 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7679 /* Make a ".reg/999" section. */
7681 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
7682 len = strlen (buf) + 1;
7683 name = bfd_alloc (abfd, len);
7686 memcpy (name, buf, len);
7688 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7692 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7693 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
7694 sect->filepos = note->descpos
7695 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7698 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7699 sect->size = sizeof (lwpstat.pr_reg);
7700 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7703 sect->alignment_power = 2;
7705 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
7708 /* Make a ".reg2/999" section */
7710 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
7711 len = strlen (buf) + 1;
7712 name = bfd_alloc (abfd, len);
7715 memcpy (name, buf, len);
7717 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7721 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7722 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
7723 sect->filepos = note->descpos
7724 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7727 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
7728 sect->size = sizeof (lwpstat.pr_fpreg);
7729 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7732 sect->alignment_power = 2;
7734 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
7736 #endif /* defined (HAVE_LWPSTATUS_T) */
7739 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
7746 int is_active_thread;
7749 if (note->descsz < 728)
7752 if (! CONST_STRNEQ (note->namedata, "win32"))
7755 type = bfd_get_32 (abfd, note->descdata);
7759 case 1 /* NOTE_INFO_PROCESS */:
7760 /* FIXME: need to add ->core_command. */
7761 /* process_info.pid */
7762 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
7763 /* process_info.signal */
7764 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
7767 case 2 /* NOTE_INFO_THREAD */:
7768 /* Make a ".reg/999" section. */
7769 /* thread_info.tid */
7770 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
7772 len = strlen (buf) + 1;
7773 name = bfd_alloc (abfd, len);
7777 memcpy (name, buf, len);
7779 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7783 /* sizeof (thread_info.thread_context) */
7785 /* offsetof (thread_info.thread_context) */
7786 sect->filepos = note->descpos + 12;
7787 sect->alignment_power = 2;
7789 /* thread_info.is_active_thread */
7790 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
7792 if (is_active_thread)
7793 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
7797 case 3 /* NOTE_INFO_MODULE */:
7798 /* Make a ".module/xxxxxxxx" section. */
7799 /* module_info.base_address */
7800 base_addr = bfd_get_32 (abfd, note->descdata + 4);
7801 sprintf (buf, ".module/%08lx", (long) base_addr);
7803 len = strlen (buf) + 1;
7804 name = bfd_alloc (abfd, len);
7808 memcpy (name, buf, len);
7810 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
7815 sect->size = note->descsz;
7816 sect->filepos = note->descpos;
7817 sect->alignment_power = 2;
7828 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
7830 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7838 if (bed->elf_backend_grok_prstatus)
7839 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
7841 #if defined (HAVE_PRSTATUS_T)
7842 return elfcore_grok_prstatus (abfd, note);
7847 #if defined (HAVE_PSTATUS_T)
7849 return elfcore_grok_pstatus (abfd, note);
7852 #if defined (HAVE_LWPSTATUS_T)
7854 return elfcore_grok_lwpstatus (abfd, note);
7857 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7858 return elfcore_grok_prfpreg (abfd, note);
7860 case NT_WIN32PSTATUS:
7861 return elfcore_grok_win32pstatus (abfd, note);
7863 case NT_PRXFPREG: /* Linux SSE extension */
7864 if (note->namesz == 6
7865 && strcmp (note->namedata, "LINUX") == 0)
7866 return elfcore_grok_prxfpreg (abfd, note);
7871 if (note->namesz == 6
7872 && strcmp (note->namedata, "LINUX") == 0)
7873 return elfcore_grok_ppc_vmx (abfd, note);
7879 if (bed->elf_backend_grok_psinfo)
7880 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
7882 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7883 return elfcore_grok_psinfo (abfd, note);
7890 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7895 sect->size = note->descsz;
7896 sect->filepos = note->descpos;
7897 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7905 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
7907 elf_tdata (abfd)->build_id_size = note->descsz;
7908 elf_tdata (abfd)->build_id = bfd_alloc (abfd, note->descsz);
7909 if (elf_tdata (abfd)->build_id == NULL)
7912 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
7918 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
7925 case NT_GNU_BUILD_ID:
7926 return elfobj_grok_gnu_build_id (abfd, note);
7931 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
7935 cp = strchr (note->namedata, '@');
7938 *lwpidp = atoi(cp + 1);
7945 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
7947 /* Signal number at offset 0x08. */
7948 elf_tdata (abfd)->core_signal
7949 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7951 /* Process ID at offset 0x50. */
7952 elf_tdata (abfd)->core_pid
7953 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7955 /* Command name at 0x7c (max 32 bytes, including nul). */
7956 elf_tdata (abfd)->core_command
7957 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7959 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7964 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
7968 if (elfcore_netbsd_get_lwpid (note, &lwp))
7969 elf_tdata (abfd)->core_lwpid = lwp;
7971 if (note->type == NT_NETBSDCORE_PROCINFO)
7973 /* NetBSD-specific core "procinfo". Note that we expect to
7974 find this note before any of the others, which is fine,
7975 since the kernel writes this note out first when it
7976 creates a core file. */
7978 return elfcore_grok_netbsd_procinfo (abfd, note);
7981 /* As of Jan 2002 there are no other machine-independent notes
7982 defined for NetBSD core files. If the note type is less
7983 than the start of the machine-dependent note types, we don't
7986 if (note->type < NT_NETBSDCORE_FIRSTMACH)
7990 switch (bfd_get_arch (abfd))
7992 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7993 PT_GETFPREGS == mach+2. */
7995 case bfd_arch_alpha:
7996 case bfd_arch_sparc:
7999 case NT_NETBSDCORE_FIRSTMACH+0:
8000 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8002 case NT_NETBSDCORE_FIRSTMACH+2:
8003 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8009 /* On all other arch's, PT_GETREGS == mach+1 and
8010 PT_GETFPREGS == mach+3. */
8015 case NT_NETBSDCORE_FIRSTMACH+1:
8016 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8018 case NT_NETBSDCORE_FIRSTMACH+3:
8019 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8029 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8031 void *ddata = note->descdata;
8038 /* nto_procfs_status 'pid' field is at offset 0. */
8039 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8041 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8042 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8044 /* nto_procfs_status 'flags' field is at offset 8. */
8045 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8047 /* nto_procfs_status 'what' field is at offset 14. */
8048 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8050 elf_tdata (abfd)->core_signal = sig;
8051 elf_tdata (abfd)->core_lwpid = *tid;
8054 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8055 do not come from signals so we make sure we set the current
8056 thread just in case. */
8057 if (flags & 0x00000080)
8058 elf_tdata (abfd)->core_lwpid = *tid;
8060 /* Make a ".qnx_core_status/%d" section. */
8061 sprintf (buf, ".qnx_core_status/%ld", *tid);
8063 name = bfd_alloc (abfd, strlen (buf) + 1);
8068 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8072 sect->size = note->descsz;
8073 sect->filepos = note->descpos;
8074 sect->alignment_power = 2;
8076 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8080 elfcore_grok_nto_regs (bfd *abfd,
8081 Elf_Internal_Note *note,
8089 /* Make a "(base)/%d" section. */
8090 sprintf (buf, "%s/%ld", base, tid);
8092 name = bfd_alloc (abfd, strlen (buf) + 1);
8097 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8101 sect->size = note->descsz;
8102 sect->filepos = note->descpos;
8103 sect->alignment_power = 2;
8105 /* This is the current thread. */
8106 if (elf_tdata (abfd)->core_lwpid == tid)
8107 return elfcore_maybe_make_sect (abfd, base, sect);
8112 #define BFD_QNT_CORE_INFO 7
8113 #define BFD_QNT_CORE_STATUS 8
8114 #define BFD_QNT_CORE_GREG 9
8115 #define BFD_QNT_CORE_FPREG 10
8118 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8120 /* Every GREG section has a STATUS section before it. Store the
8121 tid from the previous call to pass down to the next gregs
8123 static long tid = 1;
8127 case BFD_QNT_CORE_INFO:
8128 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8129 case BFD_QNT_CORE_STATUS:
8130 return elfcore_grok_nto_status (abfd, note, &tid);
8131 case BFD_QNT_CORE_GREG:
8132 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8133 case BFD_QNT_CORE_FPREG:
8134 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8141 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8147 /* Use note name as section name. */
8149 name = bfd_alloc (abfd, len);
8152 memcpy (name, note->namedata, len);
8153 name[len - 1] = '\0';
8155 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8159 sect->size = note->descsz;
8160 sect->filepos = note->descpos;
8161 sect->alignment_power = 1;
8166 /* Function: elfcore_write_note
8169 buffer to hold note, and current size of buffer
8173 size of data for note
8175 Writes note to end of buffer. ELF64 notes are written exactly as
8176 for ELF32, despite the current (as of 2006) ELF gabi specifying
8177 that they ought to have 8-byte namesz and descsz field, and have
8178 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8181 Pointer to realloc'd buffer, *BUFSIZ updated. */
8184 elfcore_write_note (bfd *abfd,
8192 Elf_External_Note *xnp;
8199 namesz = strlen (name) + 1;
8201 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8203 buf = realloc (buf, *bufsiz + newspace);
8206 dest = buf + *bufsiz;
8207 *bufsiz += newspace;
8208 xnp = (Elf_External_Note *) dest;
8209 H_PUT_32 (abfd, namesz, xnp->namesz);
8210 H_PUT_32 (abfd, size, xnp->descsz);
8211 H_PUT_32 (abfd, type, xnp->type);
8215 memcpy (dest, name, namesz);
8223 memcpy (dest, input, size);
8233 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8235 elfcore_write_prpsinfo (bfd *abfd,
8241 const char *note_name = "CORE";
8242 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8244 if (bed->elf_backend_write_core_note != NULL)
8247 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8248 NT_PRPSINFO, fname, psargs);
8253 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8254 if (bed->s->elfclass == ELFCLASS32)
8256 #if defined (HAVE_PSINFO32_T)
8258 int note_type = NT_PSINFO;
8261 int note_type = NT_PRPSINFO;
8264 memset (&data, 0, sizeof (data));
8265 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8266 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8267 return elfcore_write_note (abfd, buf, bufsiz,
8268 note_name, note_type, &data, sizeof (data));
8273 #if defined (HAVE_PSINFO_T)
8275 int note_type = NT_PSINFO;
8278 int note_type = NT_PRPSINFO;
8281 memset (&data, 0, sizeof (data));
8282 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8283 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8284 return elfcore_write_note (abfd, buf, bufsiz,
8285 note_name, note_type, &data, sizeof (data));
8288 #endif /* PSINFO_T or PRPSINFO_T */
8290 #if defined (HAVE_PRSTATUS_T)
8292 elfcore_write_prstatus (bfd *abfd,
8299 const char *note_name = "CORE";
8300 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8302 if (bed->elf_backend_write_core_note != NULL)
8305 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8307 pid, cursig, gregs);
8312 #if defined (HAVE_PRSTATUS32_T)
8313 if (bed->s->elfclass == ELFCLASS32)
8315 prstatus32_t prstat;
8317 memset (&prstat, 0, sizeof (prstat));
8318 prstat.pr_pid = pid;
8319 prstat.pr_cursig = cursig;
8320 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8321 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8322 NT_PRSTATUS, &prstat, sizeof (prstat));
8329 memset (&prstat, 0, sizeof (prstat));
8330 prstat.pr_pid = pid;
8331 prstat.pr_cursig = cursig;
8332 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8333 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8334 NT_PRSTATUS, &prstat, sizeof (prstat));
8337 #endif /* HAVE_PRSTATUS_T */
8339 #if defined (HAVE_LWPSTATUS_T)
8341 elfcore_write_lwpstatus (bfd *abfd,
8348 lwpstatus_t lwpstat;
8349 const char *note_name = "CORE";
8351 memset (&lwpstat, 0, sizeof (lwpstat));
8352 lwpstat.pr_lwpid = pid >> 16;
8353 lwpstat.pr_cursig = cursig;
8354 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8355 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8356 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8358 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8359 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8361 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8362 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8365 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8366 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8368 #endif /* HAVE_LWPSTATUS_T */
8370 #if defined (HAVE_PSTATUS_T)
8372 elfcore_write_pstatus (bfd *abfd,
8376 int cursig ATTRIBUTE_UNUSED,
8377 const void *gregs ATTRIBUTE_UNUSED)
8379 const char *note_name = "CORE";
8380 #if defined (HAVE_PSTATUS32_T)
8381 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8383 if (bed->s->elfclass == ELFCLASS32)
8387 memset (&pstat, 0, sizeof (pstat));
8388 pstat.pr_pid = pid & 0xffff;
8389 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8390 NT_PSTATUS, &pstat, sizeof (pstat));
8398 memset (&pstat, 0, sizeof (pstat));
8399 pstat.pr_pid = pid & 0xffff;
8400 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8401 NT_PSTATUS, &pstat, sizeof (pstat));
8405 #endif /* HAVE_PSTATUS_T */
8408 elfcore_write_prfpreg (bfd *abfd,
8414 const char *note_name = "CORE";
8415 return elfcore_write_note (abfd, buf, bufsiz,
8416 note_name, NT_FPREGSET, fpregs, size);
8420 elfcore_write_prxfpreg (bfd *abfd,
8423 const void *xfpregs,
8426 char *note_name = "LINUX";
8427 return elfcore_write_note (abfd, buf, bufsiz,
8428 note_name, NT_PRXFPREG, xfpregs, size);
8432 elfcore_write_ppc_vmx (bfd *abfd,
8435 const void *ppc_vmx,
8438 char *note_name = "LINUX";
8439 return elfcore_write_note (abfd, buf, bufsiz,
8440 note_name, NT_PPC_VMX, ppc_vmx, size);
8444 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
8449 while (p < buf + size)
8451 /* FIXME: bad alignment assumption. */
8452 Elf_External_Note *xnp = (Elf_External_Note *) p;
8453 Elf_Internal_Note in;
8455 in.type = H_GET_32 (abfd, xnp->type);
8457 in.namesz = H_GET_32 (abfd, xnp->namesz);
8458 in.namedata = xnp->name;
8460 in.descsz = H_GET_32 (abfd, xnp->descsz);
8461 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8462 in.descpos = offset + (in.descdata - buf);
8464 switch (bfd_get_format (abfd))
8470 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8472 if (! elfcore_grok_netbsd_note (abfd, &in))
8475 else if (CONST_STRNEQ (in.namedata, "QNX"))
8477 if (! elfcore_grok_nto_note (abfd, &in))
8480 else if (CONST_STRNEQ (in.namedata, "SPU/"))
8482 if (! elfcore_grok_spu_note (abfd, &in))
8487 if (! elfcore_grok_note (abfd, &in))
8493 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8495 if (! elfobj_grok_gnu_note (abfd, &in))
8501 p = in.descdata + BFD_ALIGN (in.descsz, 4);
8508 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8515 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8518 buf = bfd_malloc (size);
8522 if (bfd_bread (buf, size, abfd) != size
8523 || !elf_parse_notes (abfd, buf, size, offset))
8533 /* Providing external access to the ELF program header table. */
8535 /* Return an upper bound on the number of bytes required to store a
8536 copy of ABFD's program header table entries. Return -1 if an error
8537 occurs; bfd_get_error will return an appropriate code. */
8540 bfd_get_elf_phdr_upper_bound (bfd *abfd)
8542 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8544 bfd_set_error (bfd_error_wrong_format);
8548 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
8551 /* Copy ABFD's program header table entries to *PHDRS. The entries
8552 will be stored as an array of Elf_Internal_Phdr structures, as
8553 defined in include/elf/internal.h. To find out how large the
8554 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8556 Return the number of program header table entries read, or -1 if an
8557 error occurs; bfd_get_error will return an appropriate code. */
8560 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
8564 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8566 bfd_set_error (bfd_error_wrong_format);
8570 num_phdrs = elf_elfheader (abfd)->e_phnum;
8571 memcpy (phdrs, elf_tdata (abfd)->phdr,
8572 num_phdrs * sizeof (Elf_Internal_Phdr));
8577 enum elf_reloc_type_class
8578 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
8580 return reloc_class_normal;
8583 /* For RELA architectures, return the relocation value for a
8584 relocation against a local symbol. */
8587 _bfd_elf_rela_local_sym (bfd *abfd,
8588 Elf_Internal_Sym *sym,
8590 Elf_Internal_Rela *rel)
8592 asection *sec = *psec;
8595 relocation = (sec->output_section->vma
8596 + sec->output_offset
8598 if ((sec->flags & SEC_MERGE)
8599 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
8600 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
8603 _bfd_merged_section_offset (abfd, psec,
8604 elf_section_data (sec)->sec_info,
8605 sym->st_value + rel->r_addend);
8608 /* If we have changed the section, and our original section is
8609 marked with SEC_EXCLUDE, it means that the original
8610 SEC_MERGE section has been completely subsumed in some
8611 other SEC_MERGE section. In this case, we need to leave
8612 some info around for --emit-relocs. */
8613 if ((sec->flags & SEC_EXCLUDE) != 0)
8614 sec->kept_section = *psec;
8617 rel->r_addend -= relocation;
8618 rel->r_addend += sec->output_section->vma + sec->output_offset;
8624 _bfd_elf_rel_local_sym (bfd *abfd,
8625 Elf_Internal_Sym *sym,
8629 asection *sec = *psec;
8631 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
8632 return sym->st_value + addend;
8634 return _bfd_merged_section_offset (abfd, psec,
8635 elf_section_data (sec)->sec_info,
8636 sym->st_value + addend);
8640 _bfd_elf_section_offset (bfd *abfd,
8641 struct bfd_link_info *info,
8645 switch (sec->sec_info_type)
8647 case ELF_INFO_TYPE_STABS:
8648 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8650 case ELF_INFO_TYPE_EH_FRAME:
8651 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
8657 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
8658 reconstruct an ELF file by reading the segments out of remote memory
8659 based on the ELF file header at EHDR_VMA and the ELF program headers it
8660 points to. If not null, *LOADBASEP is filled in with the difference
8661 between the VMAs from which the segments were read, and the VMAs the
8662 file headers (and hence BFD's idea of each section's VMA) put them at.
8664 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8665 remote memory at target address VMA into the local buffer at MYADDR; it
8666 should return zero on success or an `errno' code on failure. TEMPL must
8667 be a BFD for an ELF target with the word size and byte order found in
8668 the remote memory. */
8671 bfd_elf_bfd_from_remote_memory
8675 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
8677 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8678 (templ, ehdr_vma, loadbasep, target_read_memory);
8682 _bfd_elf_get_synthetic_symtab (bfd *abfd,
8683 long symcount ATTRIBUTE_UNUSED,
8684 asymbol **syms ATTRIBUTE_UNUSED,
8689 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8692 const char *relplt_name;
8693 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8697 Elf_Internal_Shdr *hdr;
8703 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8706 if (dynsymcount <= 0)
8709 if (!bed->plt_sym_val)
8712 relplt_name = bed->relplt_name;
8713 if (relplt_name == NULL)
8714 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8715 relplt = bfd_get_section_by_name (abfd, relplt_name);
8719 hdr = &elf_section_data (relplt)->this_hdr;
8720 if (hdr->sh_link != elf_dynsymtab (abfd)
8721 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8724 plt = bfd_get_section_by_name (abfd, ".plt");
8728 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
8729 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
8732 count = relplt->size / hdr->sh_entsize;
8733 size = count * sizeof (asymbol);
8734 p = relplt->relocation;
8735 for (i = 0; i < count; i++, p++)
8736 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8738 s = *ret = bfd_malloc (size);
8742 names = (char *) (s + count);
8743 p = relplt->relocation;
8745 for (i = 0; i < count; i++, p++)
8750 addr = bed->plt_sym_val (i, plt, p);
8751 if (addr == (bfd_vma) -1)
8754 *s = **p->sym_ptr_ptr;
8755 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8756 we are defining a symbol, ensure one of them is set. */
8757 if ((s->flags & BSF_LOCAL) == 0)
8758 s->flags |= BSF_GLOBAL;
8760 s->value = addr - plt->vma;
8763 len = strlen ((*p->sym_ptr_ptr)->name);
8764 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8766 memcpy (names, "@plt", sizeof ("@plt"));
8767 names += sizeof ("@plt");
8774 /* It is only used by x86-64 so far. */
8775 asection _bfd_elf_large_com_section
8776 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
8777 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
8780 _bfd_elf_set_osabi (bfd * abfd,
8781 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8783 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
8785 i_ehdrp = elf_elfheader (abfd);
8787 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8791 /* Return TRUE for ELF symbol types that represent functions.
8792 This is the default version of this function, which is sufficient for
8793 most targets. It returns true if TYPE is STT_FUNC. */
8796 _bfd_elf_is_function_type (unsigned int type)
8798 return (type == STT_FUNC);