* elf32-spu.c (build_stub): Fix malloc under-allocation.
[binutils.git] / bfd / elf.c
blob5aabeeb1cdc416cb17432a8d734bb2a788187264
1 /* ELF executable support for BFD.
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
5 Free Software Foundation, Inc.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
26 SECTION
27 ELF backends
29 BFD support for ELF formats is being worked on.
30 Currently, the best supported back ends are for sparc and i386
31 (running svr4 or Solaris 2).
33 Documentation of the internals of the support code still needs
34 to be written. The code is changing quickly enough that we
35 haven't bothered yet. */
37 /* For sparc64-cross-sparc32. */
38 #define _SYSCALL32
39 #include "sysdep.h"
40 #include "bfd.h"
41 #include "bfdlink.h"
42 #include "libbfd.h"
43 #define ARCH_SIZE 0
44 #include "elf-bfd.h"
45 #include "libiberty.h"
46 #include "safe-ctype.h"
48 #ifdef CORE_HEADER
49 #include CORE_HEADER
50 #endif
52 static int elf_sort_sections (const void *, const void *);
53 static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
54 static bfd_boolean prep_headers (bfd *);
55 static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
56 static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
57 static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
58 file_ptr offset);
60 /* Swap version information in and out. The version information is
61 currently size independent. If that ever changes, this code will
62 need to move into elfcode.h. */
64 /* Swap in a Verdef structure. */
66 void
67 _bfd_elf_swap_verdef_in (bfd *abfd,
68 const Elf_External_Verdef *src,
69 Elf_Internal_Verdef *dst)
71 dst->vd_version = H_GET_16 (abfd, src->vd_version);
72 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
73 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
74 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
75 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
76 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
77 dst->vd_next = H_GET_32 (abfd, src->vd_next);
80 /* Swap out a Verdef structure. */
82 void
83 _bfd_elf_swap_verdef_out (bfd *abfd,
84 const Elf_Internal_Verdef *src,
85 Elf_External_Verdef *dst)
87 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
88 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
89 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
90 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
91 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
92 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
93 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
96 /* Swap in a Verdaux structure. */
98 void
99 _bfd_elf_swap_verdaux_in (bfd *abfd,
100 const Elf_External_Verdaux *src,
101 Elf_Internal_Verdaux *dst)
103 dst->vda_name = H_GET_32 (abfd, src->vda_name);
104 dst->vda_next = H_GET_32 (abfd, src->vda_next);
107 /* Swap out a Verdaux structure. */
109 void
110 _bfd_elf_swap_verdaux_out (bfd *abfd,
111 const Elf_Internal_Verdaux *src,
112 Elf_External_Verdaux *dst)
114 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
115 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
118 /* Swap in a Verneed structure. */
120 void
121 _bfd_elf_swap_verneed_in (bfd *abfd,
122 const Elf_External_Verneed *src,
123 Elf_Internal_Verneed *dst)
125 dst->vn_version = H_GET_16 (abfd, src->vn_version);
126 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
127 dst->vn_file = H_GET_32 (abfd, src->vn_file);
128 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
129 dst->vn_next = H_GET_32 (abfd, src->vn_next);
132 /* Swap out a Verneed structure. */
134 void
135 _bfd_elf_swap_verneed_out (bfd *abfd,
136 const Elf_Internal_Verneed *src,
137 Elf_External_Verneed *dst)
139 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
140 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
141 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
142 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
143 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
146 /* Swap in a Vernaux structure. */
148 void
149 _bfd_elf_swap_vernaux_in (bfd *abfd,
150 const Elf_External_Vernaux *src,
151 Elf_Internal_Vernaux *dst)
153 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
154 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
155 dst->vna_other = H_GET_16 (abfd, src->vna_other);
156 dst->vna_name = H_GET_32 (abfd, src->vna_name);
157 dst->vna_next = H_GET_32 (abfd, src->vna_next);
160 /* Swap out a Vernaux structure. */
162 void
163 _bfd_elf_swap_vernaux_out (bfd *abfd,
164 const Elf_Internal_Vernaux *src,
165 Elf_External_Vernaux *dst)
167 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
168 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
169 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
170 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
171 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
174 /* Swap in a Versym structure. */
176 void
177 _bfd_elf_swap_versym_in (bfd *abfd,
178 const Elf_External_Versym *src,
179 Elf_Internal_Versym *dst)
181 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
184 /* Swap out a Versym structure. */
186 void
187 _bfd_elf_swap_versym_out (bfd *abfd,
188 const Elf_Internal_Versym *src,
189 Elf_External_Versym *dst)
191 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
194 /* Standard ELF hash function. Do not change this function; you will
195 cause invalid hash tables to be generated. */
197 unsigned long
198 bfd_elf_hash (const char *namearg)
200 const unsigned char *name = (const unsigned char *) namearg;
201 unsigned long h = 0;
202 unsigned long g;
203 int ch;
205 while ((ch = *name++) != '\0')
207 h = (h << 4) + ch;
208 if ((g = (h & 0xf0000000)) != 0)
210 h ^= g >> 24;
211 /* The ELF ABI says `h &= ~g', but this is equivalent in
212 this case and on some machines one insn instead of two. */
213 h ^= g;
216 return h & 0xffffffff;
219 /* DT_GNU_HASH hash function. Do not change this function; you will
220 cause invalid hash tables to be generated. */
222 unsigned long
223 bfd_elf_gnu_hash (const char *namearg)
225 const unsigned char *name = (const unsigned char *) namearg;
226 unsigned long h = 5381;
227 unsigned char ch;
229 while ((ch = *name++) != '\0')
230 h = (h << 5) + h + ch;
231 return h & 0xffffffff;
234 /* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
235 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
236 bfd_boolean
237 bfd_elf_allocate_object (bfd *abfd,
238 size_t object_size,
239 enum elf_target_id object_id)
241 BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
242 abfd->tdata.any = bfd_zalloc (abfd, object_size);
243 if (abfd->tdata.any == NULL)
244 return FALSE;
246 elf_object_id (abfd) = object_id;
247 elf_program_header_size (abfd) = (bfd_size_type) -1;
248 return TRUE;
252 bfd_boolean
253 bfd_elf_make_object (bfd *abfd)
255 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
256 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
257 bed->target_id);
260 bfd_boolean
261 bfd_elf_mkcorefile (bfd *abfd)
263 /* I think this can be done just like an object file. */
264 return abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd);
267 static char *
268 bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
270 Elf_Internal_Shdr **i_shdrp;
271 bfd_byte *shstrtab = NULL;
272 file_ptr offset;
273 bfd_size_type shstrtabsize;
275 i_shdrp = elf_elfsections (abfd);
276 if (i_shdrp == 0
277 || shindex >= elf_numsections (abfd)
278 || i_shdrp[shindex] == 0)
279 return NULL;
281 shstrtab = i_shdrp[shindex]->contents;
282 if (shstrtab == NULL)
284 /* No cached one, attempt to read, and cache what we read. */
285 offset = i_shdrp[shindex]->sh_offset;
286 shstrtabsize = i_shdrp[shindex]->sh_size;
288 /* Allocate and clear an extra byte at the end, to prevent crashes
289 in case the string table is not terminated. */
290 if (shstrtabsize + 1 <= 1
291 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL
292 || bfd_seek (abfd, offset, SEEK_SET) != 0)
293 shstrtab = NULL;
294 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
296 if (bfd_get_error () != bfd_error_system_call)
297 bfd_set_error (bfd_error_file_truncated);
298 shstrtab = NULL;
299 /* Once we've failed to read it, make sure we don't keep
300 trying. Otherwise, we'll keep allocating space for
301 the string table over and over. */
302 i_shdrp[shindex]->sh_size = 0;
304 else
305 shstrtab[shstrtabsize] = '\0';
306 i_shdrp[shindex]->contents = shstrtab;
308 return (char *) shstrtab;
311 char *
312 bfd_elf_string_from_elf_section (bfd *abfd,
313 unsigned int shindex,
314 unsigned int strindex)
316 Elf_Internal_Shdr *hdr;
318 if (strindex == 0)
319 return "";
321 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
322 return NULL;
324 hdr = elf_elfsections (abfd)[shindex];
326 if (hdr->contents == NULL
327 && bfd_elf_get_str_section (abfd, shindex) == NULL)
328 return NULL;
330 if (strindex >= hdr->sh_size)
332 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
333 (*_bfd_error_handler)
334 (_("%B: invalid string offset %u >= %lu for section `%s'"),
335 abfd, strindex, (unsigned long) hdr->sh_size,
336 (shindex == shstrndx && strindex == hdr->sh_name
337 ? ".shstrtab"
338 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
339 return NULL;
342 return ((char *) hdr->contents) + strindex;
345 /* Read and convert symbols to internal format.
346 SYMCOUNT specifies the number of symbols to read, starting from
347 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
348 are non-NULL, they are used to store the internal symbols, external
349 symbols, and symbol section index extensions, respectively.
350 Returns a pointer to the internal symbol buffer (malloced if necessary)
351 or NULL if there were no symbols or some kind of problem. */
353 Elf_Internal_Sym *
354 bfd_elf_get_elf_syms (bfd *ibfd,
355 Elf_Internal_Shdr *symtab_hdr,
356 size_t symcount,
357 size_t symoffset,
358 Elf_Internal_Sym *intsym_buf,
359 void *extsym_buf,
360 Elf_External_Sym_Shndx *extshndx_buf)
362 Elf_Internal_Shdr *shndx_hdr;
363 void *alloc_ext;
364 const bfd_byte *esym;
365 Elf_External_Sym_Shndx *alloc_extshndx;
366 Elf_External_Sym_Shndx *shndx;
367 Elf_Internal_Sym *alloc_intsym;
368 Elf_Internal_Sym *isym;
369 Elf_Internal_Sym *isymend;
370 const struct elf_backend_data *bed;
371 size_t extsym_size;
372 bfd_size_type amt;
373 file_ptr pos;
375 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
376 abort ();
378 if (symcount == 0)
379 return intsym_buf;
381 /* Normal syms might have section extension entries. */
382 shndx_hdr = NULL;
383 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
384 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
386 /* Read the symbols. */
387 alloc_ext = NULL;
388 alloc_extshndx = NULL;
389 alloc_intsym = NULL;
390 bed = get_elf_backend_data (ibfd);
391 extsym_size = bed->s->sizeof_sym;
392 amt = symcount * extsym_size;
393 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
394 if (extsym_buf == NULL)
396 alloc_ext = bfd_malloc2 (symcount, extsym_size);
397 extsym_buf = alloc_ext;
399 if (extsym_buf == NULL
400 || bfd_seek (ibfd, pos, SEEK_SET) != 0
401 || bfd_bread (extsym_buf, amt, ibfd) != amt)
403 intsym_buf = NULL;
404 goto out;
407 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
408 extshndx_buf = NULL;
409 else
411 amt = symcount * sizeof (Elf_External_Sym_Shndx);
412 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
413 if (extshndx_buf == NULL)
415 alloc_extshndx = (Elf_External_Sym_Shndx *)
416 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
417 extshndx_buf = alloc_extshndx;
419 if (extshndx_buf == NULL
420 || bfd_seek (ibfd, pos, SEEK_SET) != 0
421 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
423 intsym_buf = NULL;
424 goto out;
428 if (intsym_buf == NULL)
430 alloc_intsym = (Elf_Internal_Sym *)
431 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
432 intsym_buf = alloc_intsym;
433 if (intsym_buf == NULL)
434 goto out;
437 /* Convert the symbols to internal form. */
438 isymend = intsym_buf + symcount;
439 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
440 shndx = extshndx_buf;
441 isym < isymend;
442 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
443 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
445 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
446 (*_bfd_error_handler) (_("%B symbol number %lu references "
447 "nonexistent SHT_SYMTAB_SHNDX section"),
448 ibfd, (unsigned long) symoffset);
449 if (alloc_intsym != NULL)
450 free (alloc_intsym);
451 intsym_buf = NULL;
452 goto out;
455 out:
456 if (alloc_ext != NULL)
457 free (alloc_ext);
458 if (alloc_extshndx != NULL)
459 free (alloc_extshndx);
461 return intsym_buf;
464 /* Look up a symbol name. */
465 const char *
466 bfd_elf_sym_name (bfd *abfd,
467 Elf_Internal_Shdr *symtab_hdr,
468 Elf_Internal_Sym *isym,
469 asection *sym_sec)
471 const char *name;
472 unsigned int iname = isym->st_name;
473 unsigned int shindex = symtab_hdr->sh_link;
475 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
476 /* Check for a bogus st_shndx to avoid crashing. */
477 && isym->st_shndx < elf_numsections (abfd))
479 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
480 shindex = elf_elfheader (abfd)->e_shstrndx;
483 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
484 if (name == NULL)
485 name = "(null)";
486 else if (sym_sec && *name == '\0')
487 name = bfd_section_name (abfd, sym_sec);
489 return name;
492 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
493 sections. The first element is the flags, the rest are section
494 pointers. */
496 typedef union elf_internal_group {
497 Elf_Internal_Shdr *shdr;
498 unsigned int flags;
499 } Elf_Internal_Group;
501 /* Return the name of the group signature symbol. Why isn't the
502 signature just a string? */
504 static const char *
505 group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
507 Elf_Internal_Shdr *hdr;
508 unsigned char esym[sizeof (Elf64_External_Sym)];
509 Elf_External_Sym_Shndx eshndx;
510 Elf_Internal_Sym isym;
512 /* First we need to ensure the symbol table is available. Make sure
513 that it is a symbol table section. */
514 if (ghdr->sh_link >= elf_numsections (abfd))
515 return NULL;
516 hdr = elf_elfsections (abfd) [ghdr->sh_link];
517 if (hdr->sh_type != SHT_SYMTAB
518 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
519 return NULL;
521 /* Go read the symbol. */
522 hdr = &elf_tdata (abfd)->symtab_hdr;
523 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
524 &isym, esym, &eshndx) == NULL)
525 return NULL;
527 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
530 /* Set next_in_group list pointer, and group name for NEWSECT. */
532 static bfd_boolean
533 setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
535 unsigned int num_group = elf_tdata (abfd)->num_group;
537 /* If num_group is zero, read in all SHT_GROUP sections. The count
538 is set to -1 if there are no SHT_GROUP sections. */
539 if (num_group == 0)
541 unsigned int i, shnum;
543 /* First count the number of groups. If we have a SHT_GROUP
544 section with just a flag word (ie. sh_size is 4), ignore it. */
545 shnum = elf_numsections (abfd);
546 num_group = 0;
548 #define IS_VALID_GROUP_SECTION_HEADER(shdr) \
549 ( (shdr)->sh_type == SHT_GROUP \
550 && (shdr)->sh_size >= (2 * GRP_ENTRY_SIZE) \
551 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
552 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
554 for (i = 0; i < shnum; i++)
556 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
558 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
559 num_group += 1;
562 if (num_group == 0)
564 num_group = (unsigned) -1;
565 elf_tdata (abfd)->num_group = num_group;
567 else
569 /* We keep a list of elf section headers for group sections,
570 so we can find them quickly. */
571 bfd_size_type amt;
573 elf_tdata (abfd)->num_group = num_group;
574 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
575 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
576 if (elf_tdata (abfd)->group_sect_ptr == NULL)
577 return FALSE;
579 num_group = 0;
580 for (i = 0; i < shnum; i++)
582 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
584 if (IS_VALID_GROUP_SECTION_HEADER (shdr))
586 unsigned char *src;
587 Elf_Internal_Group *dest;
589 /* Add to list of sections. */
590 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
591 num_group += 1;
593 /* Read the raw contents. */
594 BFD_ASSERT (sizeof (*dest) >= 4);
595 amt = shdr->sh_size * sizeof (*dest) / 4;
596 shdr->contents = (unsigned char *)
597 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
598 /* PR binutils/4110: Handle corrupt group headers. */
599 if (shdr->contents == NULL)
601 _bfd_error_handler
602 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
603 bfd_set_error (bfd_error_bad_value);
604 return FALSE;
607 memset (shdr->contents, 0, amt);
609 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
610 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
611 != shdr->sh_size))
612 return FALSE;
614 /* Translate raw contents, a flag word followed by an
615 array of elf section indices all in target byte order,
616 to the flag word followed by an array of elf section
617 pointers. */
618 src = shdr->contents + shdr->sh_size;
619 dest = (Elf_Internal_Group *) (shdr->contents + amt);
620 while (1)
622 unsigned int idx;
624 src -= 4;
625 --dest;
626 idx = H_GET_32 (abfd, src);
627 if (src == shdr->contents)
629 dest->flags = idx;
630 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
631 shdr->bfd_section->flags
632 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
633 break;
635 if (idx >= shnum)
637 ((*_bfd_error_handler)
638 (_("%B: invalid SHT_GROUP entry"), abfd));
639 idx = 0;
641 dest->shdr = elf_elfsections (abfd)[idx];
648 if (num_group != (unsigned) -1)
650 unsigned int i;
652 for (i = 0; i < num_group; i++)
654 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
655 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
656 unsigned int n_elt = shdr->sh_size / 4;
658 /* Look through this group's sections to see if current
659 section is a member. */
660 while (--n_elt != 0)
661 if ((++idx)->shdr == hdr)
663 asection *s = NULL;
665 /* We are a member of this group. Go looking through
666 other members to see if any others are linked via
667 next_in_group. */
668 idx = (Elf_Internal_Group *) shdr->contents;
669 n_elt = shdr->sh_size / 4;
670 while (--n_elt != 0)
671 if ((s = (++idx)->shdr->bfd_section) != NULL
672 && elf_next_in_group (s) != NULL)
673 break;
674 if (n_elt != 0)
676 /* Snarf the group name from other member, and
677 insert current section in circular list. */
678 elf_group_name (newsect) = elf_group_name (s);
679 elf_next_in_group (newsect) = elf_next_in_group (s);
680 elf_next_in_group (s) = newsect;
682 else
684 const char *gname;
686 gname = group_signature (abfd, shdr);
687 if (gname == NULL)
688 return FALSE;
689 elf_group_name (newsect) = gname;
691 /* Start a circular list with one element. */
692 elf_next_in_group (newsect) = newsect;
695 /* If the group section has been created, point to the
696 new member. */
697 if (shdr->bfd_section != NULL)
698 elf_next_in_group (shdr->bfd_section) = newsect;
700 i = num_group - 1;
701 break;
706 if (elf_group_name (newsect) == NULL)
708 (*_bfd_error_handler) (_("%B: no group info for section %A"),
709 abfd, newsect);
711 return TRUE;
714 bfd_boolean
715 _bfd_elf_setup_sections (bfd *abfd)
717 unsigned int i;
718 unsigned int num_group = elf_tdata (abfd)->num_group;
719 bfd_boolean result = TRUE;
720 asection *s;
722 /* Process SHF_LINK_ORDER. */
723 for (s = abfd->sections; s != NULL; s = s->next)
725 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
726 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
728 unsigned int elfsec = this_hdr->sh_link;
729 /* FIXME: The old Intel compiler and old strip/objcopy may
730 not set the sh_link or sh_info fields. Hence we could
731 get the situation where elfsec is 0. */
732 if (elfsec == 0)
734 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
735 if (bed->link_order_error_handler)
736 bed->link_order_error_handler
737 (_("%B: warning: sh_link not set for section `%A'"),
738 abfd, s);
740 else
742 asection *linksec = NULL;
744 if (elfsec < elf_numsections (abfd))
746 this_hdr = elf_elfsections (abfd)[elfsec];
747 linksec = this_hdr->bfd_section;
750 /* PR 1991, 2008:
751 Some strip/objcopy may leave an incorrect value in
752 sh_link. We don't want to proceed. */
753 if (linksec == NULL)
755 (*_bfd_error_handler)
756 (_("%B: sh_link [%d] in section `%A' is incorrect"),
757 s->owner, s, elfsec);
758 result = FALSE;
761 elf_linked_to_section (s) = linksec;
766 /* Process section groups. */
767 if (num_group == (unsigned) -1)
768 return result;
770 for (i = 0; i < num_group; i++)
772 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
773 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
774 unsigned int n_elt = shdr->sh_size / 4;
776 while (--n_elt != 0)
777 if ((++idx)->shdr->bfd_section)
778 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
779 else if (idx->shdr->sh_type == SHT_RELA
780 || idx->shdr->sh_type == SHT_REL)
781 /* We won't include relocation sections in section groups in
782 output object files. We adjust the group section size here
783 so that relocatable link will work correctly when
784 relocation sections are in section group in input object
785 files. */
786 shdr->bfd_section->size -= 4;
787 else
789 /* There are some unknown sections in the group. */
790 (*_bfd_error_handler)
791 (_("%B: unknown [%d] section `%s' in group [%s]"),
792 abfd,
793 (unsigned int) idx->shdr->sh_type,
794 bfd_elf_string_from_elf_section (abfd,
795 (elf_elfheader (abfd)
796 ->e_shstrndx),
797 idx->shdr->sh_name),
798 shdr->bfd_section->name);
799 result = FALSE;
802 return result;
805 bfd_boolean
806 bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
808 return elf_next_in_group (sec) != NULL;
811 /* Make a BFD section from an ELF section. We store a pointer to the
812 BFD section in the bfd_section field of the header. */
814 bfd_boolean
815 _bfd_elf_make_section_from_shdr (bfd *abfd,
816 Elf_Internal_Shdr *hdr,
817 const char *name,
818 int shindex)
820 asection *newsect;
821 flagword flags;
822 const struct elf_backend_data *bed;
824 if (hdr->bfd_section != NULL)
825 return TRUE;
827 newsect = bfd_make_section_anyway (abfd, name);
828 if (newsect == NULL)
829 return FALSE;
831 hdr->bfd_section = newsect;
832 elf_section_data (newsect)->this_hdr = *hdr;
833 elf_section_data (newsect)->this_idx = shindex;
835 /* Always use the real type/flags. */
836 elf_section_type (newsect) = hdr->sh_type;
837 elf_section_flags (newsect) = hdr->sh_flags;
839 newsect->filepos = hdr->sh_offset;
841 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
842 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
843 || ! bfd_set_section_alignment (abfd, newsect,
844 bfd_log2 (hdr->sh_addralign)))
845 return FALSE;
847 flags = SEC_NO_FLAGS;
848 if (hdr->sh_type != SHT_NOBITS)
849 flags |= SEC_HAS_CONTENTS;
850 if (hdr->sh_type == SHT_GROUP)
851 flags |= SEC_GROUP | SEC_EXCLUDE;
852 if ((hdr->sh_flags & SHF_ALLOC) != 0)
854 flags |= SEC_ALLOC;
855 if (hdr->sh_type != SHT_NOBITS)
856 flags |= SEC_LOAD;
858 if ((hdr->sh_flags & SHF_WRITE) == 0)
859 flags |= SEC_READONLY;
860 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
861 flags |= SEC_CODE;
862 else if ((flags & SEC_LOAD) != 0)
863 flags |= SEC_DATA;
864 if ((hdr->sh_flags & SHF_MERGE) != 0)
866 flags |= SEC_MERGE;
867 newsect->entsize = hdr->sh_entsize;
868 if ((hdr->sh_flags & SHF_STRINGS) != 0)
869 flags |= SEC_STRINGS;
871 if (hdr->sh_flags & SHF_GROUP)
872 if (!setup_group (abfd, hdr, newsect))
873 return FALSE;
874 if ((hdr->sh_flags & SHF_TLS) != 0)
875 flags |= SEC_THREAD_LOCAL;
876 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
877 flags |= SEC_EXCLUDE;
879 if ((flags & SEC_ALLOC) == 0)
881 /* The debugging sections appear to be recognized only by name,
882 not any sort of flag. Their SEC_ALLOC bits are cleared. */
883 static const struct
885 const char *name;
886 int len;
887 } debug_sections [] =
889 { STRING_COMMA_LEN ("debug") }, /* 'd' */
890 { NULL, 0 }, /* 'e' */
891 { NULL, 0 }, /* 'f' */
892 { STRING_COMMA_LEN ("gnu.linkonce.wi.") }, /* 'g' */
893 { NULL, 0 }, /* 'h' */
894 { NULL, 0 }, /* 'i' */
895 { NULL, 0 }, /* 'j' */
896 { NULL, 0 }, /* 'k' */
897 { STRING_COMMA_LEN ("line") }, /* 'l' */
898 { NULL, 0 }, /* 'm' */
899 { NULL, 0 }, /* 'n' */
900 { NULL, 0 }, /* 'o' */
901 { NULL, 0 }, /* 'p' */
902 { NULL, 0 }, /* 'q' */
903 { NULL, 0 }, /* 'r' */
904 { STRING_COMMA_LEN ("stab") }, /* 's' */
905 { NULL, 0 }, /* 't' */
906 { NULL, 0 }, /* 'u' */
907 { NULL, 0 }, /* 'v' */
908 { NULL, 0 }, /* 'w' */
909 { NULL, 0 }, /* 'x' */
910 { NULL, 0 }, /* 'y' */
911 { STRING_COMMA_LEN ("zdebug") } /* 'z' */
914 if (name [0] == '.')
916 int i = name [1] - 'd';
917 if (i >= 0
918 && i < (int) ARRAY_SIZE (debug_sections)
919 && debug_sections [i].name != NULL
920 && strncmp (&name [1], debug_sections [i].name,
921 debug_sections [i].len) == 0)
922 flags |= SEC_DEBUGGING;
926 /* As a GNU extension, if the name begins with .gnu.linkonce, we
927 only link a single copy of the section. This is used to support
928 g++. g++ will emit each template expansion in its own section.
929 The symbols will be defined as weak, so that multiple definitions
930 are permitted. The GNU linker extension is to actually discard
931 all but one of the sections. */
932 if (CONST_STRNEQ (name, ".gnu.linkonce")
933 && elf_next_in_group (newsect) == NULL)
934 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
936 bed = get_elf_backend_data (abfd);
937 if (bed->elf_backend_section_flags)
938 if (! bed->elf_backend_section_flags (&flags, hdr))
939 return FALSE;
941 if (! bfd_set_section_flags (abfd, newsect, flags))
942 return FALSE;
944 /* We do not parse the PT_NOTE segments as we are interested even in the
945 separate debug info files which may have the segments offsets corrupted.
946 PT_NOTEs from the core files are currently not parsed using BFD. */
947 if (hdr->sh_type == SHT_NOTE)
949 bfd_byte *contents;
951 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
952 return FALSE;
954 elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1);
955 free (contents);
958 if ((flags & SEC_ALLOC) != 0)
960 Elf_Internal_Phdr *phdr;
961 unsigned int i, nload;
963 /* Some ELF linkers produce binaries with all the program header
964 p_paddr fields zero. If we have such a binary with more than
965 one PT_LOAD header, then leave the section lma equal to vma
966 so that we don't create sections with overlapping lma. */
967 phdr = elf_tdata (abfd)->phdr;
968 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
969 if (phdr->p_paddr != 0)
970 break;
971 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
972 ++nload;
973 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
974 return TRUE;
976 phdr = elf_tdata (abfd)->phdr;
977 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
979 if (((phdr->p_type == PT_LOAD
980 && (hdr->sh_flags & SHF_TLS) == 0)
981 || phdr->p_type == PT_TLS)
982 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
984 if ((flags & SEC_LOAD) == 0)
985 newsect->lma = (phdr->p_paddr
986 + hdr->sh_addr - phdr->p_vaddr);
987 else
988 /* We used to use the same adjustment for SEC_LOAD
989 sections, but that doesn't work if the segment
990 is packed with code from multiple VMAs.
991 Instead we calculate the section LMA based on
992 the segment LMA. It is assumed that the
993 segment will contain sections with contiguous
994 LMAs, even if the VMAs are not. */
995 newsect->lma = (phdr->p_paddr
996 + hdr->sh_offset - phdr->p_offset);
998 /* With contiguous segments, we can't tell from file
999 offsets whether a section with zero size should
1000 be placed at the end of one segment or the
1001 beginning of the next. Decide based on vaddr. */
1002 if (hdr->sh_addr >= phdr->p_vaddr
1003 && (hdr->sh_addr + hdr->sh_size
1004 <= phdr->p_vaddr + phdr->p_memsz))
1005 break;
1010 /* Compress/decompress DWARF debug sections with names: .debug_* and
1011 .zdebug_*, after the section flags is set. */
1012 if ((flags & SEC_DEBUGGING)
1013 && ((name[1] == 'd' && name[6] == '_')
1014 || (name[1] == 'z' && name[7] == '_')))
1016 enum { nothing, compress, decompress } action = nothing;
1017 char *new_name;
1019 if (bfd_is_section_compressed (abfd, newsect))
1021 /* Compressed section. Check if we should decompress. */
1022 if ((abfd->flags & BFD_DECOMPRESS))
1023 action = decompress;
1025 else
1027 /* Normal section. Check if we should compress. */
1028 if ((abfd->flags & BFD_COMPRESS))
1029 action = compress;
1032 new_name = NULL;
1033 switch (action)
1035 case nothing:
1036 break;
1037 case compress:
1038 if (!bfd_init_section_compress_status (abfd, newsect))
1040 (*_bfd_error_handler)
1041 (_("%B: unable to initialize commpress status for section %s"),
1042 abfd, name);
1043 return FALSE;
1045 if (name[1] != 'z')
1047 unsigned int len = strlen (name);
1049 new_name = bfd_alloc (abfd, len + 2);
1050 if (new_name == NULL)
1051 return FALSE;
1052 new_name[0] = '.';
1053 new_name[1] = 'z';
1054 memcpy (new_name + 2, name + 1, len);
1056 break;
1057 case decompress:
1058 if (!bfd_init_section_decompress_status (abfd, newsect))
1060 (*_bfd_error_handler)
1061 (_("%B: unable to initialize decommpress status for section %s"),
1062 abfd, name);
1063 return FALSE;
1065 if (name[1] == 'z')
1067 unsigned int len = strlen (name);
1069 new_name = bfd_alloc (abfd, len);
1070 if (new_name == NULL)
1071 return FALSE;
1072 new_name[0] = '.';
1073 memcpy (new_name + 1, name + 2, len - 1);
1075 break;
1077 if (new_name != NULL)
1078 bfd_rename_section (abfd, newsect, new_name);
1081 return TRUE;
1084 const char *const bfd_elf_section_type_names[] = {
1085 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1086 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1087 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1090 /* ELF relocs are against symbols. If we are producing relocatable
1091 output, and the reloc is against an external symbol, and nothing
1092 has given us any additional addend, the resulting reloc will also
1093 be against the same symbol. In such a case, we don't want to
1094 change anything about the way the reloc is handled, since it will
1095 all be done at final link time. Rather than put special case code
1096 into bfd_perform_relocation, all the reloc types use this howto
1097 function. It just short circuits the reloc if producing
1098 relocatable output against an external symbol. */
1100 bfd_reloc_status_type
1101 bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1102 arelent *reloc_entry,
1103 asymbol *symbol,
1104 void *data ATTRIBUTE_UNUSED,
1105 asection *input_section,
1106 bfd *output_bfd,
1107 char **error_message ATTRIBUTE_UNUSED)
1109 if (output_bfd != NULL
1110 && (symbol->flags & BSF_SECTION_SYM) == 0
1111 && (! reloc_entry->howto->partial_inplace
1112 || reloc_entry->addend == 0))
1114 reloc_entry->address += input_section->output_offset;
1115 return bfd_reloc_ok;
1118 return bfd_reloc_continue;
1121 /* Copy the program header and other data from one object module to
1122 another. */
1124 bfd_boolean
1125 _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
1127 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1128 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1129 return TRUE;
1131 BFD_ASSERT (!elf_flags_init (obfd)
1132 || (elf_elfheader (obfd)->e_flags
1133 == elf_elfheader (ibfd)->e_flags));
1135 elf_gp (obfd) = elf_gp (ibfd);
1136 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1137 elf_flags_init (obfd) = TRUE;
1139 /* Copy object attributes. */
1140 _bfd_elf_copy_obj_attributes (ibfd, obfd);
1141 return TRUE;
1144 static const char *
1145 get_segment_type (unsigned int p_type)
1147 const char *pt;
1148 switch (p_type)
1150 case PT_NULL: pt = "NULL"; break;
1151 case PT_LOAD: pt = "LOAD"; break;
1152 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1153 case PT_INTERP: pt = "INTERP"; break;
1154 case PT_NOTE: pt = "NOTE"; break;
1155 case PT_SHLIB: pt = "SHLIB"; break;
1156 case PT_PHDR: pt = "PHDR"; break;
1157 case PT_TLS: pt = "TLS"; break;
1158 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1159 case PT_GNU_STACK: pt = "STACK"; break;
1160 case PT_GNU_RELRO: pt = "RELRO"; break;
1161 default: pt = NULL; break;
1163 return pt;
1166 /* Print out the program headers. */
1168 bfd_boolean
1169 _bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
1171 FILE *f = (FILE *) farg;
1172 Elf_Internal_Phdr *p;
1173 asection *s;
1174 bfd_byte *dynbuf = NULL;
1176 p = elf_tdata (abfd)->phdr;
1177 if (p != NULL)
1179 unsigned int i, c;
1181 fprintf (f, _("\nProgram Header:\n"));
1182 c = elf_elfheader (abfd)->e_phnum;
1183 for (i = 0; i < c; i++, p++)
1185 const char *pt = get_segment_type (p->p_type);
1186 char buf[20];
1188 if (pt == NULL)
1190 sprintf (buf, "0x%lx", p->p_type);
1191 pt = buf;
1193 fprintf (f, "%8s off 0x", pt);
1194 bfd_fprintf_vma (abfd, f, p->p_offset);
1195 fprintf (f, " vaddr 0x");
1196 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1197 fprintf (f, " paddr 0x");
1198 bfd_fprintf_vma (abfd, f, p->p_paddr);
1199 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1200 fprintf (f, " filesz 0x");
1201 bfd_fprintf_vma (abfd, f, p->p_filesz);
1202 fprintf (f, " memsz 0x");
1203 bfd_fprintf_vma (abfd, f, p->p_memsz);
1204 fprintf (f, " flags %c%c%c",
1205 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1206 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1207 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1208 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1209 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1210 fprintf (f, "\n");
1214 s = bfd_get_section_by_name (abfd, ".dynamic");
1215 if (s != NULL)
1217 unsigned int elfsec;
1218 unsigned long shlink;
1219 bfd_byte *extdyn, *extdynend;
1220 size_t extdynsize;
1221 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
1223 fprintf (f, _("\nDynamic Section:\n"));
1225 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
1226 goto error_return;
1228 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1229 if (elfsec == SHN_BAD)
1230 goto error_return;
1231 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1233 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1234 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1236 extdyn = dynbuf;
1237 extdynend = extdyn + s->size;
1238 for (; extdyn < extdynend; extdyn += extdynsize)
1240 Elf_Internal_Dyn dyn;
1241 const char *name = "";
1242 char ab[20];
1243 bfd_boolean stringp;
1244 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1246 (*swap_dyn_in) (abfd, extdyn, &dyn);
1248 if (dyn.d_tag == DT_NULL)
1249 break;
1251 stringp = FALSE;
1252 switch (dyn.d_tag)
1254 default:
1255 if (bed->elf_backend_get_target_dtag)
1256 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1258 if (!strcmp (name, ""))
1260 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1261 name = ab;
1263 break;
1265 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
1266 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1267 case DT_PLTGOT: name = "PLTGOT"; break;
1268 case DT_HASH: name = "HASH"; break;
1269 case DT_STRTAB: name = "STRTAB"; break;
1270 case DT_SYMTAB: name = "SYMTAB"; break;
1271 case DT_RELA: name = "RELA"; break;
1272 case DT_RELASZ: name = "RELASZ"; break;
1273 case DT_RELAENT: name = "RELAENT"; break;
1274 case DT_STRSZ: name = "STRSZ"; break;
1275 case DT_SYMENT: name = "SYMENT"; break;
1276 case DT_INIT: name = "INIT"; break;
1277 case DT_FINI: name = "FINI"; break;
1278 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1279 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
1280 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1281 case DT_REL: name = "REL"; break;
1282 case DT_RELSZ: name = "RELSZ"; break;
1283 case DT_RELENT: name = "RELENT"; break;
1284 case DT_PLTREL: name = "PLTREL"; break;
1285 case DT_DEBUG: name = "DEBUG"; break;
1286 case DT_TEXTREL: name = "TEXTREL"; break;
1287 case DT_JMPREL: name = "JMPREL"; break;
1288 case DT_BIND_NOW: name = "BIND_NOW"; break;
1289 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1290 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1291 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1292 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1293 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
1294 case DT_FLAGS: name = "FLAGS"; break;
1295 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1296 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1297 case DT_CHECKSUM: name = "CHECKSUM"; break;
1298 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1299 case DT_MOVEENT: name = "MOVEENT"; break;
1300 case DT_MOVESZ: name = "MOVESZ"; break;
1301 case DT_FEATURE: name = "FEATURE"; break;
1302 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1303 case DT_SYMINSZ: name = "SYMINSZ"; break;
1304 case DT_SYMINENT: name = "SYMINENT"; break;
1305 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1306 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1307 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
1308 case DT_PLTPAD: name = "PLTPAD"; break;
1309 case DT_MOVETAB: name = "MOVETAB"; break;
1310 case DT_SYMINFO: name = "SYMINFO"; break;
1311 case DT_RELACOUNT: name = "RELACOUNT"; break;
1312 case DT_RELCOUNT: name = "RELCOUNT"; break;
1313 case DT_FLAGS_1: name = "FLAGS_1"; break;
1314 case DT_VERSYM: name = "VERSYM"; break;
1315 case DT_VERDEF: name = "VERDEF"; break;
1316 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1317 case DT_VERNEED: name = "VERNEED"; break;
1318 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1319 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
1320 case DT_USED: name = "USED"; break;
1321 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
1322 case DT_GNU_HASH: name = "GNU_HASH"; break;
1325 fprintf (f, " %-20s ", name);
1326 if (! stringp)
1328 fprintf (f, "0x");
1329 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1331 else
1333 const char *string;
1334 unsigned int tagv = dyn.d_un.d_val;
1336 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1337 if (string == NULL)
1338 goto error_return;
1339 fprintf (f, "%s", string);
1341 fprintf (f, "\n");
1344 free (dynbuf);
1345 dynbuf = NULL;
1348 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1349 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1351 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
1352 return FALSE;
1355 if (elf_dynverdef (abfd) != 0)
1357 Elf_Internal_Verdef *t;
1359 fprintf (f, _("\nVersion definitions:\n"));
1360 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1362 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1363 t->vd_flags, t->vd_hash,
1364 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1365 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
1367 Elf_Internal_Verdaux *a;
1369 fprintf (f, "\t");
1370 for (a = t->vd_auxptr->vda_nextptr;
1371 a != NULL;
1372 a = a->vda_nextptr)
1373 fprintf (f, "%s ",
1374 a->vda_nodename ? a->vda_nodename : "<corrupt>");
1375 fprintf (f, "\n");
1380 if (elf_dynverref (abfd) != 0)
1382 Elf_Internal_Verneed *t;
1384 fprintf (f, _("\nVersion References:\n"));
1385 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1387 Elf_Internal_Vernaux *a;
1389 fprintf (f, _(" required from %s:\n"),
1390 t->vn_filename ? t->vn_filename : "<corrupt>");
1391 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1392 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1393 a->vna_flags, a->vna_other,
1394 a->vna_nodename ? a->vna_nodename : "<corrupt>");
1398 return TRUE;
1400 error_return:
1401 if (dynbuf != NULL)
1402 free (dynbuf);
1403 return FALSE;
1406 /* Display ELF-specific fields of a symbol. */
1408 void
1409 bfd_elf_print_symbol (bfd *abfd,
1410 void *filep,
1411 asymbol *symbol,
1412 bfd_print_symbol_type how)
1414 FILE *file = (FILE *) filep;
1415 switch (how)
1417 case bfd_print_symbol_name:
1418 fprintf (file, "%s", symbol->name);
1419 break;
1420 case bfd_print_symbol_more:
1421 fprintf (file, "elf ");
1422 bfd_fprintf_vma (abfd, file, symbol->value);
1423 fprintf (file, " %lx", (unsigned long) symbol->flags);
1424 break;
1425 case bfd_print_symbol_all:
1427 const char *section_name;
1428 const char *name = NULL;
1429 const struct elf_backend_data *bed;
1430 unsigned char st_other;
1431 bfd_vma val;
1433 section_name = symbol->section ? symbol->section->name : "(*none*)";
1435 bed = get_elf_backend_data (abfd);
1436 if (bed->elf_backend_print_symbol_all)
1437 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1439 if (name == NULL)
1441 name = symbol->name;
1442 bfd_print_symbol_vandf (abfd, file, symbol);
1445 fprintf (file, " %s\t", section_name);
1446 /* Print the "other" value for a symbol. For common symbols,
1447 we've already printed the size; now print the alignment.
1448 For other symbols, we have no specified alignment, and
1449 we've printed the address; now print the size. */
1450 if (symbol->section && bfd_is_com_section (symbol->section))
1451 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1452 else
1453 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1454 bfd_fprintf_vma (abfd, file, val);
1456 /* If we have version information, print it. */
1457 if (elf_tdata (abfd)->dynversym_section != 0
1458 && (elf_tdata (abfd)->dynverdef_section != 0
1459 || elf_tdata (abfd)->dynverref_section != 0))
1461 unsigned int vernum;
1462 const char *version_string;
1464 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1466 if (vernum == 0)
1467 version_string = "";
1468 else if (vernum == 1)
1469 version_string = "Base";
1470 else if (vernum <= elf_tdata (abfd)->cverdefs)
1471 version_string =
1472 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1473 else
1475 Elf_Internal_Verneed *t;
1477 version_string = "";
1478 for (t = elf_tdata (abfd)->verref;
1479 t != NULL;
1480 t = t->vn_nextref)
1482 Elf_Internal_Vernaux *a;
1484 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1486 if (a->vna_other == vernum)
1488 version_string = a->vna_nodename;
1489 break;
1495 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1496 fprintf (file, " %-11s", version_string);
1497 else
1499 int i;
1501 fprintf (file, " (%s)", version_string);
1502 for (i = 10 - strlen (version_string); i > 0; --i)
1503 putc (' ', file);
1507 /* If the st_other field is not zero, print it. */
1508 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1510 switch (st_other)
1512 case 0: break;
1513 case STV_INTERNAL: fprintf (file, " .internal"); break;
1514 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1515 case STV_PROTECTED: fprintf (file, " .protected"); break;
1516 default:
1517 /* Some other non-defined flags are also present, so print
1518 everything hex. */
1519 fprintf (file, " 0x%02x", (unsigned int) st_other);
1522 fprintf (file, " %s", name);
1524 break;
1528 /* Allocate an ELF string table--force the first byte to be zero. */
1530 struct bfd_strtab_hash *
1531 _bfd_elf_stringtab_init (void)
1533 struct bfd_strtab_hash *ret;
1535 ret = _bfd_stringtab_init ();
1536 if (ret != NULL)
1538 bfd_size_type loc;
1540 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
1541 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1542 if (loc == (bfd_size_type) -1)
1544 _bfd_stringtab_free (ret);
1545 ret = NULL;
1548 return ret;
1551 /* ELF .o/exec file reading */
1553 /* Create a new bfd section from an ELF section header. */
1555 bfd_boolean
1556 bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
1558 Elf_Internal_Shdr *hdr;
1559 Elf_Internal_Ehdr *ehdr;
1560 const struct elf_backend_data *bed;
1561 const char *name;
1563 if (shindex >= elf_numsections (abfd))
1564 return FALSE;
1566 hdr = elf_elfsections (abfd)[shindex];
1567 ehdr = elf_elfheader (abfd);
1568 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1569 hdr->sh_name);
1570 if (name == NULL)
1571 return FALSE;
1573 bed = get_elf_backend_data (abfd);
1574 switch (hdr->sh_type)
1576 case SHT_NULL:
1577 /* Inactive section. Throw it away. */
1578 return TRUE;
1580 case SHT_PROGBITS: /* Normal section with contents. */
1581 case SHT_NOBITS: /* .bss section. */
1582 case SHT_HASH: /* .hash section. */
1583 case SHT_NOTE: /* .note section. */
1584 case SHT_INIT_ARRAY: /* .init_array section. */
1585 case SHT_FINI_ARRAY: /* .fini_array section. */
1586 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1587 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
1588 case SHT_GNU_HASH: /* .gnu.hash section. */
1589 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1591 case SHT_DYNAMIC: /* Dynamic linking information. */
1592 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1593 return FALSE;
1594 if (hdr->sh_link > elf_numsections (abfd))
1596 /* PR 10478: Accept Solaris binaries with a sh_link
1597 field set to SHN_BEFORE or SHN_AFTER. */
1598 switch (bfd_get_arch (abfd))
1600 case bfd_arch_i386:
1601 case bfd_arch_sparc:
1602 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1603 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1604 break;
1605 /* Otherwise fall through. */
1606 default:
1607 return FALSE;
1610 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
1611 return FALSE;
1612 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1614 Elf_Internal_Shdr *dynsymhdr;
1616 /* The shared libraries distributed with hpux11 have a bogus
1617 sh_link field for the ".dynamic" section. Find the
1618 string table for the ".dynsym" section instead. */
1619 if (elf_dynsymtab (abfd) != 0)
1621 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1622 hdr->sh_link = dynsymhdr->sh_link;
1624 else
1626 unsigned int i, num_sec;
1628 num_sec = elf_numsections (abfd);
1629 for (i = 1; i < num_sec; i++)
1631 dynsymhdr = elf_elfsections (abfd)[i];
1632 if (dynsymhdr->sh_type == SHT_DYNSYM)
1634 hdr->sh_link = dynsymhdr->sh_link;
1635 break;
1640 break;
1642 case SHT_SYMTAB: /* A symbol table */
1643 if (elf_onesymtab (abfd) == shindex)
1644 return TRUE;
1646 if (hdr->sh_entsize != bed->s->sizeof_sym)
1647 return FALSE;
1648 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
1649 return FALSE;
1650 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1651 elf_onesymtab (abfd) = shindex;
1652 elf_tdata (abfd)->symtab_hdr = *hdr;
1653 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1654 abfd->flags |= HAS_SYMS;
1656 /* Sometimes a shared object will map in the symbol table. If
1657 SHF_ALLOC is set, and this is a shared object, then we also
1658 treat this section as a BFD section. We can not base the
1659 decision purely on SHF_ALLOC, because that flag is sometimes
1660 set in a relocatable object file, which would confuse the
1661 linker. */
1662 if ((hdr->sh_flags & SHF_ALLOC) != 0
1663 && (abfd->flags & DYNAMIC) != 0
1664 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1665 shindex))
1666 return FALSE;
1668 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1669 can't read symbols without that section loaded as well. It
1670 is most likely specified by the next section header. */
1671 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1673 unsigned int i, num_sec;
1675 num_sec = elf_numsections (abfd);
1676 for (i = shindex + 1; i < num_sec; i++)
1678 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1679 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1680 && hdr2->sh_link == shindex)
1681 break;
1683 if (i == num_sec)
1684 for (i = 1; i < shindex; i++)
1686 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1687 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1688 && hdr2->sh_link == shindex)
1689 break;
1691 if (i != shindex)
1692 return bfd_section_from_shdr (abfd, i);
1694 return TRUE;
1696 case SHT_DYNSYM: /* A dynamic symbol table */
1697 if (elf_dynsymtab (abfd) == shindex)
1698 return TRUE;
1700 if (hdr->sh_entsize != bed->s->sizeof_sym)
1701 return FALSE;
1702 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1703 elf_dynsymtab (abfd) = shindex;
1704 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1705 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1706 abfd->flags |= HAS_SYMS;
1708 /* Besides being a symbol table, we also treat this as a regular
1709 section, so that objcopy can handle it. */
1710 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1712 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1713 if (elf_symtab_shndx (abfd) == shindex)
1714 return TRUE;
1716 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
1717 elf_symtab_shndx (abfd) = shindex;
1718 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1719 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1720 return TRUE;
1722 case SHT_STRTAB: /* A string table */
1723 if (hdr->bfd_section != NULL)
1724 return TRUE;
1725 if (ehdr->e_shstrndx == shindex)
1727 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1728 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1729 return TRUE;
1731 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1733 symtab_strtab:
1734 elf_tdata (abfd)->strtab_hdr = *hdr;
1735 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1736 return TRUE;
1738 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1740 dynsymtab_strtab:
1741 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1742 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1743 elf_elfsections (abfd)[shindex] = hdr;
1744 /* We also treat this as a regular section, so that objcopy
1745 can handle it. */
1746 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1747 shindex);
1750 /* If the string table isn't one of the above, then treat it as a
1751 regular section. We need to scan all the headers to be sure,
1752 just in case this strtab section appeared before the above. */
1753 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1755 unsigned int i, num_sec;
1757 num_sec = elf_numsections (abfd);
1758 for (i = 1; i < num_sec; i++)
1760 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1761 if (hdr2->sh_link == shindex)
1763 /* Prevent endless recursion on broken objects. */
1764 if (i == shindex)
1765 return FALSE;
1766 if (! bfd_section_from_shdr (abfd, i))
1767 return FALSE;
1768 if (elf_onesymtab (abfd) == i)
1769 goto symtab_strtab;
1770 if (elf_dynsymtab (abfd) == i)
1771 goto dynsymtab_strtab;
1775 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1777 case SHT_REL:
1778 case SHT_RELA:
1779 /* *These* do a lot of work -- but build no sections! */
1781 asection *target_sect;
1782 Elf_Internal_Shdr *hdr2, **p_hdr;
1783 unsigned int num_sec = elf_numsections (abfd);
1784 struct bfd_elf_section_data *esdt;
1785 bfd_size_type amt;
1787 if (hdr->sh_entsize
1788 != (bfd_size_type) (hdr->sh_type == SHT_REL
1789 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1790 return FALSE;
1792 /* Check for a bogus link to avoid crashing. */
1793 if (hdr->sh_link >= num_sec)
1795 ((*_bfd_error_handler)
1796 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1797 abfd, hdr->sh_link, name, shindex));
1798 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1799 shindex);
1802 /* For some incomprehensible reason Oracle distributes
1803 libraries for Solaris in which some of the objects have
1804 bogus sh_link fields. It would be nice if we could just
1805 reject them, but, unfortunately, some people need to use
1806 them. We scan through the section headers; if we find only
1807 one suitable symbol table, we clobber the sh_link to point
1808 to it. I hope this doesn't break anything.
1810 Don't do it on executable nor shared library. */
1811 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
1812 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1813 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1815 unsigned int scan;
1816 int found;
1818 found = 0;
1819 for (scan = 1; scan < num_sec; scan++)
1821 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1822 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1824 if (found != 0)
1826 found = 0;
1827 break;
1829 found = scan;
1832 if (found != 0)
1833 hdr->sh_link = found;
1836 /* Get the symbol table. */
1837 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1838 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
1839 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1840 return FALSE;
1842 /* If this reloc section does not use the main symbol table we
1843 don't treat it as a reloc section. BFD can't adequately
1844 represent such a section, so at least for now, we don't
1845 try. We just present it as a normal section. We also
1846 can't use it as a reloc section if it points to the null
1847 section, an invalid section, another reloc section, or its
1848 sh_link points to the null section. */
1849 if (hdr->sh_link != elf_onesymtab (abfd)
1850 || hdr->sh_link == SHN_UNDEF
1851 || hdr->sh_info == SHN_UNDEF
1852 || hdr->sh_info >= num_sec
1853 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1854 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
1855 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1856 shindex);
1858 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1859 return FALSE;
1860 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1861 if (target_sect == NULL)
1862 return FALSE;
1864 esdt = elf_section_data (target_sect);
1865 if (hdr->sh_type == SHT_RELA)
1866 p_hdr = &esdt->rela.hdr;
1867 else
1868 p_hdr = &esdt->rel.hdr;
1870 BFD_ASSERT (*p_hdr == NULL);
1871 amt = sizeof (*hdr2);
1872 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1873 if (hdr2 == NULL)
1874 return FALSE;
1875 *hdr2 = *hdr;
1876 *p_hdr = hdr2;
1877 elf_elfsections (abfd)[shindex] = hdr2;
1878 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1879 target_sect->flags |= SEC_RELOC;
1880 target_sect->relocation = NULL;
1881 target_sect->rel_filepos = hdr->sh_offset;
1882 /* In the section to which the relocations apply, mark whether
1883 its relocations are of the REL or RELA variety. */
1884 if (hdr->sh_size != 0)
1886 if (hdr->sh_type == SHT_RELA)
1887 target_sect->use_rela_p = 1;
1889 abfd->flags |= HAS_RELOC;
1890 return TRUE;
1893 case SHT_GNU_verdef:
1894 elf_dynverdef (abfd) = shindex;
1895 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1896 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1898 case SHT_GNU_versym:
1899 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1900 return FALSE;
1901 elf_dynversym (abfd) = shindex;
1902 elf_tdata (abfd)->dynversym_hdr = *hdr;
1903 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1905 case SHT_GNU_verneed:
1906 elf_dynverref (abfd) = shindex;
1907 elf_tdata (abfd)->dynverref_hdr = *hdr;
1908 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1910 case SHT_SHLIB:
1911 return TRUE;
1913 case SHT_GROUP:
1914 if (! IS_VALID_GROUP_SECTION_HEADER (hdr))
1915 return FALSE;
1916 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1917 return FALSE;
1918 if (hdr->contents != NULL)
1920 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1921 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
1922 asection *s;
1924 if (idx->flags & GRP_COMDAT)
1925 hdr->bfd_section->flags
1926 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1928 /* We try to keep the same section order as it comes in. */
1929 idx += n_elt;
1930 while (--n_elt != 0)
1932 --idx;
1934 if (idx->shdr != NULL
1935 && (s = idx->shdr->bfd_section) != NULL
1936 && elf_next_in_group (s) != NULL)
1938 elf_next_in_group (hdr->bfd_section) = s;
1939 break;
1943 break;
1945 default:
1946 /* Possibly an attributes section. */
1947 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1948 || hdr->sh_type == bed->obj_attrs_section_type)
1950 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1951 return FALSE;
1952 _bfd_elf_parse_attributes (abfd, hdr);
1953 return TRUE;
1956 /* Check for any processor-specific section types. */
1957 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1958 return TRUE;
1960 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1962 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1963 /* FIXME: How to properly handle allocated section reserved
1964 for applications? */
1965 (*_bfd_error_handler)
1966 (_("%B: don't know how to handle allocated, application "
1967 "specific section `%s' [0x%8x]"),
1968 abfd, name, hdr->sh_type);
1969 else
1970 /* Allow sections reserved for applications. */
1971 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1972 shindex);
1974 else if (hdr->sh_type >= SHT_LOPROC
1975 && hdr->sh_type <= SHT_HIPROC)
1976 /* FIXME: We should handle this section. */
1977 (*_bfd_error_handler)
1978 (_("%B: don't know how to handle processor specific section "
1979 "`%s' [0x%8x]"),
1980 abfd, name, hdr->sh_type);
1981 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
1983 /* Unrecognised OS-specific sections. */
1984 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1985 /* SHF_OS_NONCONFORMING indicates that special knowledge is
1986 required to correctly process the section and the file should
1987 be rejected with an error message. */
1988 (*_bfd_error_handler)
1989 (_("%B: don't know how to handle OS specific section "
1990 "`%s' [0x%8x]"),
1991 abfd, name, hdr->sh_type);
1992 else
1993 /* Otherwise it should be processed. */
1994 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
1996 else
1997 /* FIXME: We should handle this section. */
1998 (*_bfd_error_handler)
1999 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2000 abfd, name, hdr->sh_type);
2002 return FALSE;
2005 return TRUE;
2008 /* Return the local symbol specified by ABFD, R_SYMNDX. */
2010 Elf_Internal_Sym *
2011 bfd_sym_from_r_symndx (struct sym_cache *cache,
2012 bfd *abfd,
2013 unsigned long r_symndx)
2015 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2017 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2019 Elf_Internal_Shdr *symtab_hdr;
2020 unsigned char esym[sizeof (Elf64_External_Sym)];
2021 Elf_External_Sym_Shndx eshndx;
2023 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2024 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2025 &cache->sym[ent], esym, &eshndx) == NULL)
2026 return NULL;
2028 if (cache->abfd != abfd)
2030 memset (cache->indx, -1, sizeof (cache->indx));
2031 cache->abfd = abfd;
2033 cache->indx[ent] = r_symndx;
2036 return &cache->sym[ent];
2039 /* Given an ELF section number, retrieve the corresponding BFD
2040 section. */
2042 asection *
2043 bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
2045 if (sec_index >= elf_numsections (abfd))
2046 return NULL;
2047 return elf_elfsections (abfd)[sec_index]->bfd_section;
2050 static const struct bfd_elf_special_section special_sections_b[] =
2052 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2053 { NULL, 0, 0, 0, 0 }
2056 static const struct bfd_elf_special_section special_sections_c[] =
2058 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2059 { NULL, 0, 0, 0, 0 }
2062 static const struct bfd_elf_special_section special_sections_d[] =
2064 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2065 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2066 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2067 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2068 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2069 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2070 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2071 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2072 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2073 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2074 { NULL, 0, 0, 0, 0 }
2077 static const struct bfd_elf_special_section special_sections_f[] =
2079 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2080 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2081 { NULL, 0, 0, 0, 0 }
2084 static const struct bfd_elf_special_section special_sections_g[] =
2086 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2087 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE },
2088 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2089 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2090 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2091 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2092 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2093 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2094 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2095 { NULL, 0, 0, 0, 0 }
2098 static const struct bfd_elf_special_section special_sections_h[] =
2100 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2101 { NULL, 0, 0, 0, 0 }
2104 static const struct bfd_elf_special_section special_sections_i[] =
2106 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2107 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2108 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2109 { NULL, 0, 0, 0, 0 }
2112 static const struct bfd_elf_special_section special_sections_l[] =
2114 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2115 { NULL, 0, 0, 0, 0 }
2118 static const struct bfd_elf_special_section special_sections_n[] =
2120 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2121 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2122 { NULL, 0, 0, 0, 0 }
2125 static const struct bfd_elf_special_section special_sections_p[] =
2127 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2128 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2129 { NULL, 0, 0, 0, 0 }
2132 static const struct bfd_elf_special_section special_sections_r[] =
2134 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2135 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2136 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2137 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2138 { NULL, 0, 0, 0, 0 }
2141 static const struct bfd_elf_special_section special_sections_s[] =
2143 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2144 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2145 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
2146 /* See struct bfd_elf_special_section declaration for the semantics of
2147 this special case where .prefix_length != strlen (.prefix). */
2148 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
2149 { NULL, 0, 0, 0, 0 }
2152 static const struct bfd_elf_special_section special_sections_t[] =
2154 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2155 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2156 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2157 { NULL, 0, 0, 0, 0 }
2160 static const struct bfd_elf_special_section special_sections_z[] =
2162 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2163 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2164 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2165 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2166 { NULL, 0, 0, 0, 0 }
2169 static const struct bfd_elf_special_section * const special_sections[] =
2171 special_sections_b, /* 'b' */
2172 special_sections_c, /* 'c' */
2173 special_sections_d, /* 'd' */
2174 NULL, /* 'e' */
2175 special_sections_f, /* 'f' */
2176 special_sections_g, /* 'g' */
2177 special_sections_h, /* 'h' */
2178 special_sections_i, /* 'i' */
2179 NULL, /* 'j' */
2180 NULL, /* 'k' */
2181 special_sections_l, /* 'l' */
2182 NULL, /* 'm' */
2183 special_sections_n, /* 'n' */
2184 NULL, /* 'o' */
2185 special_sections_p, /* 'p' */
2186 NULL, /* 'q' */
2187 special_sections_r, /* 'r' */
2188 special_sections_s, /* 's' */
2189 special_sections_t, /* 't' */
2190 NULL, /* 'u' */
2191 NULL, /* 'v' */
2192 NULL, /* 'w' */
2193 NULL, /* 'x' */
2194 NULL, /* 'y' */
2195 special_sections_z /* 'z' */
2198 const struct bfd_elf_special_section *
2199 _bfd_elf_get_special_section (const char *name,
2200 const struct bfd_elf_special_section *spec,
2201 unsigned int rela)
2203 int i;
2204 int len;
2206 len = strlen (name);
2208 for (i = 0; spec[i].prefix != NULL; i++)
2210 int suffix_len;
2211 int prefix_len = spec[i].prefix_length;
2213 if (len < prefix_len)
2214 continue;
2215 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
2216 continue;
2218 suffix_len = spec[i].suffix_length;
2219 if (suffix_len <= 0)
2221 if (name[prefix_len] != 0)
2223 if (suffix_len == 0)
2224 continue;
2225 if (name[prefix_len] != '.'
2226 && (suffix_len == -2
2227 || (rela && spec[i].type == SHT_REL)))
2228 continue;
2231 else
2233 if (len < prefix_len + suffix_len)
2234 continue;
2235 if (memcmp (name + len - suffix_len,
2236 spec[i].prefix + prefix_len,
2237 suffix_len) != 0)
2238 continue;
2240 return &spec[i];
2243 return NULL;
2246 const struct bfd_elf_special_section *
2247 _bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2249 int i;
2250 const struct bfd_elf_special_section *spec;
2251 const struct elf_backend_data *bed;
2253 /* See if this is one of the special sections. */
2254 if (sec->name == NULL)
2255 return NULL;
2257 bed = get_elf_backend_data (abfd);
2258 spec = bed->special_sections;
2259 if (spec)
2261 spec = _bfd_elf_get_special_section (sec->name,
2262 bed->special_sections,
2263 sec->use_rela_p);
2264 if (spec != NULL)
2265 return spec;
2268 if (sec->name[0] != '.')
2269 return NULL;
2271 i = sec->name[1] - 'b';
2272 if (i < 0 || i > 'z' - 'b')
2273 return NULL;
2275 spec = special_sections[i];
2277 if (spec == NULL)
2278 return NULL;
2280 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2283 bfd_boolean
2284 _bfd_elf_new_section_hook (bfd *abfd, asection *sec)
2286 struct bfd_elf_section_data *sdata;
2287 const struct elf_backend_data *bed;
2288 const struct bfd_elf_special_section *ssect;
2290 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2291 if (sdata == NULL)
2293 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2294 sizeof (*sdata));
2295 if (sdata == NULL)
2296 return FALSE;
2297 sec->used_by_bfd = sdata;
2300 /* Indicate whether or not this section should use RELA relocations. */
2301 bed = get_elf_backend_data (abfd);
2302 sec->use_rela_p = bed->default_use_rela_p;
2304 /* When we read a file, we don't need to set ELF section type and
2305 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2306 anyway. We will set ELF section type and flags for all linker
2307 created sections. If user specifies BFD section flags, we will
2308 set ELF section type and flags based on BFD section flags in
2309 elf_fake_sections. Special handling for .init_array/.fini_array
2310 output sections since they may contain .ctors/.dtors input
2311 sections. We don't want _bfd_elf_init_private_section_data to
2312 copy ELF section type from .ctors/.dtors input sections. */
2313 if (abfd->direction != read_direction
2314 || (sec->flags & SEC_LINKER_CREATED) != 0)
2316 ssect = (*bed->get_sec_type_attr) (abfd, sec);
2317 if (ssect != NULL
2318 && (!sec->flags
2319 || (sec->flags & SEC_LINKER_CREATED) != 0
2320 || ssect->type == SHT_INIT_ARRAY
2321 || ssect->type == SHT_FINI_ARRAY))
2323 elf_section_type (sec) = ssect->type;
2324 elf_section_flags (sec) = ssect->attr;
2328 return _bfd_generic_new_section_hook (abfd, sec);
2331 /* Create a new bfd section from an ELF program header.
2333 Since program segments have no names, we generate a synthetic name
2334 of the form segment<NUM>, where NUM is generally the index in the
2335 program header table. For segments that are split (see below) we
2336 generate the names segment<NUM>a and segment<NUM>b.
2338 Note that some program segments may have a file size that is different than
2339 (less than) the memory size. All this means is that at execution the
2340 system must allocate the amount of memory specified by the memory size,
2341 but only initialize it with the first "file size" bytes read from the
2342 file. This would occur for example, with program segments consisting
2343 of combined data+bss.
2345 To handle the above situation, this routine generates TWO bfd sections
2346 for the single program segment. The first has the length specified by
2347 the file size of the segment, and the second has the length specified
2348 by the difference between the two sizes. In effect, the segment is split
2349 into its initialized and uninitialized parts.
2353 bfd_boolean
2354 _bfd_elf_make_section_from_phdr (bfd *abfd,
2355 Elf_Internal_Phdr *hdr,
2356 int hdr_index,
2357 const char *type_name)
2359 asection *newsect;
2360 char *name;
2361 char namebuf[64];
2362 size_t len;
2363 int split;
2365 split = ((hdr->p_memsz > 0)
2366 && (hdr->p_filesz > 0)
2367 && (hdr->p_memsz > hdr->p_filesz));
2369 if (hdr->p_filesz > 0)
2371 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
2372 len = strlen (namebuf) + 1;
2373 name = (char *) bfd_alloc (abfd, len);
2374 if (!name)
2375 return FALSE;
2376 memcpy (name, namebuf, len);
2377 newsect = bfd_make_section (abfd, name);
2378 if (newsect == NULL)
2379 return FALSE;
2380 newsect->vma = hdr->p_vaddr;
2381 newsect->lma = hdr->p_paddr;
2382 newsect->size = hdr->p_filesz;
2383 newsect->filepos = hdr->p_offset;
2384 newsect->flags |= SEC_HAS_CONTENTS;
2385 newsect->alignment_power = bfd_log2 (hdr->p_align);
2386 if (hdr->p_type == PT_LOAD)
2388 newsect->flags |= SEC_ALLOC;
2389 newsect->flags |= SEC_LOAD;
2390 if (hdr->p_flags & PF_X)
2392 /* FIXME: all we known is that it has execute PERMISSION,
2393 may be data. */
2394 newsect->flags |= SEC_CODE;
2397 if (!(hdr->p_flags & PF_W))
2399 newsect->flags |= SEC_READONLY;
2403 if (hdr->p_memsz > hdr->p_filesz)
2405 bfd_vma align;
2407 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
2408 len = strlen (namebuf) + 1;
2409 name = (char *) bfd_alloc (abfd, len);
2410 if (!name)
2411 return FALSE;
2412 memcpy (name, namebuf, len);
2413 newsect = bfd_make_section (abfd, name);
2414 if (newsect == NULL)
2415 return FALSE;
2416 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2417 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2418 newsect->size = hdr->p_memsz - hdr->p_filesz;
2419 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2420 align = newsect->vma & -newsect->vma;
2421 if (align == 0 || align > hdr->p_align)
2422 align = hdr->p_align;
2423 newsect->alignment_power = bfd_log2 (align);
2424 if (hdr->p_type == PT_LOAD)
2426 /* Hack for gdb. Segments that have not been modified do
2427 not have their contents written to a core file, on the
2428 assumption that a debugger can find the contents in the
2429 executable. We flag this case by setting the fake
2430 section size to zero. Note that "real" bss sections will
2431 always have their contents dumped to the core file. */
2432 if (bfd_get_format (abfd) == bfd_core)
2433 newsect->size = 0;
2434 newsect->flags |= SEC_ALLOC;
2435 if (hdr->p_flags & PF_X)
2436 newsect->flags |= SEC_CODE;
2438 if (!(hdr->p_flags & PF_W))
2439 newsect->flags |= SEC_READONLY;
2442 return TRUE;
2445 bfd_boolean
2446 bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
2448 const struct elf_backend_data *bed;
2450 switch (hdr->p_type)
2452 case PT_NULL:
2453 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
2455 case PT_LOAD:
2456 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
2458 case PT_DYNAMIC:
2459 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
2461 case PT_INTERP:
2462 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
2464 case PT_NOTE:
2465 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
2466 return FALSE;
2467 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
2468 return FALSE;
2469 return TRUE;
2471 case PT_SHLIB:
2472 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
2474 case PT_PHDR:
2475 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
2477 case PT_GNU_EH_FRAME:
2478 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
2479 "eh_frame_hdr");
2481 case PT_GNU_STACK:
2482 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
2484 case PT_GNU_RELRO:
2485 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
2487 default:
2488 /* Check for any processor-specific program segment types. */
2489 bed = get_elf_backend_data (abfd);
2490 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
2494 /* Return the REL_HDR for SEC, assuming there is only a single one, either
2495 REL or RELA. */
2497 Elf_Internal_Shdr *
2498 _bfd_elf_single_rel_hdr (asection *sec)
2500 if (elf_section_data (sec)->rel.hdr)
2502 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2503 return elf_section_data (sec)->rel.hdr;
2505 else
2506 return elf_section_data (sec)->rela.hdr;
2509 /* Allocate and initialize a section-header for a new reloc section,
2510 containing relocations against ASECT. It is stored in RELDATA. If
2511 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2512 relocations. */
2514 bfd_boolean
2515 _bfd_elf_init_reloc_shdr (bfd *abfd,
2516 struct bfd_elf_section_reloc_data *reldata,
2517 asection *asect,
2518 bfd_boolean use_rela_p)
2520 Elf_Internal_Shdr *rel_hdr;
2521 char *name;
2522 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2523 bfd_size_type amt;
2525 amt = sizeof (Elf_Internal_Shdr);
2526 BFD_ASSERT (reldata->hdr == NULL);
2527 rel_hdr = bfd_zalloc (abfd, amt);
2528 reldata->hdr = rel_hdr;
2530 amt = sizeof ".rela" + strlen (asect->name);
2531 name = (char *) bfd_alloc (abfd, amt);
2532 if (name == NULL)
2533 return FALSE;
2534 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2535 rel_hdr->sh_name =
2536 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2537 FALSE);
2538 if (rel_hdr->sh_name == (unsigned int) -1)
2539 return FALSE;
2540 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2541 rel_hdr->sh_entsize = (use_rela_p
2542 ? bed->s->sizeof_rela
2543 : bed->s->sizeof_rel);
2544 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
2545 rel_hdr->sh_flags = 0;
2546 rel_hdr->sh_addr = 0;
2547 rel_hdr->sh_size = 0;
2548 rel_hdr->sh_offset = 0;
2550 return TRUE;
2553 /* Return the default section type based on the passed in section flags. */
2556 bfd_elf_get_default_section_type (flagword flags)
2558 if ((flags & SEC_ALLOC) != 0
2559 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2560 return SHT_NOBITS;
2561 return SHT_PROGBITS;
2564 struct fake_section_arg
2566 struct bfd_link_info *link_info;
2567 bfd_boolean failed;
2570 /* Set up an ELF internal section header for a section. */
2572 static void
2573 elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
2575 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
2576 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2577 struct bfd_elf_section_data *esd = elf_section_data (asect);
2578 Elf_Internal_Shdr *this_hdr;
2579 unsigned int sh_type;
2581 if (arg->failed)
2583 /* We already failed; just get out of the bfd_map_over_sections
2584 loop. */
2585 return;
2588 this_hdr = &esd->this_hdr;
2590 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2591 asect->name, FALSE);
2592 if (this_hdr->sh_name == (unsigned int) -1)
2594 arg->failed = TRUE;
2595 return;
2598 /* Don't clear sh_flags. Assembler may set additional bits. */
2600 if ((asect->flags & SEC_ALLOC) != 0
2601 || asect->user_set_vma)
2602 this_hdr->sh_addr = asect->vma;
2603 else
2604 this_hdr->sh_addr = 0;
2606 this_hdr->sh_offset = 0;
2607 this_hdr->sh_size = asect->size;
2608 this_hdr->sh_link = 0;
2609 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
2610 /* The sh_entsize and sh_info fields may have been set already by
2611 copy_private_section_data. */
2613 this_hdr->bfd_section = asect;
2614 this_hdr->contents = NULL;
2616 /* If the section type is unspecified, we set it based on
2617 asect->flags. */
2618 if ((asect->flags & SEC_GROUP) != 0)
2619 sh_type = SHT_GROUP;
2620 else
2621 sh_type = bfd_elf_get_default_section_type (asect->flags);
2623 if (this_hdr->sh_type == SHT_NULL)
2624 this_hdr->sh_type = sh_type;
2625 else if (this_hdr->sh_type == SHT_NOBITS
2626 && sh_type == SHT_PROGBITS
2627 && (asect->flags & SEC_ALLOC) != 0)
2629 /* Warn if we are changing a NOBITS section to PROGBITS, but
2630 allow the link to proceed. This can happen when users link
2631 non-bss input sections to bss output sections, or emit data
2632 to a bss output section via a linker script. */
2633 (*_bfd_error_handler)
2634 (_("warning: section `%A' type changed to PROGBITS"), asect);
2635 this_hdr->sh_type = sh_type;
2638 switch (this_hdr->sh_type)
2640 default:
2641 break;
2643 case SHT_STRTAB:
2644 case SHT_INIT_ARRAY:
2645 case SHT_FINI_ARRAY:
2646 case SHT_PREINIT_ARRAY:
2647 case SHT_NOTE:
2648 case SHT_NOBITS:
2649 case SHT_PROGBITS:
2650 break;
2652 case SHT_HASH:
2653 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2654 break;
2656 case SHT_DYNSYM:
2657 this_hdr->sh_entsize = bed->s->sizeof_sym;
2658 break;
2660 case SHT_DYNAMIC:
2661 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2662 break;
2664 case SHT_RELA:
2665 if (get_elf_backend_data (abfd)->may_use_rela_p)
2666 this_hdr->sh_entsize = bed->s->sizeof_rela;
2667 break;
2669 case SHT_REL:
2670 if (get_elf_backend_data (abfd)->may_use_rel_p)
2671 this_hdr->sh_entsize = bed->s->sizeof_rel;
2672 break;
2674 case SHT_GNU_versym:
2675 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2676 break;
2678 case SHT_GNU_verdef:
2679 this_hdr->sh_entsize = 0;
2680 /* objcopy or strip will copy over sh_info, but may not set
2681 cverdefs. The linker will set cverdefs, but sh_info will be
2682 zero. */
2683 if (this_hdr->sh_info == 0)
2684 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2685 else
2686 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2687 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2688 break;
2690 case SHT_GNU_verneed:
2691 this_hdr->sh_entsize = 0;
2692 /* objcopy or strip will copy over sh_info, but may not set
2693 cverrefs. The linker will set cverrefs, but sh_info will be
2694 zero. */
2695 if (this_hdr->sh_info == 0)
2696 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2697 else
2698 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2699 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2700 break;
2702 case SHT_GROUP:
2703 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2704 break;
2706 case SHT_GNU_HASH:
2707 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2708 break;
2711 if ((asect->flags & SEC_ALLOC) != 0)
2712 this_hdr->sh_flags |= SHF_ALLOC;
2713 if ((asect->flags & SEC_READONLY) == 0)
2714 this_hdr->sh_flags |= SHF_WRITE;
2715 if ((asect->flags & SEC_CODE) != 0)
2716 this_hdr->sh_flags |= SHF_EXECINSTR;
2717 if ((asect->flags & SEC_MERGE) != 0)
2719 this_hdr->sh_flags |= SHF_MERGE;
2720 this_hdr->sh_entsize = asect->entsize;
2721 if ((asect->flags & SEC_STRINGS) != 0)
2722 this_hdr->sh_flags |= SHF_STRINGS;
2724 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2725 this_hdr->sh_flags |= SHF_GROUP;
2726 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2728 this_hdr->sh_flags |= SHF_TLS;
2729 if (asect->size == 0
2730 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2732 struct bfd_link_order *o = asect->map_tail.link_order;
2734 this_hdr->sh_size = 0;
2735 if (o != NULL)
2737 this_hdr->sh_size = o->offset + o->size;
2738 if (this_hdr->sh_size != 0)
2739 this_hdr->sh_type = SHT_NOBITS;
2743 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2744 this_hdr->sh_flags |= SHF_EXCLUDE;
2746 /* If the section has relocs, set up a section header for the
2747 SHT_REL[A] section. If two relocation sections are required for
2748 this section, it is up to the processor-specific back-end to
2749 create the other. */
2750 if ((asect->flags & SEC_RELOC) != 0)
2752 /* When doing a relocatable link, create both REL and RELA sections if
2753 needed. */
2754 if (arg->link_info
2755 /* Do the normal setup if we wouldn't create any sections here. */
2756 && esd->rel.count + esd->rela.count > 0
2757 && (arg->link_info->relocatable || arg->link_info->emitrelocations))
2759 if (esd->rel.count && esd->rel.hdr == NULL
2760 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
2762 arg->failed = TRUE;
2763 return;
2765 if (esd->rela.count && esd->rela.hdr == NULL
2766 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
2768 arg->failed = TRUE;
2769 return;
2772 else if (!_bfd_elf_init_reloc_shdr (abfd,
2773 (asect->use_rela_p
2774 ? &esd->rela : &esd->rel),
2775 asect,
2776 asect->use_rela_p))
2777 arg->failed = TRUE;
2780 /* Check for processor-specific section types. */
2781 sh_type = this_hdr->sh_type;
2782 if (bed->elf_backend_fake_sections
2783 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2784 arg->failed = TRUE;
2786 if (sh_type == SHT_NOBITS && asect->size != 0)
2788 /* Don't change the header type from NOBITS if we are being
2789 called for objcopy --only-keep-debug. */
2790 this_hdr->sh_type = sh_type;
2794 /* Fill in the contents of a SHT_GROUP section. Called from
2795 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2796 when ELF targets use the generic linker, ld. Called for ld -r
2797 from bfd_elf_final_link. */
2799 void
2800 bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
2802 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
2803 asection *elt, *first;
2804 unsigned char *loc;
2805 bfd_boolean gas;
2807 /* Ignore linker created group section. See elfNN_ia64_object_p in
2808 elfxx-ia64.c. */
2809 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
2810 || *failedptr)
2811 return;
2813 if (elf_section_data (sec)->this_hdr.sh_info == 0)
2815 unsigned long symindx = 0;
2817 /* elf_group_id will have been set up by objcopy and the
2818 generic linker. */
2819 if (elf_group_id (sec) != NULL)
2820 symindx = elf_group_id (sec)->udata.i;
2822 if (symindx == 0)
2824 /* If called from the assembler, swap_out_syms will have set up
2825 elf_section_syms. */
2826 BFD_ASSERT (elf_section_syms (abfd) != NULL);
2827 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2829 elf_section_data (sec)->this_hdr.sh_info = symindx;
2831 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
2833 /* The ELF backend linker sets sh_info to -2 when the group
2834 signature symbol is global, and thus the index can't be
2835 set until all local symbols are output. */
2836 asection *igroup = elf_sec_group (elf_next_in_group (sec));
2837 struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2838 unsigned long symndx = sec_data->this_hdr.sh_info;
2839 unsigned long extsymoff = 0;
2840 struct elf_link_hash_entry *h;
2842 if (!elf_bad_symtab (igroup->owner))
2844 Elf_Internal_Shdr *symtab_hdr;
2846 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2847 extsymoff = symtab_hdr->sh_info;
2849 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2850 while (h->root.type == bfd_link_hash_indirect
2851 || h->root.type == bfd_link_hash_warning)
2852 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2854 elf_section_data (sec)->this_hdr.sh_info = h->indx;
2857 /* The contents won't be allocated for "ld -r" or objcopy. */
2858 gas = TRUE;
2859 if (sec->contents == NULL)
2861 gas = FALSE;
2862 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
2864 /* Arrange for the section to be written out. */
2865 elf_section_data (sec)->this_hdr.contents = sec->contents;
2866 if (sec->contents == NULL)
2868 *failedptr = TRUE;
2869 return;
2873 loc = sec->contents + sec->size;
2875 /* Get the pointer to the first section in the group that gas
2876 squirreled away here. objcopy arranges for this to be set to the
2877 start of the input section group. */
2878 first = elt = elf_next_in_group (sec);
2880 /* First element is a flag word. Rest of section is elf section
2881 indices for all the sections of the group. Write them backwards
2882 just to keep the group in the same order as given in .section
2883 directives, not that it matters. */
2884 while (elt != NULL)
2886 asection *s;
2888 s = elt;
2889 if (!gas)
2890 s = s->output_section;
2891 if (s != NULL
2892 && !bfd_is_abs_section (s))
2894 unsigned int idx = elf_section_data (s)->this_idx;
2896 loc -= 4;
2897 H_PUT_32 (abfd, idx, loc);
2899 elt = elf_next_in_group (elt);
2900 if (elt == first)
2901 break;
2904 if ((loc -= 4) != sec->contents)
2905 abort ();
2907 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2910 /* Assign all ELF section numbers. The dummy first section is handled here
2911 too. The link/info pointers for the standard section types are filled
2912 in here too, while we're at it. */
2914 static bfd_boolean
2915 assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
2917 struct elf_obj_tdata *t = elf_tdata (abfd);
2918 asection *sec;
2919 unsigned int section_number, secn;
2920 Elf_Internal_Shdr **i_shdrp;
2921 struct bfd_elf_section_data *d;
2922 bfd_boolean need_symtab;
2924 section_number = 1;
2926 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2928 /* SHT_GROUP sections are in relocatable files only. */
2929 if (link_info == NULL || link_info->relocatable)
2931 /* Put SHT_GROUP sections first. */
2932 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2934 d = elf_section_data (sec);
2936 if (d->this_hdr.sh_type == SHT_GROUP)
2938 if (sec->flags & SEC_LINKER_CREATED)
2940 /* Remove the linker created SHT_GROUP sections. */
2941 bfd_section_list_remove (abfd, sec);
2942 abfd->section_count--;
2944 else
2945 d->this_idx = section_number++;
2950 for (sec = abfd->sections; sec; sec = sec->next)
2952 d = elf_section_data (sec);
2954 if (d->this_hdr.sh_type != SHT_GROUP)
2955 d->this_idx = section_number++;
2956 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2957 if (d->rel.hdr)
2959 d->rel.idx = section_number++;
2960 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2962 else
2963 d->rel.idx = 0;
2965 if (d->rela.hdr)
2967 d->rela.idx = section_number++;
2968 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2970 else
2971 d->rela.idx = 0;
2974 t->shstrtab_section = section_number++;
2975 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2976 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2978 need_symtab = (bfd_get_symcount (abfd) > 0
2979 || (link_info == NULL
2980 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2981 == HAS_RELOC)));
2982 if (need_symtab)
2984 t->symtab_section = section_number++;
2985 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2986 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
2988 t->symtab_shndx_section = section_number++;
2989 t->symtab_shndx_hdr.sh_name
2990 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2991 ".symtab_shndx", FALSE);
2992 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2993 return FALSE;
2995 t->strtab_section = section_number++;
2996 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2999 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3000 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3002 elf_numsections (abfd) = section_number;
3003 elf_elfheader (abfd)->e_shnum = section_number;
3005 /* Set up the list of section header pointers, in agreement with the
3006 indices. */
3007 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3008 sizeof (Elf_Internal_Shdr *));
3009 if (i_shdrp == NULL)
3010 return FALSE;
3012 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3013 sizeof (Elf_Internal_Shdr));
3014 if (i_shdrp[0] == NULL)
3016 bfd_release (abfd, i_shdrp);
3017 return FALSE;
3020 elf_elfsections (abfd) = i_shdrp;
3022 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
3023 if (need_symtab)
3025 i_shdrp[t->symtab_section] = &t->symtab_hdr;
3026 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
3028 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
3029 t->symtab_shndx_hdr.sh_link = t->symtab_section;
3031 i_shdrp[t->strtab_section] = &t->strtab_hdr;
3032 t->symtab_hdr.sh_link = t->strtab_section;
3035 for (sec = abfd->sections; sec; sec = sec->next)
3037 asection *s;
3038 const char *name;
3040 d = elf_section_data (sec);
3042 i_shdrp[d->this_idx] = &d->this_hdr;
3043 if (d->rel.idx != 0)
3044 i_shdrp[d->rel.idx] = d->rel.hdr;
3045 if (d->rela.idx != 0)
3046 i_shdrp[d->rela.idx] = d->rela.hdr;
3048 /* Fill in the sh_link and sh_info fields while we're at it. */
3050 /* sh_link of a reloc section is the section index of the symbol
3051 table. sh_info is the section index of the section to which
3052 the relocation entries apply. */
3053 if (d->rel.idx != 0)
3055 d->rel.hdr->sh_link = t->symtab_section;
3056 d->rel.hdr->sh_info = d->this_idx;
3058 if (d->rela.idx != 0)
3060 d->rela.hdr->sh_link = t->symtab_section;
3061 d->rela.hdr->sh_info = d->this_idx;
3064 /* We need to set up sh_link for SHF_LINK_ORDER. */
3065 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3067 s = elf_linked_to_section (sec);
3068 if (s)
3070 /* elf_linked_to_section points to the input section. */
3071 if (link_info != NULL)
3073 /* Check discarded linkonce section. */
3074 if (elf_discarded_section (s))
3076 asection *kept;
3077 (*_bfd_error_handler)
3078 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3079 abfd, d->this_hdr.bfd_section,
3080 s, s->owner);
3081 /* Point to the kept section if it has the same
3082 size as the discarded one. */
3083 kept = _bfd_elf_check_kept_section (s, link_info);
3084 if (kept == NULL)
3086 bfd_set_error (bfd_error_bad_value);
3087 return FALSE;
3089 s = kept;
3092 s = s->output_section;
3093 BFD_ASSERT (s != NULL);
3095 else
3097 /* Handle objcopy. */
3098 if (s->output_section == NULL)
3100 (*_bfd_error_handler)
3101 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3102 abfd, d->this_hdr.bfd_section, s, s->owner);
3103 bfd_set_error (bfd_error_bad_value);
3104 return FALSE;
3106 s = s->output_section;
3108 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3110 else
3112 /* PR 290:
3113 The Intel C compiler generates SHT_IA_64_UNWIND with
3114 SHF_LINK_ORDER. But it doesn't set the sh_link or
3115 sh_info fields. Hence we could get the situation
3116 where s is NULL. */
3117 const struct elf_backend_data *bed
3118 = get_elf_backend_data (abfd);
3119 if (bed->link_order_error_handler)
3120 bed->link_order_error_handler
3121 (_("%B: warning: sh_link not set for section `%A'"),
3122 abfd, sec);
3126 switch (d->this_hdr.sh_type)
3128 case SHT_REL:
3129 case SHT_RELA:
3130 /* A reloc section which we are treating as a normal BFD
3131 section. sh_link is the section index of the symbol
3132 table. sh_info is the section index of the section to
3133 which the relocation entries apply. We assume that an
3134 allocated reloc section uses the dynamic symbol table.
3135 FIXME: How can we be sure? */
3136 s = bfd_get_section_by_name (abfd, ".dynsym");
3137 if (s != NULL)
3138 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3140 /* We look up the section the relocs apply to by name. */
3141 name = sec->name;
3142 if (d->this_hdr.sh_type == SHT_REL)
3143 name += 4;
3144 else
3145 name += 5;
3146 s = bfd_get_section_by_name (abfd, name);
3147 if (s != NULL)
3148 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3149 break;
3151 case SHT_STRTAB:
3152 /* We assume that a section named .stab*str is a stabs
3153 string section. We look for a section with the same name
3154 but without the trailing ``str'', and set its sh_link
3155 field to point to this section. */
3156 if (CONST_STRNEQ (sec->name, ".stab")
3157 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3159 size_t len;
3160 char *alc;
3162 len = strlen (sec->name);
3163 alc = (char *) bfd_malloc (len - 2);
3164 if (alc == NULL)
3165 return FALSE;
3166 memcpy (alc, sec->name, len - 3);
3167 alc[len - 3] = '\0';
3168 s = bfd_get_section_by_name (abfd, alc);
3169 free (alc);
3170 if (s != NULL)
3172 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3174 /* This is a .stab section. */
3175 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3176 elf_section_data (s)->this_hdr.sh_entsize
3177 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
3180 break;
3182 case SHT_DYNAMIC:
3183 case SHT_DYNSYM:
3184 case SHT_GNU_verneed:
3185 case SHT_GNU_verdef:
3186 /* sh_link is the section header index of the string table
3187 used for the dynamic entries, or the symbol table, or the
3188 version strings. */
3189 s = bfd_get_section_by_name (abfd, ".dynstr");
3190 if (s != NULL)
3191 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3192 break;
3194 case SHT_GNU_LIBLIST:
3195 /* sh_link is the section header index of the prelink library
3196 list used for the dynamic entries, or the symbol table, or
3197 the version strings. */
3198 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3199 ? ".dynstr" : ".gnu.libstr");
3200 if (s != NULL)
3201 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3202 break;
3204 case SHT_HASH:
3205 case SHT_GNU_HASH:
3206 case SHT_GNU_versym:
3207 /* sh_link is the section header index of the symbol table
3208 this hash table or version table is for. */
3209 s = bfd_get_section_by_name (abfd, ".dynsym");
3210 if (s != NULL)
3211 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3212 break;
3214 case SHT_GROUP:
3215 d->this_hdr.sh_link = t->symtab_section;
3219 for (secn = 1; secn < section_number; ++secn)
3220 if (i_shdrp[secn] == NULL)
3221 i_shdrp[secn] = i_shdrp[0];
3222 else
3223 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3224 i_shdrp[secn]->sh_name);
3225 return TRUE;
3228 /* Map symbol from it's internal number to the external number, moving
3229 all local symbols to be at the head of the list. */
3231 static bfd_boolean
3232 sym_is_global (bfd *abfd, asymbol *sym)
3234 /* If the backend has a special mapping, use it. */
3235 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3236 if (bed->elf_backend_sym_is_global)
3237 return (*bed->elf_backend_sym_is_global) (abfd, sym);
3239 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
3240 || bfd_is_und_section (bfd_get_section (sym))
3241 || bfd_is_com_section (bfd_get_section (sym)));
3244 /* Don't output section symbols for sections that are not going to be
3245 output. */
3247 static bfd_boolean
3248 ignore_section_sym (bfd *abfd, asymbol *sym)
3250 return ((sym->flags & BSF_SECTION_SYM) != 0
3251 && !(sym->section->owner == abfd
3252 || (sym->section->output_section->owner == abfd
3253 && sym->section->output_offset == 0)));
3256 static bfd_boolean
3257 elf_map_symbols (bfd *abfd)
3259 unsigned int symcount = bfd_get_symcount (abfd);
3260 asymbol **syms = bfd_get_outsymbols (abfd);
3261 asymbol **sect_syms;
3262 unsigned int num_locals = 0;
3263 unsigned int num_globals = 0;
3264 unsigned int num_locals2 = 0;
3265 unsigned int num_globals2 = 0;
3266 int max_index = 0;
3267 unsigned int idx;
3268 asection *asect;
3269 asymbol **new_syms;
3271 #ifdef DEBUG
3272 fprintf (stderr, "elf_map_symbols\n");
3273 fflush (stderr);
3274 #endif
3276 for (asect = abfd->sections; asect; asect = asect->next)
3278 if (max_index < asect->index)
3279 max_index = asect->index;
3282 max_index++;
3283 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
3284 if (sect_syms == NULL)
3285 return FALSE;
3286 elf_section_syms (abfd) = sect_syms;
3287 elf_num_section_syms (abfd) = max_index;
3289 /* Init sect_syms entries for any section symbols we have already
3290 decided to output. */
3291 for (idx = 0; idx < symcount; idx++)
3293 asymbol *sym = syms[idx];
3295 if ((sym->flags & BSF_SECTION_SYM) != 0
3296 && sym->value == 0
3297 && !ignore_section_sym (abfd, sym))
3299 asection *sec = sym->section;
3301 if (sec->owner != abfd)
3302 sec = sec->output_section;
3304 sect_syms[sec->index] = syms[idx];
3308 /* Classify all of the symbols. */
3309 for (idx = 0; idx < symcount; idx++)
3311 if (ignore_section_sym (abfd, syms[idx]))
3312 continue;
3313 if (!sym_is_global (abfd, syms[idx]))
3314 num_locals++;
3315 else
3316 num_globals++;
3319 /* We will be adding a section symbol for each normal BFD section. Most
3320 sections will already have a section symbol in outsymbols, but
3321 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3322 at least in that case. */
3323 for (asect = abfd->sections; asect; asect = asect->next)
3325 if (sect_syms[asect->index] == NULL)
3327 if (!sym_is_global (abfd, asect->symbol))
3328 num_locals++;
3329 else
3330 num_globals++;
3334 /* Now sort the symbols so the local symbols are first. */
3335 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3336 sizeof (asymbol *));
3338 if (new_syms == NULL)
3339 return FALSE;
3341 for (idx = 0; idx < symcount; idx++)
3343 asymbol *sym = syms[idx];
3344 unsigned int i;
3346 if (ignore_section_sym (abfd, sym))
3347 continue;
3348 if (!sym_is_global (abfd, sym))
3349 i = num_locals2++;
3350 else
3351 i = num_locals + num_globals2++;
3352 new_syms[i] = sym;
3353 sym->udata.i = i + 1;
3355 for (asect = abfd->sections; asect; asect = asect->next)
3357 if (sect_syms[asect->index] == NULL)
3359 asymbol *sym = asect->symbol;
3360 unsigned int i;
3362 sect_syms[asect->index] = sym;
3363 if (!sym_is_global (abfd, sym))
3364 i = num_locals2++;
3365 else
3366 i = num_locals + num_globals2++;
3367 new_syms[i] = sym;
3368 sym->udata.i = i + 1;
3372 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3374 elf_num_locals (abfd) = num_locals;
3375 elf_num_globals (abfd) = num_globals;
3376 return TRUE;
3379 /* Align to the maximum file alignment that could be required for any
3380 ELF data structure. */
3382 static inline file_ptr
3383 align_file_position (file_ptr off, int align)
3385 return (off + align - 1) & ~(align - 1);
3388 /* Assign a file position to a section, optionally aligning to the
3389 required section alignment. */
3391 file_ptr
3392 _bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3393 file_ptr offset,
3394 bfd_boolean align)
3396 if (align && i_shdrp->sh_addralign > 1)
3397 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
3398 i_shdrp->sh_offset = offset;
3399 if (i_shdrp->bfd_section != NULL)
3400 i_shdrp->bfd_section->filepos = offset;
3401 if (i_shdrp->sh_type != SHT_NOBITS)
3402 offset += i_shdrp->sh_size;
3403 return offset;
3406 /* Compute the file positions we are going to put the sections at, and
3407 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3408 is not NULL, this is being called by the ELF backend linker. */
3410 bfd_boolean
3411 _bfd_elf_compute_section_file_positions (bfd *abfd,
3412 struct bfd_link_info *link_info)
3414 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3415 struct fake_section_arg fsargs;
3416 bfd_boolean failed;
3417 struct bfd_strtab_hash *strtab = NULL;
3418 Elf_Internal_Shdr *shstrtab_hdr;
3419 bfd_boolean need_symtab;
3421 if (abfd->output_has_begun)
3422 return TRUE;
3424 /* Do any elf backend specific processing first. */
3425 if (bed->elf_backend_begin_write_processing)
3426 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3428 if (! prep_headers (abfd))
3429 return FALSE;
3431 /* Post process the headers if necessary. */
3432 if (bed->elf_backend_post_process_headers)
3433 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3435 fsargs.failed = FALSE;
3436 fsargs.link_info = link_info;
3437 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
3438 if (fsargs.failed)
3439 return FALSE;
3441 if (!assign_section_numbers (abfd, link_info))
3442 return FALSE;
3444 /* The backend linker builds symbol table information itself. */
3445 need_symtab = (link_info == NULL
3446 && (bfd_get_symcount (abfd) > 0
3447 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3448 == HAS_RELOC)));
3449 if (need_symtab)
3451 /* Non-zero if doing a relocatable link. */
3452 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3454 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3455 return FALSE;
3458 failed = FALSE;
3459 if (link_info == NULL)
3461 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3462 if (failed)
3463 return FALSE;
3466 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3467 /* sh_name was set in prep_headers. */
3468 shstrtab_hdr->sh_type = SHT_STRTAB;
3469 shstrtab_hdr->sh_flags = 0;
3470 shstrtab_hdr->sh_addr = 0;
3471 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3472 shstrtab_hdr->sh_entsize = 0;
3473 shstrtab_hdr->sh_link = 0;
3474 shstrtab_hdr->sh_info = 0;
3475 /* sh_offset is set in assign_file_positions_except_relocs. */
3476 shstrtab_hdr->sh_addralign = 1;
3478 if (!assign_file_positions_except_relocs (abfd, link_info))
3479 return FALSE;
3481 if (need_symtab)
3483 file_ptr off;
3484 Elf_Internal_Shdr *hdr;
3486 off = elf_tdata (abfd)->next_file_pos;
3488 hdr = &elf_tdata (abfd)->symtab_hdr;
3489 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3491 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3492 if (hdr->sh_size != 0)
3493 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3495 hdr = &elf_tdata (abfd)->strtab_hdr;
3496 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
3498 elf_tdata (abfd)->next_file_pos = off;
3500 /* Now that we know where the .strtab section goes, write it
3501 out. */
3502 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3503 || ! _bfd_stringtab_emit (abfd, strtab))
3504 return FALSE;
3505 _bfd_stringtab_free (strtab);
3508 abfd->output_has_begun = TRUE;
3510 return TRUE;
3513 /* Make an initial estimate of the size of the program header. If we
3514 get the number wrong here, we'll redo section placement. */
3516 static bfd_size_type
3517 get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3519 size_t segs;
3520 asection *s;
3521 const struct elf_backend_data *bed;
3523 /* Assume we will need exactly two PT_LOAD segments: one for text
3524 and one for data. */
3525 segs = 2;
3527 s = bfd_get_section_by_name (abfd, ".interp");
3528 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3530 /* If we have a loadable interpreter section, we need a
3531 PT_INTERP segment. In this case, assume we also need a
3532 PT_PHDR segment, although that may not be true for all
3533 targets. */
3534 segs += 2;
3537 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3539 /* We need a PT_DYNAMIC segment. */
3540 ++segs;
3543 if (info != NULL && info->relro)
3545 /* We need a PT_GNU_RELRO segment. */
3546 ++segs;
3549 if (elf_tdata (abfd)->eh_frame_hdr)
3551 /* We need a PT_GNU_EH_FRAME segment. */
3552 ++segs;
3555 if (elf_tdata (abfd)->stack_flags)
3557 /* We need a PT_GNU_STACK segment. */
3558 ++segs;
3561 for (s = abfd->sections; s != NULL; s = s->next)
3563 if ((s->flags & SEC_LOAD) != 0
3564 && CONST_STRNEQ (s->name, ".note"))
3566 /* We need a PT_NOTE segment. */
3567 ++segs;
3568 /* Try to create just one PT_NOTE segment
3569 for all adjacent loadable .note* sections.
3570 gABI requires that within a PT_NOTE segment
3571 (and also inside of each SHT_NOTE section)
3572 each note is padded to a multiple of 4 size,
3573 so we check whether the sections are correctly
3574 aligned. */
3575 if (s->alignment_power == 2)
3576 while (s->next != NULL
3577 && s->next->alignment_power == 2
3578 && (s->next->flags & SEC_LOAD) != 0
3579 && CONST_STRNEQ (s->next->name, ".note"))
3580 s = s->next;
3584 for (s = abfd->sections; s != NULL; s = s->next)
3586 if (s->flags & SEC_THREAD_LOCAL)
3588 /* We need a PT_TLS segment. */
3589 ++segs;
3590 break;
3594 /* Let the backend count up any program headers it might need. */
3595 bed = get_elf_backend_data (abfd);
3596 if (bed->elf_backend_additional_program_headers)
3598 int a;
3600 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3601 if (a == -1)
3602 abort ();
3603 segs += a;
3606 return segs * bed->s->sizeof_phdr;
3609 /* Find the segment that contains the output_section of section. */
3611 Elf_Internal_Phdr *
3612 _bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3614 struct elf_segment_map *m;
3615 Elf_Internal_Phdr *p;
3617 for (m = elf_tdata (abfd)->segment_map,
3618 p = elf_tdata (abfd)->phdr;
3619 m != NULL;
3620 m = m->next, p++)
3622 int i;
3624 for (i = m->count - 1; i >= 0; i--)
3625 if (m->sections[i] == section)
3626 return p;
3629 return NULL;
3632 /* Create a mapping from a set of sections to a program segment. */
3634 static struct elf_segment_map *
3635 make_mapping (bfd *abfd,
3636 asection **sections,
3637 unsigned int from,
3638 unsigned int to,
3639 bfd_boolean phdr)
3641 struct elf_segment_map *m;
3642 unsigned int i;
3643 asection **hdrpp;
3644 bfd_size_type amt;
3646 amt = sizeof (struct elf_segment_map);
3647 amt += (to - from - 1) * sizeof (asection *);
3648 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3649 if (m == NULL)
3650 return NULL;
3651 m->next = NULL;
3652 m->p_type = PT_LOAD;
3653 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3654 m->sections[i - from] = *hdrpp;
3655 m->count = to - from;
3657 if (from == 0 && phdr)
3659 /* Include the headers in the first PT_LOAD segment. */
3660 m->includes_filehdr = 1;
3661 m->includes_phdrs = 1;
3664 return m;
3667 /* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3668 on failure. */
3670 struct elf_segment_map *
3671 _bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3673 struct elf_segment_map *m;
3675 m = (struct elf_segment_map *) bfd_zalloc (abfd,
3676 sizeof (struct elf_segment_map));
3677 if (m == NULL)
3678 return NULL;
3679 m->next = NULL;
3680 m->p_type = PT_DYNAMIC;
3681 m->count = 1;
3682 m->sections[0] = dynsec;
3684 return m;
3687 /* Possibly add or remove segments from the segment map. */
3689 static bfd_boolean
3690 elf_modify_segment_map (bfd *abfd,
3691 struct bfd_link_info *info,
3692 bfd_boolean remove_empty_load)
3694 struct elf_segment_map **m;
3695 const struct elf_backend_data *bed;
3697 /* The placement algorithm assumes that non allocated sections are
3698 not in PT_LOAD segments. We ensure this here by removing such
3699 sections from the segment map. We also remove excluded
3700 sections. Finally, any PT_LOAD segment without sections is
3701 removed. */
3702 m = &elf_tdata (abfd)->segment_map;
3703 while (*m)
3705 unsigned int i, new_count;
3707 for (new_count = 0, i = 0; i < (*m)->count; i++)
3709 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3710 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3711 || (*m)->p_type != PT_LOAD))
3713 (*m)->sections[new_count] = (*m)->sections[i];
3714 new_count++;
3717 (*m)->count = new_count;
3719 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
3720 *m = (*m)->next;
3721 else
3722 m = &(*m)->next;
3725 bed = get_elf_backend_data (abfd);
3726 if (bed->elf_backend_modify_segment_map != NULL)
3728 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
3729 return FALSE;
3732 return TRUE;
3735 /* Set up a mapping from BFD sections to program segments. */
3737 bfd_boolean
3738 _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3740 unsigned int count;
3741 struct elf_segment_map *m;
3742 asection **sections = NULL;
3743 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3744 bfd_boolean no_user_phdrs;
3746 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3747 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
3749 asection *s;
3750 unsigned int i;
3751 struct elf_segment_map *mfirst;
3752 struct elf_segment_map **pm;
3753 asection *last_hdr;
3754 bfd_vma last_size;
3755 unsigned int phdr_index;
3756 bfd_vma maxpagesize;
3757 asection **hdrpp;
3758 bfd_boolean phdr_in_segment = TRUE;
3759 bfd_boolean writable;
3760 int tls_count = 0;
3761 asection *first_tls = NULL;
3762 asection *dynsec, *eh_frame_hdr;
3763 bfd_size_type amt;
3764 bfd_vma addr_mask, wrap_to = 0;
3766 /* Select the allocated sections, and sort them. */
3768 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3769 sizeof (asection *));
3770 if (sections == NULL)
3771 goto error_return;
3773 /* Calculate top address, avoiding undefined behaviour of shift
3774 left operator when shift count is equal to size of type
3775 being shifted. */
3776 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
3777 addr_mask = (addr_mask << 1) + 1;
3779 i = 0;
3780 for (s = abfd->sections; s != NULL; s = s->next)
3782 if ((s->flags & SEC_ALLOC) != 0)
3784 sections[i] = s;
3785 ++i;
3786 /* A wrapping section potentially clashes with header. */
3787 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
3788 wrap_to = (s->lma + s->size) & addr_mask;
3791 BFD_ASSERT (i <= bfd_count_sections (abfd));
3792 count = i;
3794 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3796 /* Build the mapping. */
3798 mfirst = NULL;
3799 pm = &mfirst;
3801 /* If we have a .interp section, then create a PT_PHDR segment for
3802 the program headers and a PT_INTERP segment for the .interp
3803 section. */
3804 s = bfd_get_section_by_name (abfd, ".interp");
3805 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3807 amt = sizeof (struct elf_segment_map);
3808 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3809 if (m == NULL)
3810 goto error_return;
3811 m->next = NULL;
3812 m->p_type = PT_PHDR;
3813 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3814 m->p_flags = PF_R | PF_X;
3815 m->p_flags_valid = 1;
3816 m->includes_phdrs = 1;
3818 *pm = m;
3819 pm = &m->next;
3821 amt = sizeof (struct elf_segment_map);
3822 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3823 if (m == NULL)
3824 goto error_return;
3825 m->next = NULL;
3826 m->p_type = PT_INTERP;
3827 m->count = 1;
3828 m->sections[0] = s;
3830 *pm = m;
3831 pm = &m->next;
3834 /* Look through the sections. We put sections in the same program
3835 segment when the start of the second section can be placed within
3836 a few bytes of the end of the first section. */
3837 last_hdr = NULL;
3838 last_size = 0;
3839 phdr_index = 0;
3840 maxpagesize = bed->maxpagesize;
3841 writable = FALSE;
3842 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3843 if (dynsec != NULL
3844 && (dynsec->flags & SEC_LOAD) == 0)
3845 dynsec = NULL;
3847 /* Deal with -Ttext or something similar such that the first section
3848 is not adjacent to the program headers. This is an
3849 approximation, since at this point we don't know exactly how many
3850 program headers we will need. */
3851 if (count > 0)
3853 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3855 if (phdr_size == (bfd_size_type) -1)
3856 phdr_size = get_program_header_size (abfd, info);
3857 if ((abfd->flags & D_PAGED) == 0
3858 || (sections[0]->lma & addr_mask) < phdr_size
3859 || ((sections[0]->lma & addr_mask) % maxpagesize
3860 < phdr_size % maxpagesize)
3861 || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
3862 phdr_in_segment = FALSE;
3865 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3867 asection *hdr;
3868 bfd_boolean new_segment;
3870 hdr = *hdrpp;
3872 /* See if this section and the last one will fit in the same
3873 segment. */
3875 if (last_hdr == NULL)
3877 /* If we don't have a segment yet, then we don't need a new
3878 one (we build the last one after this loop). */
3879 new_segment = FALSE;
3881 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3883 /* If this section has a different relation between the
3884 virtual address and the load address, then we need a new
3885 segment. */
3886 new_segment = TRUE;
3888 else if (hdr->lma < last_hdr->lma + last_size
3889 || last_hdr->lma + last_size < last_hdr->lma)
3891 /* If this section has a load address that makes it overlap
3892 the previous section, then we need a new segment. */
3893 new_segment = TRUE;
3895 /* In the next test we have to be careful when last_hdr->lma is close
3896 to the end of the address space. If the aligned address wraps
3897 around to the start of the address space, then there are no more
3898 pages left in memory and it is OK to assume that the current
3899 section can be included in the current segment. */
3900 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3901 > last_hdr->lma)
3902 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3903 <= hdr->lma))
3905 /* If putting this section in this segment would force us to
3906 skip a page in the segment, then we need a new segment. */
3907 new_segment = TRUE;
3909 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3910 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3912 /* We don't want to put a loadable section after a
3913 nonloadable section in the same segment.
3914 Consider .tbss sections as loadable for this purpose. */
3915 new_segment = TRUE;
3917 else if ((abfd->flags & D_PAGED) == 0)
3919 /* If the file is not demand paged, which means that we
3920 don't require the sections to be correctly aligned in the
3921 file, then there is no other reason for a new segment. */
3922 new_segment = FALSE;
3924 else if (! writable
3925 && (hdr->flags & SEC_READONLY) == 0
3926 && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3927 != (hdr->lma & -maxpagesize)))
3929 /* We don't want to put a writable section in a read only
3930 segment, unless they are on the same page in memory
3931 anyhow. We already know that the last section does not
3932 bring us past the current section on the page, so the
3933 only case in which the new section is not on the same
3934 page as the previous section is when the previous section
3935 ends precisely on a page boundary. */
3936 new_segment = TRUE;
3938 else
3940 /* Otherwise, we can use the same segment. */
3941 new_segment = FALSE;
3944 /* Allow interested parties a chance to override our decision. */
3945 if (last_hdr != NULL
3946 && info != NULL
3947 && info->callbacks->override_segment_assignment != NULL)
3948 new_segment
3949 = info->callbacks->override_segment_assignment (info, abfd, hdr,
3950 last_hdr,
3951 new_segment);
3953 if (! new_segment)
3955 if ((hdr->flags & SEC_READONLY) == 0)
3956 writable = TRUE;
3957 last_hdr = hdr;
3958 /* .tbss sections effectively have zero size. */
3959 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3960 != SEC_THREAD_LOCAL)
3961 last_size = hdr->size;
3962 else
3963 last_size = 0;
3964 continue;
3967 /* We need a new program segment. We must create a new program
3968 header holding all the sections from phdr_index until hdr. */
3970 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3971 if (m == NULL)
3972 goto error_return;
3974 *pm = m;
3975 pm = &m->next;
3977 if ((hdr->flags & SEC_READONLY) == 0)
3978 writable = TRUE;
3979 else
3980 writable = FALSE;
3982 last_hdr = hdr;
3983 /* .tbss sections effectively have zero size. */
3984 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
3985 last_size = hdr->size;
3986 else
3987 last_size = 0;
3988 phdr_index = i;
3989 phdr_in_segment = FALSE;
3992 /* Create a final PT_LOAD program segment, but not if it's just
3993 for .tbss. */
3994 if (last_hdr != NULL
3995 && (i - phdr_index != 1
3996 || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3997 != SEC_THREAD_LOCAL)))
3999 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4000 if (m == NULL)
4001 goto error_return;
4003 *pm = m;
4004 pm = &m->next;
4007 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4008 if (dynsec != NULL)
4010 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4011 if (m == NULL)
4012 goto error_return;
4013 *pm = m;
4014 pm = &m->next;
4017 /* For each batch of consecutive loadable .note sections,
4018 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4019 because if we link together nonloadable .note sections and
4020 loadable .note sections, we will generate two .note sections
4021 in the output file. FIXME: Using names for section types is
4022 bogus anyhow. */
4023 for (s = abfd->sections; s != NULL; s = s->next)
4025 if ((s->flags & SEC_LOAD) != 0
4026 && CONST_STRNEQ (s->name, ".note"))
4028 asection *s2;
4030 count = 1;
4031 amt = sizeof (struct elf_segment_map);
4032 if (s->alignment_power == 2)
4033 for (s2 = s; s2->next != NULL; s2 = s2->next)
4035 if (s2->next->alignment_power == 2
4036 && (s2->next->flags & SEC_LOAD) != 0
4037 && CONST_STRNEQ (s2->next->name, ".note")
4038 && align_power (s2->lma + s2->size, 2)
4039 == s2->next->lma)
4040 count++;
4041 else
4042 break;
4044 amt += (count - 1) * sizeof (asection *);
4045 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4046 if (m == NULL)
4047 goto error_return;
4048 m->next = NULL;
4049 m->p_type = PT_NOTE;
4050 m->count = count;
4051 while (count > 1)
4053 m->sections[m->count - count--] = s;
4054 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4055 s = s->next;
4057 m->sections[m->count - 1] = s;
4058 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4059 *pm = m;
4060 pm = &m->next;
4062 if (s->flags & SEC_THREAD_LOCAL)
4064 if (! tls_count)
4065 first_tls = s;
4066 tls_count++;
4070 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4071 if (tls_count > 0)
4073 amt = sizeof (struct elf_segment_map);
4074 amt += (tls_count - 1) * sizeof (asection *);
4075 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4076 if (m == NULL)
4077 goto error_return;
4078 m->next = NULL;
4079 m->p_type = PT_TLS;
4080 m->count = tls_count;
4081 /* Mandated PF_R. */
4082 m->p_flags = PF_R;
4083 m->p_flags_valid = 1;
4084 for (i = 0; i < (unsigned int) tls_count; ++i)
4086 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
4087 m->sections[i] = first_tls;
4088 first_tls = first_tls->next;
4091 *pm = m;
4092 pm = &m->next;
4095 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4096 segment. */
4097 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
4098 if (eh_frame_hdr != NULL
4099 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
4101 amt = sizeof (struct elf_segment_map);
4102 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4103 if (m == NULL)
4104 goto error_return;
4105 m->next = NULL;
4106 m->p_type = PT_GNU_EH_FRAME;
4107 m->count = 1;
4108 m->sections[0] = eh_frame_hdr->output_section;
4110 *pm = m;
4111 pm = &m->next;
4114 if (elf_tdata (abfd)->stack_flags)
4116 amt = sizeof (struct elf_segment_map);
4117 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4118 if (m == NULL)
4119 goto error_return;
4120 m->next = NULL;
4121 m->p_type = PT_GNU_STACK;
4122 m->p_flags = elf_tdata (abfd)->stack_flags;
4123 m->p_flags_valid = 1;
4125 *pm = m;
4126 pm = &m->next;
4129 if (info != NULL && info->relro)
4131 for (m = mfirst; m != NULL; m = m->next)
4133 if (m->p_type == PT_LOAD)
4135 asection *last = m->sections[m->count - 1];
4136 bfd_vma vaddr = m->sections[0]->vma;
4137 bfd_vma filesz = last->vma - vaddr + last->size;
4139 if (vaddr < info->relro_end
4140 && vaddr >= info->relro_start
4141 && (vaddr + filesz) >= info->relro_end)
4142 break;
4146 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4147 if (m != NULL)
4149 amt = sizeof (struct elf_segment_map);
4150 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
4151 if (m == NULL)
4152 goto error_return;
4153 m->next = NULL;
4154 m->p_type = PT_GNU_RELRO;
4155 m->p_flags = PF_R;
4156 m->p_flags_valid = 1;
4158 *pm = m;
4159 pm = &m->next;
4163 free (sections);
4164 elf_tdata (abfd)->segment_map = mfirst;
4167 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
4168 return FALSE;
4170 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4171 ++count;
4172 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
4174 return TRUE;
4176 error_return:
4177 if (sections != NULL)
4178 free (sections);
4179 return FALSE;
4182 /* Sort sections by address. */
4184 static int
4185 elf_sort_sections (const void *arg1, const void *arg2)
4187 const asection *sec1 = *(const asection **) arg1;
4188 const asection *sec2 = *(const asection **) arg2;
4189 bfd_size_type size1, size2;
4191 /* Sort by LMA first, since this is the address used to
4192 place the section into a segment. */
4193 if (sec1->lma < sec2->lma)
4194 return -1;
4195 else if (sec1->lma > sec2->lma)
4196 return 1;
4198 /* Then sort by VMA. Normally the LMA and the VMA will be
4199 the same, and this will do nothing. */
4200 if (sec1->vma < sec2->vma)
4201 return -1;
4202 else if (sec1->vma > sec2->vma)
4203 return 1;
4205 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4207 #define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
4209 if (TOEND (sec1))
4211 if (TOEND (sec2))
4213 /* If the indicies are the same, do not return 0
4214 here, but continue to try the next comparison. */
4215 if (sec1->target_index - sec2->target_index != 0)
4216 return sec1->target_index - sec2->target_index;
4218 else
4219 return 1;
4221 else if (TOEND (sec2))
4222 return -1;
4224 #undef TOEND
4226 /* Sort by size, to put zero sized sections
4227 before others at the same address. */
4229 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4230 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
4232 if (size1 < size2)
4233 return -1;
4234 if (size1 > size2)
4235 return 1;
4237 return sec1->target_index - sec2->target_index;
4240 /* Ian Lance Taylor writes:
4242 We shouldn't be using % with a negative signed number. That's just
4243 not good. We have to make sure either that the number is not
4244 negative, or that the number has an unsigned type. When the types
4245 are all the same size they wind up as unsigned. When file_ptr is a
4246 larger signed type, the arithmetic winds up as signed long long,
4247 which is wrong.
4249 What we're trying to say here is something like ``increase OFF by
4250 the least amount that will cause it to be equal to the VMA modulo
4251 the page size.'' */
4252 /* In other words, something like:
4254 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4255 off_offset = off % bed->maxpagesize;
4256 if (vma_offset < off_offset)
4257 adjustment = vma_offset + bed->maxpagesize - off_offset;
4258 else
4259 adjustment = vma_offset - off_offset;
4261 which can can be collapsed into the expression below. */
4263 static file_ptr
4264 vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4266 return ((vma - off) % maxpagesize);
4269 static void
4270 print_segment_map (const struct elf_segment_map *m)
4272 unsigned int j;
4273 const char *pt = get_segment_type (m->p_type);
4274 char buf[32];
4276 if (pt == NULL)
4278 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4279 sprintf (buf, "LOPROC+%7.7x",
4280 (unsigned int) (m->p_type - PT_LOPROC));
4281 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4282 sprintf (buf, "LOOS+%7.7x",
4283 (unsigned int) (m->p_type - PT_LOOS));
4284 else
4285 snprintf (buf, sizeof (buf), "%8.8x",
4286 (unsigned int) m->p_type);
4287 pt = buf;
4289 fflush (stdout);
4290 fprintf (stderr, "%s:", pt);
4291 for (j = 0; j < m->count; j++)
4292 fprintf (stderr, " %s", m->sections [j]->name);
4293 putc ('\n',stderr);
4294 fflush (stderr);
4297 static bfd_boolean
4298 write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
4300 void *buf;
4301 bfd_boolean ret;
4303 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4304 return FALSE;
4305 buf = bfd_zmalloc (len);
4306 if (buf == NULL)
4307 return FALSE;
4308 ret = bfd_bwrite (buf, len, abfd) == len;
4309 free (buf);
4310 return ret;
4313 /* Assign file positions to the sections based on the mapping from
4314 sections to segments. This function also sets up some fields in
4315 the file header. */
4317 static bfd_boolean
4318 assign_file_positions_for_load_sections (bfd *abfd,
4319 struct bfd_link_info *link_info)
4321 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4322 struct elf_segment_map *m;
4323 Elf_Internal_Phdr *phdrs;
4324 Elf_Internal_Phdr *p;
4325 file_ptr off;
4326 bfd_size_type maxpagesize;
4327 unsigned int alloc;
4328 unsigned int i, j;
4329 bfd_vma header_pad = 0;
4331 if (link_info == NULL
4332 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
4333 return FALSE;
4335 alloc = 0;
4336 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4338 ++alloc;
4339 if (m->header_size)
4340 header_pad = m->header_size;
4343 if (alloc)
4345 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4346 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4348 else
4350 /* PR binutils/12467. */
4351 elf_elfheader (abfd)->e_phoff = 0;
4352 elf_elfheader (abfd)->e_phentsize = 0;
4355 elf_elfheader (abfd)->e_phnum = alloc;
4357 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
4358 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4359 else
4360 BFD_ASSERT (elf_tdata (abfd)->program_header_size
4361 >= alloc * bed->s->sizeof_phdr);
4363 if (alloc == 0)
4365 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4366 return TRUE;
4369 /* We're writing the size in elf_tdata (abfd)->program_header_size,
4370 see assign_file_positions_except_relocs, so make sure we have
4371 that amount allocated, with trailing space cleared.
4372 The variable alloc contains the computed need, while elf_tdata
4373 (abfd)->program_header_size contains the size used for the
4374 layout.
4375 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4376 where the layout is forced to according to a larger size in the
4377 last iterations for the testcase ld-elf/header. */
4378 BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr
4379 == 0);
4380 phdrs = (Elf_Internal_Phdr *)
4381 bfd_zalloc2 (abfd,
4382 (elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr),
4383 sizeof (Elf_Internal_Phdr));
4384 elf_tdata (abfd)->phdr = phdrs;
4385 if (phdrs == NULL)
4386 return FALSE;
4388 maxpagesize = 1;
4389 if ((abfd->flags & D_PAGED) != 0)
4390 maxpagesize = bed->maxpagesize;
4392 off = bed->s->sizeof_ehdr;
4393 off += alloc * bed->s->sizeof_phdr;
4394 if (header_pad < (bfd_vma) off)
4395 header_pad = 0;
4396 else
4397 header_pad -= off;
4398 off += header_pad;
4400 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
4401 m != NULL;
4402 m = m->next, p++, j++)
4404 asection **secpp;
4405 bfd_vma off_adjust;
4406 bfd_boolean no_contents;
4408 /* If elf_segment_map is not from map_sections_to_segments, the
4409 sections may not be correctly ordered. NOTE: sorting should
4410 not be done to the PT_NOTE section of a corefile, which may
4411 contain several pseudo-sections artificially created by bfd.
4412 Sorting these pseudo-sections breaks things badly. */
4413 if (m->count > 1
4414 && !(elf_elfheader (abfd)->e_type == ET_CORE
4415 && m->p_type == PT_NOTE))
4416 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4417 elf_sort_sections);
4419 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4420 number of sections with contents contributing to both p_filesz
4421 and p_memsz, followed by a number of sections with no contents
4422 that just contribute to p_memsz. In this loop, OFF tracks next
4423 available file offset for PT_LOAD and PT_NOTE segments. */
4424 p->p_type = m->p_type;
4425 p->p_flags = m->p_flags;
4427 if (m->count == 0)
4428 p->p_vaddr = 0;
4429 else
4430 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
4432 if (m->p_paddr_valid)
4433 p->p_paddr = m->p_paddr;
4434 else if (m->count == 0)
4435 p->p_paddr = 0;
4436 else
4437 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
4439 if (p->p_type == PT_LOAD
4440 && (abfd->flags & D_PAGED) != 0)
4442 /* p_align in demand paged PT_LOAD segments effectively stores
4443 the maximum page size. When copying an executable with
4444 objcopy, we set m->p_align from the input file. Use this
4445 value for maxpagesize rather than bed->maxpagesize, which
4446 may be different. Note that we use maxpagesize for PT_TLS
4447 segment alignment later in this function, so we are relying
4448 on at least one PT_LOAD segment appearing before a PT_TLS
4449 segment. */
4450 if (m->p_align_valid)
4451 maxpagesize = m->p_align;
4453 p->p_align = maxpagesize;
4455 else if (m->p_align_valid)
4456 p->p_align = m->p_align;
4457 else if (m->count == 0)
4458 p->p_align = 1 << bed->s->log_file_align;
4459 else
4460 p->p_align = 0;
4462 no_contents = FALSE;
4463 off_adjust = 0;
4464 if (p->p_type == PT_LOAD
4465 && m->count > 0)
4467 bfd_size_type align;
4468 unsigned int align_power = 0;
4470 if (m->p_align_valid)
4471 align = p->p_align;
4472 else
4474 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4476 unsigned int secalign;
4478 secalign = bfd_get_section_alignment (abfd, *secpp);
4479 if (secalign > align_power)
4480 align_power = secalign;
4482 align = (bfd_size_type) 1 << align_power;
4483 if (align < maxpagesize)
4484 align = maxpagesize;
4487 for (i = 0; i < m->count; i++)
4488 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4489 /* If we aren't making room for this section, then
4490 it must be SHT_NOBITS regardless of what we've
4491 set via struct bfd_elf_special_section. */
4492 elf_section_type (m->sections[i]) = SHT_NOBITS;
4494 /* Find out whether this segment contains any loadable
4495 sections. */
4496 no_contents = TRUE;
4497 for (i = 0; i < m->count; i++)
4498 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4500 no_contents = FALSE;
4501 break;
4504 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
4505 off += off_adjust;
4506 if (no_contents)
4508 /* We shouldn't need to align the segment on disk since
4509 the segment doesn't need file space, but the gABI
4510 arguably requires the alignment and glibc ld.so
4511 checks it. So to comply with the alignment
4512 requirement but not waste file space, we adjust
4513 p_offset for just this segment. (OFF_ADJUST is
4514 subtracted from OFF later.) This may put p_offset
4515 past the end of file, but that shouldn't matter. */
4517 else
4518 off_adjust = 0;
4520 /* Make sure the .dynamic section is the first section in the
4521 PT_DYNAMIC segment. */
4522 else if (p->p_type == PT_DYNAMIC
4523 && m->count > 1
4524 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4526 _bfd_error_handler
4527 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4528 abfd);
4529 bfd_set_error (bfd_error_bad_value);
4530 return FALSE;
4532 /* Set the note section type to SHT_NOTE. */
4533 else if (p->p_type == PT_NOTE)
4534 for (i = 0; i < m->count; i++)
4535 elf_section_type (m->sections[i]) = SHT_NOTE;
4537 p->p_offset = 0;
4538 p->p_filesz = 0;
4539 p->p_memsz = 0;
4541 if (m->includes_filehdr)
4543 if (!m->p_flags_valid)
4544 p->p_flags |= PF_R;
4545 p->p_filesz = bed->s->sizeof_ehdr;
4546 p->p_memsz = bed->s->sizeof_ehdr;
4547 if (m->count > 0)
4549 BFD_ASSERT (p->p_type == PT_LOAD);
4551 if (p->p_vaddr < (bfd_vma) off)
4553 (*_bfd_error_handler)
4554 (_("%B: Not enough room for program headers, try linking with -N"),
4555 abfd);
4556 bfd_set_error (bfd_error_bad_value);
4557 return FALSE;
4560 p->p_vaddr -= off;
4561 if (!m->p_paddr_valid)
4562 p->p_paddr -= off;
4566 if (m->includes_phdrs)
4568 if (!m->p_flags_valid)
4569 p->p_flags |= PF_R;
4571 if (!m->includes_filehdr)
4573 p->p_offset = bed->s->sizeof_ehdr;
4575 if (m->count > 0)
4577 BFD_ASSERT (p->p_type == PT_LOAD);
4578 p->p_vaddr -= off - p->p_offset;
4579 if (!m->p_paddr_valid)
4580 p->p_paddr -= off - p->p_offset;
4584 p->p_filesz += alloc * bed->s->sizeof_phdr;
4585 p->p_memsz += alloc * bed->s->sizeof_phdr;
4586 if (m->count)
4588 p->p_filesz += header_pad;
4589 p->p_memsz += header_pad;
4593 if (p->p_type == PT_LOAD
4594 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4596 if (!m->includes_filehdr && !m->includes_phdrs)
4597 p->p_offset = off;
4598 else
4600 file_ptr adjust;
4602 adjust = off - (p->p_offset + p->p_filesz);
4603 if (!no_contents)
4604 p->p_filesz += adjust;
4605 p->p_memsz += adjust;
4609 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4610 maps. Set filepos for sections in PT_LOAD segments, and in
4611 core files, for sections in PT_NOTE segments.
4612 assign_file_positions_for_non_load_sections will set filepos
4613 for other sections and update p_filesz for other segments. */
4614 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4616 asection *sec;
4617 bfd_size_type align;
4618 Elf_Internal_Shdr *this_hdr;
4620 sec = *secpp;
4621 this_hdr = &elf_section_data (sec)->this_hdr;
4622 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
4624 if ((p->p_type == PT_LOAD
4625 || p->p_type == PT_TLS)
4626 && (this_hdr->sh_type != SHT_NOBITS
4627 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4628 && ((this_hdr->sh_flags & SHF_TLS) == 0
4629 || p->p_type == PT_TLS))))
4631 bfd_vma p_start = p->p_paddr;
4632 bfd_vma p_end = p_start + p->p_memsz;
4633 bfd_vma s_start = sec->lma;
4634 bfd_vma adjust = s_start - p_end;
4636 if (adjust != 0
4637 && (s_start < p_end
4638 || p_end < p_start))
4640 (*_bfd_error_handler)
4641 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
4642 (unsigned long) s_start, (unsigned long) p_end);
4643 adjust = 0;
4644 sec->lma = p_end;
4646 p->p_memsz += adjust;
4648 if (this_hdr->sh_type != SHT_NOBITS)
4650 if (p->p_filesz + adjust < p->p_memsz)
4652 /* We have a PROGBITS section following NOBITS ones.
4653 Allocate file space for the NOBITS section(s) and
4654 zero it. */
4655 adjust = p->p_memsz - p->p_filesz;
4656 if (!write_zeros (abfd, off, adjust))
4657 return FALSE;
4659 off += adjust;
4660 p->p_filesz += adjust;
4664 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4666 /* The section at i == 0 is the one that actually contains
4667 everything. */
4668 if (i == 0)
4670 this_hdr->sh_offset = sec->filepos = off;
4671 off += this_hdr->sh_size;
4672 p->p_filesz = this_hdr->sh_size;
4673 p->p_memsz = 0;
4674 p->p_align = 1;
4676 else
4678 /* The rest are fake sections that shouldn't be written. */
4679 sec->filepos = 0;
4680 sec->size = 0;
4681 sec->flags = 0;
4682 continue;
4685 else
4687 if (p->p_type == PT_LOAD)
4689 this_hdr->sh_offset = sec->filepos = off;
4690 if (this_hdr->sh_type != SHT_NOBITS)
4691 off += this_hdr->sh_size;
4693 else if (this_hdr->sh_type == SHT_NOBITS
4694 && (this_hdr->sh_flags & SHF_TLS) != 0
4695 && this_hdr->sh_offset == 0)
4697 /* This is a .tbss section that didn't get a PT_LOAD.
4698 (See _bfd_elf_map_sections_to_segments "Create a
4699 final PT_LOAD".) Set sh_offset to the value it
4700 would have if we had created a zero p_filesz and
4701 p_memsz PT_LOAD header for the section. This
4702 also makes the PT_TLS header have the same
4703 p_offset value. */
4704 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
4705 off, align);
4706 this_hdr->sh_offset = sec->filepos = off + adjust;
4709 if (this_hdr->sh_type != SHT_NOBITS)
4711 p->p_filesz += this_hdr->sh_size;
4712 /* A load section without SHF_ALLOC is something like
4713 a note section in a PT_NOTE segment. These take
4714 file space but are not loaded into memory. */
4715 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4716 p->p_memsz += this_hdr->sh_size;
4718 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
4720 if (p->p_type == PT_TLS)
4721 p->p_memsz += this_hdr->sh_size;
4723 /* .tbss is special. It doesn't contribute to p_memsz of
4724 normal segments. */
4725 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4726 p->p_memsz += this_hdr->sh_size;
4729 if (align > p->p_align
4730 && !m->p_align_valid
4731 && (p->p_type != PT_LOAD
4732 || (abfd->flags & D_PAGED) == 0))
4733 p->p_align = align;
4736 if (!m->p_flags_valid)
4738 p->p_flags |= PF_R;
4739 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
4740 p->p_flags |= PF_X;
4741 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
4742 p->p_flags |= PF_W;
4745 off -= off_adjust;
4747 /* Check that all sections are in a PT_LOAD segment.
4748 Don't check funky gdb generated core files. */
4749 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
4751 bfd_boolean check_vma = TRUE;
4753 for (i = 1; i < m->count; i++)
4754 if (m->sections[i]->vma == m->sections[i - 1]->vma
4755 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
4756 ->this_hdr), p) != 0
4757 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
4758 ->this_hdr), p) != 0)
4760 /* Looks like we have overlays packed into the segment. */
4761 check_vma = FALSE;
4762 break;
4765 for (i = 0; i < m->count; i++)
4767 Elf_Internal_Shdr *this_hdr;
4768 asection *sec;
4770 sec = m->sections[i];
4771 this_hdr = &(elf_section_data(sec)->this_hdr);
4772 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
4773 && !ELF_TBSS_SPECIAL (this_hdr, p))
4775 (*_bfd_error_handler)
4776 (_("%B: section `%A' can't be allocated in segment %d"),
4777 abfd, sec, j);
4778 print_segment_map (m);
4784 elf_tdata (abfd)->next_file_pos = off;
4785 return TRUE;
4788 /* Assign file positions for the other sections. */
4790 static bfd_boolean
4791 assign_file_positions_for_non_load_sections (bfd *abfd,
4792 struct bfd_link_info *link_info)
4794 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4795 Elf_Internal_Shdr **i_shdrpp;
4796 Elf_Internal_Shdr **hdrpp;
4797 Elf_Internal_Phdr *phdrs;
4798 Elf_Internal_Phdr *p;
4799 struct elf_segment_map *m;
4800 bfd_vma filehdr_vaddr, filehdr_paddr;
4801 bfd_vma phdrs_vaddr, phdrs_paddr;
4802 file_ptr off;
4803 unsigned int num_sec;
4804 unsigned int i;
4805 unsigned int count;
4807 i_shdrpp = elf_elfsections (abfd);
4808 num_sec = elf_numsections (abfd);
4809 off = elf_tdata (abfd)->next_file_pos;
4810 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4812 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4813 Elf_Internal_Shdr *hdr;
4815 hdr = *hdrpp;
4816 if (hdr->bfd_section != NULL
4817 && (hdr->bfd_section->filepos != 0
4818 || (hdr->sh_type == SHT_NOBITS
4819 && hdr->contents == NULL)))
4820 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
4821 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4823 (*_bfd_error_handler)
4824 (_("%B: warning: allocated section `%s' not in segment"),
4825 abfd,
4826 (hdr->bfd_section == NULL
4827 ? "*unknown*"
4828 : hdr->bfd_section->name));
4829 /* We don't need to page align empty sections. */
4830 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
4831 off += vma_page_aligned_bias (hdr->sh_addr, off,
4832 bed->maxpagesize);
4833 else
4834 off += vma_page_aligned_bias (hdr->sh_addr, off,
4835 hdr->sh_addralign);
4836 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4837 FALSE);
4839 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4840 && hdr->bfd_section == NULL)
4841 || hdr == i_shdrpp[tdata->symtab_section]
4842 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4843 || hdr == i_shdrpp[tdata->strtab_section])
4844 hdr->sh_offset = -1;
4845 else
4846 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
4849 /* Now that we have set the section file positions, we can set up
4850 the file positions for the non PT_LOAD segments. */
4851 count = 0;
4852 filehdr_vaddr = 0;
4853 filehdr_paddr = 0;
4854 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4855 phdrs_paddr = 0;
4856 phdrs = elf_tdata (abfd)->phdr;
4857 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4858 m != NULL;
4859 m = m->next, p++)
4861 ++count;
4862 if (p->p_type != PT_LOAD)
4863 continue;
4865 if (m->includes_filehdr)
4867 filehdr_vaddr = p->p_vaddr;
4868 filehdr_paddr = p->p_paddr;
4870 if (m->includes_phdrs)
4872 phdrs_vaddr = p->p_vaddr;
4873 phdrs_paddr = p->p_paddr;
4874 if (m->includes_filehdr)
4876 phdrs_vaddr += bed->s->sizeof_ehdr;
4877 phdrs_paddr += bed->s->sizeof_ehdr;
4882 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4883 m != NULL;
4884 m = m->next, p++)
4886 if (p->p_type == PT_GNU_RELRO)
4888 const Elf_Internal_Phdr *lp;
4890 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4892 if (link_info != NULL)
4894 /* During linking the range of the RELRO segment is passed
4895 in link_info. */
4896 for (lp = phdrs; lp < phdrs + count; ++lp)
4898 if (lp->p_type == PT_LOAD
4899 && lp->p_vaddr >= link_info->relro_start
4900 && lp->p_vaddr < link_info->relro_end
4901 && lp->p_vaddr + lp->p_filesz >= link_info->relro_end)
4902 break;
4905 else
4907 /* Otherwise we are copying an executable or shared
4908 library, but we need to use the same linker logic. */
4909 for (lp = phdrs; lp < phdrs + count; ++lp)
4911 if (lp->p_type == PT_LOAD
4912 && lp->p_paddr == p->p_paddr)
4913 break;
4917 if (lp < phdrs + count)
4919 p->p_vaddr = lp->p_vaddr;
4920 p->p_paddr = lp->p_paddr;
4921 p->p_offset = lp->p_offset;
4922 if (link_info != NULL)
4923 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4924 else if (m->p_size_valid)
4925 p->p_filesz = m->p_size;
4926 else
4927 abort ();
4928 p->p_memsz = p->p_filesz;
4929 p->p_align = 1;
4930 p->p_flags = (lp->p_flags & ~PF_W);
4932 else
4934 memset (p, 0, sizeof *p);
4935 p->p_type = PT_NULL;
4938 else if (m->count != 0)
4940 if (p->p_type != PT_LOAD
4941 && (p->p_type != PT_NOTE
4942 || bfd_get_format (abfd) != bfd_core))
4944 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4946 p->p_filesz = 0;
4947 p->p_offset = m->sections[0]->filepos;
4948 for (i = m->count; i-- != 0;)
4950 asection *sect = m->sections[i];
4951 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
4952 if (hdr->sh_type != SHT_NOBITS)
4954 p->p_filesz = (sect->filepos - m->sections[0]->filepos
4955 + hdr->sh_size);
4956 break;
4961 else if (m->includes_filehdr)
4963 p->p_vaddr = filehdr_vaddr;
4964 if (! m->p_paddr_valid)
4965 p->p_paddr = filehdr_paddr;
4967 else if (m->includes_phdrs)
4969 p->p_vaddr = phdrs_vaddr;
4970 if (! m->p_paddr_valid)
4971 p->p_paddr = phdrs_paddr;
4975 elf_tdata (abfd)->next_file_pos = off;
4977 return TRUE;
4980 /* Work out the file positions of all the sections. This is called by
4981 _bfd_elf_compute_section_file_positions. All the section sizes and
4982 VMAs must be known before this is called.
4984 Reloc sections come in two flavours: Those processed specially as
4985 "side-channel" data attached to a section to which they apply, and
4986 those that bfd doesn't process as relocations. The latter sort are
4987 stored in a normal bfd section by bfd_section_from_shdr. We don't
4988 consider the former sort here, unless they form part of the loadable
4989 image. Reloc sections not assigned here will be handled later by
4990 assign_file_positions_for_relocs.
4992 We also don't set the positions of the .symtab and .strtab here. */
4994 static bfd_boolean
4995 assign_file_positions_except_relocs (bfd *abfd,
4996 struct bfd_link_info *link_info)
4998 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4999 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5000 file_ptr off;
5001 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5003 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
5004 && bfd_get_format (abfd) != bfd_core)
5006 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
5007 unsigned int num_sec = elf_numsections (abfd);
5008 Elf_Internal_Shdr **hdrpp;
5009 unsigned int i;
5011 /* Start after the ELF header. */
5012 off = i_ehdrp->e_ehsize;
5014 /* We are not creating an executable, which means that we are
5015 not creating a program header, and that the actual order of
5016 the sections in the file is unimportant. */
5017 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
5019 Elf_Internal_Shdr *hdr;
5021 hdr = *hdrpp;
5022 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5023 && hdr->bfd_section == NULL)
5024 || i == tdata->symtab_section
5025 || i == tdata->symtab_shndx_section
5026 || i == tdata->strtab_section)
5028 hdr->sh_offset = -1;
5030 else
5031 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5034 else
5036 unsigned int alloc;
5038 /* Assign file positions for the loaded sections based on the
5039 assignment of sections to segments. */
5040 if (!assign_file_positions_for_load_sections (abfd, link_info))
5041 return FALSE;
5043 /* And for non-load sections. */
5044 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
5045 return FALSE;
5047 if (bed->elf_backend_modify_program_headers != NULL)
5049 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
5050 return FALSE;
5053 /* Write out the program headers. */
5054 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
5055 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
5056 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
5057 return FALSE;
5059 off = tdata->next_file_pos;
5062 /* Place the section headers. */
5063 off = align_file_position (off, 1 << bed->s->log_file_align);
5064 i_ehdrp->e_shoff = off;
5065 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
5067 tdata->next_file_pos = off;
5069 return TRUE;
5072 static bfd_boolean
5073 prep_headers (bfd *abfd)
5075 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
5076 struct elf_strtab_hash *shstrtab;
5077 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5079 i_ehdrp = elf_elfheader (abfd);
5081 shstrtab = _bfd_elf_strtab_init ();
5082 if (shstrtab == NULL)
5083 return FALSE;
5085 elf_shstrtab (abfd) = shstrtab;
5087 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
5088 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
5089 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
5090 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
5092 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
5093 i_ehdrp->e_ident[EI_DATA] =
5094 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
5095 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
5097 if ((abfd->flags & DYNAMIC) != 0)
5098 i_ehdrp->e_type = ET_DYN;
5099 else if ((abfd->flags & EXEC_P) != 0)
5100 i_ehdrp->e_type = ET_EXEC;
5101 else if (bfd_get_format (abfd) == bfd_core)
5102 i_ehdrp->e_type = ET_CORE;
5103 else
5104 i_ehdrp->e_type = ET_REL;
5106 switch (bfd_get_arch (abfd))
5108 case bfd_arch_unknown:
5109 i_ehdrp->e_machine = EM_NONE;
5110 break;
5112 /* There used to be a long list of cases here, each one setting
5113 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5114 in the corresponding bfd definition. To avoid duplication,
5115 the switch was removed. Machines that need special handling
5116 can generally do it in elf_backend_final_write_processing(),
5117 unless they need the information earlier than the final write.
5118 Such need can generally be supplied by replacing the tests for
5119 e_machine with the conditions used to determine it. */
5120 default:
5121 i_ehdrp->e_machine = bed->elf_machine_code;
5124 i_ehdrp->e_version = bed->s->ev_current;
5125 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5127 /* No program header, for now. */
5128 i_ehdrp->e_phoff = 0;
5129 i_ehdrp->e_phentsize = 0;
5130 i_ehdrp->e_phnum = 0;
5132 /* Each bfd section is section header entry. */
5133 i_ehdrp->e_entry = bfd_get_start_address (abfd);
5134 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5136 /* If we're building an executable, we'll need a program header table. */
5137 if (abfd->flags & EXEC_P)
5138 /* It all happens later. */
5140 else
5142 i_ehdrp->e_phentsize = 0;
5143 i_ehdrp->e_phoff = 0;
5146 elf_tdata (abfd)->symtab_hdr.sh_name =
5147 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
5148 elf_tdata (abfd)->strtab_hdr.sh_name =
5149 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
5150 elf_tdata (abfd)->shstrtab_hdr.sh_name =
5151 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
5152 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5153 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5154 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
5155 return FALSE;
5157 return TRUE;
5160 /* Assign file positions for all the reloc sections which are not part
5161 of the loadable file image. */
5163 void
5164 _bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
5166 file_ptr off;
5167 unsigned int i, num_sec;
5168 Elf_Internal_Shdr **shdrpp;
5170 off = elf_tdata (abfd)->next_file_pos;
5172 num_sec = elf_numsections (abfd);
5173 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
5175 Elf_Internal_Shdr *shdrp;
5177 shdrp = *shdrpp;
5178 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
5179 && shdrp->sh_offset == -1)
5180 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
5183 elf_tdata (abfd)->next_file_pos = off;
5186 bfd_boolean
5187 _bfd_elf_write_object_contents (bfd *abfd)
5189 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
5190 Elf_Internal_Shdr **i_shdrp;
5191 bfd_boolean failed;
5192 unsigned int count, num_sec;
5194 if (! abfd->output_has_begun
5195 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
5196 return FALSE;
5198 i_shdrp = elf_elfsections (abfd);
5200 failed = FALSE;
5201 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5202 if (failed)
5203 return FALSE;
5205 _bfd_elf_assign_file_positions_for_relocs (abfd);
5207 /* After writing the headers, we need to write the sections too... */
5208 num_sec = elf_numsections (abfd);
5209 for (count = 1; count < num_sec; count++)
5211 if (bed->elf_backend_section_processing)
5212 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5213 if (i_shdrp[count]->contents)
5215 bfd_size_type amt = i_shdrp[count]->sh_size;
5217 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
5218 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
5219 return FALSE;
5223 /* Write out the section header names. */
5224 if (elf_shstrtab (abfd) != NULL
5225 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
5226 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
5227 return FALSE;
5229 if (bed->elf_backend_final_write_processing)
5230 (*bed->elf_backend_final_write_processing) (abfd,
5231 elf_tdata (abfd)->linker);
5233 if (!bed->s->write_shdrs_and_ehdr (abfd))
5234 return FALSE;
5236 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
5237 if (elf_tdata (abfd)->after_write_object_contents)
5238 return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
5240 return TRUE;
5243 bfd_boolean
5244 _bfd_elf_write_corefile_contents (bfd *abfd)
5246 /* Hopefully this can be done just like an object file. */
5247 return _bfd_elf_write_object_contents (abfd);
5250 /* Given a section, search the header to find them. */
5252 unsigned int
5253 _bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
5255 const struct elf_backend_data *bed;
5256 unsigned int sec_index;
5258 if (elf_section_data (asect) != NULL
5259 && elf_section_data (asect)->this_idx != 0)
5260 return elf_section_data (asect)->this_idx;
5262 if (bfd_is_abs_section (asect))
5263 sec_index = SHN_ABS;
5264 else if (bfd_is_com_section (asect))
5265 sec_index = SHN_COMMON;
5266 else if (bfd_is_und_section (asect))
5267 sec_index = SHN_UNDEF;
5268 else
5269 sec_index = SHN_BAD;
5271 bed = get_elf_backend_data (abfd);
5272 if (bed->elf_backend_section_from_bfd_section)
5274 int retval = sec_index;
5276 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5277 return retval;
5280 if (sec_index == SHN_BAD)
5281 bfd_set_error (bfd_error_nonrepresentable_section);
5283 return sec_index;
5286 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
5287 on error. */
5290 _bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
5292 asymbol *asym_ptr = *asym_ptr_ptr;
5293 int idx;
5294 flagword flags = asym_ptr->flags;
5296 /* When gas creates relocations against local labels, it creates its
5297 own symbol for the section, but does put the symbol into the
5298 symbol chain, so udata is 0. When the linker is generating
5299 relocatable output, this section symbol may be for one of the
5300 input sections rather than the output section. */
5301 if (asym_ptr->udata.i == 0
5302 && (flags & BSF_SECTION_SYM)
5303 && asym_ptr->section)
5305 asection *sec;
5306 int indx;
5308 sec = asym_ptr->section;
5309 if (sec->owner != abfd && sec->output_section != NULL)
5310 sec = sec->output_section;
5311 if (sec->owner == abfd
5312 && (indx = sec->index) < elf_num_section_syms (abfd)
5313 && elf_section_syms (abfd)[indx] != NULL)
5314 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5317 idx = asym_ptr->udata.i;
5319 if (idx == 0)
5321 /* This case can occur when using --strip-symbol on a symbol
5322 which is used in a relocation entry. */
5323 (*_bfd_error_handler)
5324 (_("%B: symbol `%s' required but not present"),
5325 abfd, bfd_asymbol_name (asym_ptr));
5326 bfd_set_error (bfd_error_no_symbols);
5327 return -1;
5330 #if DEBUG & 4
5332 fprintf (stderr,
5333 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5334 (long) asym_ptr, asym_ptr->name, idx, (long) flags);
5335 fflush (stderr);
5337 #endif
5339 return idx;
5342 /* Rewrite program header information. */
5344 static bfd_boolean
5345 rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
5347 Elf_Internal_Ehdr *iehdr;
5348 struct elf_segment_map *map;
5349 struct elf_segment_map *map_first;
5350 struct elf_segment_map **pointer_to_map;
5351 Elf_Internal_Phdr *segment;
5352 asection *section;
5353 unsigned int i;
5354 unsigned int num_segments;
5355 bfd_boolean phdr_included = FALSE;
5356 bfd_boolean p_paddr_valid;
5357 bfd_vma maxpagesize;
5358 struct elf_segment_map *phdr_adjust_seg = NULL;
5359 unsigned int phdr_adjust_num = 0;
5360 const struct elf_backend_data *bed;
5362 bed = get_elf_backend_data (ibfd);
5363 iehdr = elf_elfheader (ibfd);
5365 map_first = NULL;
5366 pointer_to_map = &map_first;
5368 num_segments = elf_elfheader (ibfd)->e_phnum;
5369 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5371 /* Returns the end address of the segment + 1. */
5372 #define SEGMENT_END(segment, start) \
5373 (start + (segment->p_memsz > segment->p_filesz \
5374 ? segment->p_memsz : segment->p_filesz))
5376 #define SECTION_SIZE(section, segment) \
5377 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5378 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
5379 ? section->size : 0)
5381 /* Returns TRUE if the given section is contained within
5382 the given segment. VMA addresses are compared. */
5383 #define IS_CONTAINED_BY_VMA(section, segment) \
5384 (section->vma >= segment->p_vaddr \
5385 && (section->vma + SECTION_SIZE (section, segment) \
5386 <= (SEGMENT_END (segment, segment->p_vaddr))))
5388 /* Returns TRUE if the given section is contained within
5389 the given segment. LMA addresses are compared. */
5390 #define IS_CONTAINED_BY_LMA(section, segment, base) \
5391 (section->lma >= base \
5392 && (section->lma + SECTION_SIZE (section, segment) \
5393 <= SEGMENT_END (segment, base)))
5395 /* Handle PT_NOTE segment. */
5396 #define IS_NOTE(p, s) \
5397 (p->p_type == PT_NOTE \
5398 && elf_section_type (s) == SHT_NOTE \
5399 && (bfd_vma) s->filepos >= p->p_offset \
5400 && ((bfd_vma) s->filepos + s->size \
5401 <= p->p_offset + p->p_filesz))
5403 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5404 etc. */
5405 #define IS_COREFILE_NOTE(p, s) \
5406 (IS_NOTE (p, s) \
5407 && bfd_get_format (ibfd) == bfd_core \
5408 && s->vma == 0 \
5409 && s->lma == 0)
5411 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5412 linker, which generates a PT_INTERP section with p_vaddr and
5413 p_memsz set to 0. */
5414 #define IS_SOLARIS_PT_INTERP(p, s) \
5415 (p->p_vaddr == 0 \
5416 && p->p_paddr == 0 \
5417 && p->p_memsz == 0 \
5418 && p->p_filesz > 0 \
5419 && (s->flags & SEC_HAS_CONTENTS) != 0 \
5420 && s->size > 0 \
5421 && (bfd_vma) s->filepos >= p->p_offset \
5422 && ((bfd_vma) s->filepos + s->size \
5423 <= p->p_offset + p->p_filesz))
5425 /* Decide if the given section should be included in the given segment.
5426 A section will be included if:
5427 1. It is within the address space of the segment -- we use the LMA
5428 if that is set for the segment and the VMA otherwise,
5429 2. It is an allocated section or a NOTE section in a PT_NOTE
5430 segment.
5431 3. There is an output section associated with it,
5432 4. The section has not already been allocated to a previous segment.
5433 5. PT_GNU_STACK segments do not include any sections.
5434 6. PT_TLS segment includes only SHF_TLS sections.
5435 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5436 8. PT_DYNAMIC should not contain empty sections at the beginning
5437 (with the possible exception of .dynamic). */
5438 #define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
5439 ((((segment->p_paddr \
5440 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5441 : IS_CONTAINED_BY_VMA (section, segment)) \
5442 && (section->flags & SEC_ALLOC) != 0) \
5443 || IS_NOTE (segment, section)) \
5444 && segment->p_type != PT_GNU_STACK \
5445 && (segment->p_type != PT_TLS \
5446 || (section->flags & SEC_THREAD_LOCAL)) \
5447 && (segment->p_type == PT_LOAD \
5448 || segment->p_type == PT_TLS \
5449 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5450 && (segment->p_type != PT_DYNAMIC \
5451 || SECTION_SIZE (section, segment) > 0 \
5452 || (segment->p_paddr \
5453 ? segment->p_paddr != section->lma \
5454 : segment->p_vaddr != section->vma) \
5455 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5456 == 0)) \
5457 && !section->segment_mark)
5459 /* If the output section of a section in the input segment is NULL,
5460 it is removed from the corresponding output segment. */
5461 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5462 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5463 && section->output_section != NULL)
5465 /* Returns TRUE iff seg1 starts after the end of seg2. */
5466 #define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5467 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5469 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5470 their VMA address ranges and their LMA address ranges overlap.
5471 It is possible to have overlapping VMA ranges without overlapping LMA
5472 ranges. RedBoot images for example can have both .data and .bss mapped
5473 to the same VMA range, but with the .data section mapped to a different
5474 LMA. */
5475 #define SEGMENT_OVERLAPS(seg1, seg2) \
5476 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
5477 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
5478 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
5479 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
5481 /* Initialise the segment mark field. */
5482 for (section = ibfd->sections; section != NULL; section = section->next)
5483 section->segment_mark = FALSE;
5485 /* The Solaris linker creates program headers in which all the
5486 p_paddr fields are zero. When we try to objcopy or strip such a
5487 file, we get confused. Check for this case, and if we find it
5488 don't set the p_paddr_valid fields. */
5489 p_paddr_valid = FALSE;
5490 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5491 i < num_segments;
5492 i++, segment++)
5493 if (segment->p_paddr != 0)
5495 p_paddr_valid = TRUE;
5496 break;
5499 /* Scan through the segments specified in the program header
5500 of the input BFD. For this first scan we look for overlaps
5501 in the loadable segments. These can be created by weird
5502 parameters to objcopy. Also, fix some solaris weirdness. */
5503 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5504 i < num_segments;
5505 i++, segment++)
5507 unsigned int j;
5508 Elf_Internal_Phdr *segment2;
5510 if (segment->p_type == PT_INTERP)
5511 for (section = ibfd->sections; section; section = section->next)
5512 if (IS_SOLARIS_PT_INTERP (segment, section))
5514 /* Mininal change so that the normal section to segment
5515 assignment code will work. */
5516 segment->p_vaddr = section->vma;
5517 break;
5520 if (segment->p_type != PT_LOAD)
5522 /* Remove PT_GNU_RELRO segment. */
5523 if (segment->p_type == PT_GNU_RELRO)
5524 segment->p_type = PT_NULL;
5525 continue;
5528 /* Determine if this segment overlaps any previous segments. */
5529 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
5531 bfd_signed_vma extra_length;
5533 if (segment2->p_type != PT_LOAD
5534 || !SEGMENT_OVERLAPS (segment, segment2))
5535 continue;
5537 /* Merge the two segments together. */
5538 if (segment2->p_vaddr < segment->p_vaddr)
5540 /* Extend SEGMENT2 to include SEGMENT and then delete
5541 SEGMENT. */
5542 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5543 - SEGMENT_END (segment2, segment2->p_vaddr));
5545 if (extra_length > 0)
5547 segment2->p_memsz += extra_length;
5548 segment2->p_filesz += extra_length;
5551 segment->p_type = PT_NULL;
5553 /* Since we have deleted P we must restart the outer loop. */
5554 i = 0;
5555 segment = elf_tdata (ibfd)->phdr;
5556 break;
5558 else
5560 /* Extend SEGMENT to include SEGMENT2 and then delete
5561 SEGMENT2. */
5562 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5563 - SEGMENT_END (segment, segment->p_vaddr));
5565 if (extra_length > 0)
5567 segment->p_memsz += extra_length;
5568 segment->p_filesz += extra_length;
5571 segment2->p_type = PT_NULL;
5576 /* The second scan attempts to assign sections to segments. */
5577 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5578 i < num_segments;
5579 i++, segment++)
5581 unsigned int section_count;
5582 asection **sections;
5583 asection *output_section;
5584 unsigned int isec;
5585 bfd_vma matching_lma;
5586 bfd_vma suggested_lma;
5587 unsigned int j;
5588 bfd_size_type amt;
5589 asection *first_section;
5590 bfd_boolean first_matching_lma;
5591 bfd_boolean first_suggested_lma;
5593 if (segment->p_type == PT_NULL)
5594 continue;
5596 first_section = NULL;
5597 /* Compute how many sections might be placed into this segment. */
5598 for (section = ibfd->sections, section_count = 0;
5599 section != NULL;
5600 section = section->next)
5602 /* Find the first section in the input segment, which may be
5603 removed from the corresponding output segment. */
5604 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5606 if (first_section == NULL)
5607 first_section = section;
5608 if (section->output_section != NULL)
5609 ++section_count;
5613 /* Allocate a segment map big enough to contain
5614 all of the sections we have selected. */
5615 amt = sizeof (struct elf_segment_map);
5616 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5617 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
5618 if (map == NULL)
5619 return FALSE;
5621 /* Initialise the fields of the segment map. Default to
5622 using the physical address of the segment in the input BFD. */
5623 map->next = NULL;
5624 map->p_type = segment->p_type;
5625 map->p_flags = segment->p_flags;
5626 map->p_flags_valid = 1;
5628 /* If the first section in the input segment is removed, there is
5629 no need to preserve segment physical address in the corresponding
5630 output segment. */
5631 if (!first_section || first_section->output_section != NULL)
5633 map->p_paddr = segment->p_paddr;
5634 map->p_paddr_valid = p_paddr_valid;
5637 /* Determine if this segment contains the ELF file header
5638 and if it contains the program headers themselves. */
5639 map->includes_filehdr = (segment->p_offset == 0
5640 && segment->p_filesz >= iehdr->e_ehsize);
5641 map->includes_phdrs = 0;
5643 if (!phdr_included || segment->p_type != PT_LOAD)
5645 map->includes_phdrs =
5646 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5647 && (segment->p_offset + segment->p_filesz
5648 >= ((bfd_vma) iehdr->e_phoff
5649 + iehdr->e_phnum * iehdr->e_phentsize)));
5651 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5652 phdr_included = TRUE;
5655 if (section_count == 0)
5657 /* Special segments, such as the PT_PHDR segment, may contain
5658 no sections, but ordinary, loadable segments should contain
5659 something. They are allowed by the ELF spec however, so only
5660 a warning is produced. */
5661 if (segment->p_type == PT_LOAD)
5662 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5663 " detected, is this intentional ?\n"),
5664 ibfd);
5666 map->count = 0;
5667 *pointer_to_map = map;
5668 pointer_to_map = &map->next;
5670 continue;
5673 /* Now scan the sections in the input BFD again and attempt
5674 to add their corresponding output sections to the segment map.
5675 The problem here is how to handle an output section which has
5676 been moved (ie had its LMA changed). There are four possibilities:
5678 1. None of the sections have been moved.
5679 In this case we can continue to use the segment LMA from the
5680 input BFD.
5682 2. All of the sections have been moved by the same amount.
5683 In this case we can change the segment's LMA to match the LMA
5684 of the first section.
5686 3. Some of the sections have been moved, others have not.
5687 In this case those sections which have not been moved can be
5688 placed in the current segment which will have to have its size,
5689 and possibly its LMA changed, and a new segment or segments will
5690 have to be created to contain the other sections.
5692 4. The sections have been moved, but not by the same amount.
5693 In this case we can change the segment's LMA to match the LMA
5694 of the first section and we will have to create a new segment
5695 or segments to contain the other sections.
5697 In order to save time, we allocate an array to hold the section
5698 pointers that we are interested in. As these sections get assigned
5699 to a segment, they are removed from this array. */
5701 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
5702 if (sections == NULL)
5703 return FALSE;
5705 /* Step One: Scan for segment vs section LMA conflicts.
5706 Also add the sections to the section array allocated above.
5707 Also add the sections to the current segment. In the common
5708 case, where the sections have not been moved, this means that
5709 we have completely filled the segment, and there is nothing
5710 more to do. */
5711 isec = 0;
5712 matching_lma = 0;
5713 suggested_lma = 0;
5714 first_matching_lma = TRUE;
5715 first_suggested_lma = TRUE;
5717 for (section = ibfd->sections;
5718 section != NULL;
5719 section = section->next)
5720 if (section == first_section)
5721 break;
5723 for (j = 0; section != NULL; section = section->next)
5725 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
5727 output_section = section->output_section;
5729 sections[j++] = section;
5731 /* The Solaris native linker always sets p_paddr to 0.
5732 We try to catch that case here, and set it to the
5733 correct value. Note - some backends require that
5734 p_paddr be left as zero. */
5735 if (!p_paddr_valid
5736 && segment->p_vaddr != 0
5737 && !bed->want_p_paddr_set_to_zero
5738 && isec == 0
5739 && output_section->lma != 0
5740 && output_section->vma == (segment->p_vaddr
5741 + (map->includes_filehdr
5742 ? iehdr->e_ehsize
5743 : 0)
5744 + (map->includes_phdrs
5745 ? (iehdr->e_phnum
5746 * iehdr->e_phentsize)
5747 : 0)))
5748 map->p_paddr = segment->p_vaddr;
5750 /* Match up the physical address of the segment with the
5751 LMA address of the output section. */
5752 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5753 || IS_COREFILE_NOTE (segment, section)
5754 || (bed->want_p_paddr_set_to_zero
5755 && IS_CONTAINED_BY_VMA (output_section, segment)))
5757 if (first_matching_lma || output_section->lma < matching_lma)
5759 matching_lma = output_section->lma;
5760 first_matching_lma = FALSE;
5763 /* We assume that if the section fits within the segment
5764 then it does not overlap any other section within that
5765 segment. */
5766 map->sections[isec++] = output_section;
5768 else if (first_suggested_lma)
5770 suggested_lma = output_section->lma;
5771 first_suggested_lma = FALSE;
5774 if (j == section_count)
5775 break;
5779 BFD_ASSERT (j == section_count);
5781 /* Step Two: Adjust the physical address of the current segment,
5782 if necessary. */
5783 if (isec == section_count)
5785 /* All of the sections fitted within the segment as currently
5786 specified. This is the default case. Add the segment to
5787 the list of built segments and carry on to process the next
5788 program header in the input BFD. */
5789 map->count = section_count;
5790 *pointer_to_map = map;
5791 pointer_to_map = &map->next;
5793 if (p_paddr_valid
5794 && !bed->want_p_paddr_set_to_zero
5795 && matching_lma != map->p_paddr
5796 && !map->includes_filehdr
5797 && !map->includes_phdrs)
5798 /* There is some padding before the first section in the
5799 segment. So, we must account for that in the output
5800 segment's vma. */
5801 map->p_vaddr_offset = matching_lma - map->p_paddr;
5803 free (sections);
5804 continue;
5806 else
5808 if (!first_matching_lma)
5810 /* At least one section fits inside the current segment.
5811 Keep it, but modify its physical address to match the
5812 LMA of the first section that fitted. */
5813 map->p_paddr = matching_lma;
5815 else
5817 /* None of the sections fitted inside the current segment.
5818 Change the current segment's physical address to match
5819 the LMA of the first section. */
5820 map->p_paddr = suggested_lma;
5823 /* Offset the segment physical address from the lma
5824 to allow for space taken up by elf headers. */
5825 if (map->includes_filehdr)
5827 if (map->p_paddr >= iehdr->e_ehsize)
5828 map->p_paddr -= iehdr->e_ehsize;
5829 else
5831 map->includes_filehdr = FALSE;
5832 map->includes_phdrs = FALSE;
5836 if (map->includes_phdrs)
5838 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5840 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5842 /* iehdr->e_phnum is just an estimate of the number
5843 of program headers that we will need. Make a note
5844 here of the number we used and the segment we chose
5845 to hold these headers, so that we can adjust the
5846 offset when we know the correct value. */
5847 phdr_adjust_num = iehdr->e_phnum;
5848 phdr_adjust_seg = map;
5850 else
5851 map->includes_phdrs = FALSE;
5855 /* Step Three: Loop over the sections again, this time assigning
5856 those that fit to the current segment and removing them from the
5857 sections array; but making sure not to leave large gaps. Once all
5858 possible sections have been assigned to the current segment it is
5859 added to the list of built segments and if sections still remain
5860 to be assigned, a new segment is constructed before repeating
5861 the loop. */
5862 isec = 0;
5865 map->count = 0;
5866 suggested_lma = 0;
5867 first_suggested_lma = TRUE;
5869 /* Fill the current segment with sections that fit. */
5870 for (j = 0; j < section_count; j++)
5872 section = sections[j];
5874 if (section == NULL)
5875 continue;
5877 output_section = section->output_section;
5879 BFD_ASSERT (output_section != NULL);
5881 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5882 || IS_COREFILE_NOTE (segment, section))
5884 if (map->count == 0)
5886 /* If the first section in a segment does not start at
5887 the beginning of the segment, then something is
5888 wrong. */
5889 if (output_section->lma
5890 != (map->p_paddr
5891 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5892 + (map->includes_phdrs
5893 ? iehdr->e_phnum * iehdr->e_phentsize
5894 : 0)))
5895 abort ();
5897 else
5899 asection *prev_sec;
5901 prev_sec = map->sections[map->count - 1];
5903 /* If the gap between the end of the previous section
5904 and the start of this section is more than
5905 maxpagesize then we need to start a new segment. */
5906 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
5907 maxpagesize)
5908 < BFD_ALIGN (output_section->lma, maxpagesize))
5909 || (prev_sec->lma + prev_sec->size
5910 > output_section->lma))
5912 if (first_suggested_lma)
5914 suggested_lma = output_section->lma;
5915 first_suggested_lma = FALSE;
5918 continue;
5922 map->sections[map->count++] = output_section;
5923 ++isec;
5924 sections[j] = NULL;
5925 section->segment_mark = TRUE;
5927 else if (first_suggested_lma)
5929 suggested_lma = output_section->lma;
5930 first_suggested_lma = FALSE;
5934 BFD_ASSERT (map->count > 0);
5936 /* Add the current segment to the list of built segments. */
5937 *pointer_to_map = map;
5938 pointer_to_map = &map->next;
5940 if (isec < section_count)
5942 /* We still have not allocated all of the sections to
5943 segments. Create a new segment here, initialise it
5944 and carry on looping. */
5945 amt = sizeof (struct elf_segment_map);
5946 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5947 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
5948 if (map == NULL)
5950 free (sections);
5951 return FALSE;
5954 /* Initialise the fields of the segment map. Set the physical
5955 physical address to the LMA of the first section that has
5956 not yet been assigned. */
5957 map->next = NULL;
5958 map->p_type = segment->p_type;
5959 map->p_flags = segment->p_flags;
5960 map->p_flags_valid = 1;
5961 map->p_paddr = suggested_lma;
5962 map->p_paddr_valid = p_paddr_valid;
5963 map->includes_filehdr = 0;
5964 map->includes_phdrs = 0;
5967 while (isec < section_count);
5969 free (sections);
5972 elf_tdata (obfd)->segment_map = map_first;
5974 /* If we had to estimate the number of program headers that were
5975 going to be needed, then check our estimate now and adjust
5976 the offset if necessary. */
5977 if (phdr_adjust_seg != NULL)
5979 unsigned int count;
5981 for (count = 0, map = map_first; map != NULL; map = map->next)
5982 count++;
5984 if (count > phdr_adjust_num)
5985 phdr_adjust_seg->p_paddr
5986 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5989 #undef SEGMENT_END
5990 #undef SECTION_SIZE
5991 #undef IS_CONTAINED_BY_VMA
5992 #undef IS_CONTAINED_BY_LMA
5993 #undef IS_NOTE
5994 #undef IS_COREFILE_NOTE
5995 #undef IS_SOLARIS_PT_INTERP
5996 #undef IS_SECTION_IN_INPUT_SEGMENT
5997 #undef INCLUDE_SECTION_IN_SEGMENT
5998 #undef SEGMENT_AFTER_SEGMENT
5999 #undef SEGMENT_OVERLAPS
6000 return TRUE;
6003 /* Copy ELF program header information. */
6005 static bfd_boolean
6006 copy_elf_program_header (bfd *ibfd, bfd *obfd)
6008 Elf_Internal_Ehdr *iehdr;
6009 struct elf_segment_map *map;
6010 struct elf_segment_map *map_first;
6011 struct elf_segment_map **pointer_to_map;
6012 Elf_Internal_Phdr *segment;
6013 unsigned int i;
6014 unsigned int num_segments;
6015 bfd_boolean phdr_included = FALSE;
6016 bfd_boolean p_paddr_valid;
6018 iehdr = elf_elfheader (ibfd);
6020 map_first = NULL;
6021 pointer_to_map = &map_first;
6023 /* If all the segment p_paddr fields are zero, don't set
6024 map->p_paddr_valid. */
6025 p_paddr_valid = FALSE;
6026 num_segments = elf_elfheader (ibfd)->e_phnum;
6027 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6028 i < num_segments;
6029 i++, segment++)
6030 if (segment->p_paddr != 0)
6032 p_paddr_valid = TRUE;
6033 break;
6036 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6037 i < num_segments;
6038 i++, segment++)
6040 asection *section;
6041 unsigned int section_count;
6042 bfd_size_type amt;
6043 Elf_Internal_Shdr *this_hdr;
6044 asection *first_section = NULL;
6045 asection *lowest_section;
6047 /* Compute how many sections are in this segment. */
6048 for (section = ibfd->sections, section_count = 0;
6049 section != NULL;
6050 section = section->next)
6052 this_hdr = &(elf_section_data(section)->this_hdr);
6053 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6055 if (first_section == NULL)
6056 first_section = section;
6057 section_count++;
6061 /* Allocate a segment map big enough to contain
6062 all of the sections we have selected. */
6063 amt = sizeof (struct elf_segment_map);
6064 if (section_count != 0)
6065 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
6066 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
6067 if (map == NULL)
6068 return FALSE;
6070 /* Initialize the fields of the output segment map with the
6071 input segment. */
6072 map->next = NULL;
6073 map->p_type = segment->p_type;
6074 map->p_flags = segment->p_flags;
6075 map->p_flags_valid = 1;
6076 map->p_paddr = segment->p_paddr;
6077 map->p_paddr_valid = p_paddr_valid;
6078 map->p_align = segment->p_align;
6079 map->p_align_valid = 1;
6080 map->p_vaddr_offset = 0;
6082 if (map->p_type == PT_GNU_RELRO)
6084 /* The PT_GNU_RELRO segment may contain the first a few
6085 bytes in the .got.plt section even if the whole .got.plt
6086 section isn't in the PT_GNU_RELRO segment. We won't
6087 change the size of the PT_GNU_RELRO segment. */
6088 map->p_size = segment->p_memsz;
6089 map->p_size_valid = 1;
6092 /* Determine if this segment contains the ELF file header
6093 and if it contains the program headers themselves. */
6094 map->includes_filehdr = (segment->p_offset == 0
6095 && segment->p_filesz >= iehdr->e_ehsize);
6097 map->includes_phdrs = 0;
6098 if (! phdr_included || segment->p_type != PT_LOAD)
6100 map->includes_phdrs =
6101 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6102 && (segment->p_offset + segment->p_filesz
6103 >= ((bfd_vma) iehdr->e_phoff
6104 + iehdr->e_phnum * iehdr->e_phentsize)));
6106 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6107 phdr_included = TRUE;
6110 lowest_section = first_section;
6111 if (section_count != 0)
6113 unsigned int isec = 0;
6115 for (section = first_section;
6116 section != NULL;
6117 section = section->next)
6119 this_hdr = &(elf_section_data(section)->this_hdr);
6120 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6122 map->sections[isec++] = section->output_section;
6123 if (section->lma < lowest_section->lma)
6124 lowest_section = section;
6125 if ((section->flags & SEC_ALLOC) != 0)
6127 bfd_vma seg_off;
6129 /* Section lmas are set up from PT_LOAD header
6130 p_paddr in _bfd_elf_make_section_from_shdr.
6131 If this header has a p_paddr that disagrees
6132 with the section lma, flag the p_paddr as
6133 invalid. */
6134 if ((section->flags & SEC_LOAD) != 0)
6135 seg_off = this_hdr->sh_offset - segment->p_offset;
6136 else
6137 seg_off = this_hdr->sh_addr - segment->p_vaddr;
6138 if (section->lma - segment->p_paddr != seg_off)
6139 map->p_paddr_valid = FALSE;
6141 if (isec == section_count)
6142 break;
6147 if (map->includes_filehdr && lowest_section != NULL)
6148 /* We need to keep the space used by the headers fixed. */
6149 map->header_size = lowest_section->vma - segment->p_vaddr;
6151 if (!map->includes_phdrs
6152 && !map->includes_filehdr
6153 && map->p_paddr_valid)
6154 /* There is some other padding before the first section. */
6155 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
6156 - segment->p_paddr);
6158 map->count = section_count;
6159 *pointer_to_map = map;
6160 pointer_to_map = &map->next;
6163 elf_tdata (obfd)->segment_map = map_first;
6164 return TRUE;
6167 /* Copy private BFD data. This copies or rewrites ELF program header
6168 information. */
6170 static bfd_boolean
6171 copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6173 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6174 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6175 return TRUE;
6177 if (elf_tdata (ibfd)->phdr == NULL)
6178 return TRUE;
6180 if (ibfd->xvec == obfd->xvec)
6182 /* Check to see if any sections in the input BFD
6183 covered by ELF program header have changed. */
6184 Elf_Internal_Phdr *segment;
6185 asection *section, *osec;
6186 unsigned int i, num_segments;
6187 Elf_Internal_Shdr *this_hdr;
6188 const struct elf_backend_data *bed;
6190 bed = get_elf_backend_data (ibfd);
6192 /* Regenerate the segment map if p_paddr is set to 0. */
6193 if (bed->want_p_paddr_set_to_zero)
6194 goto rewrite;
6196 /* Initialize the segment mark field. */
6197 for (section = obfd->sections; section != NULL;
6198 section = section->next)
6199 section->segment_mark = FALSE;
6201 num_segments = elf_elfheader (ibfd)->e_phnum;
6202 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6203 i < num_segments;
6204 i++, segment++)
6206 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6207 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6208 which severly confuses things, so always regenerate the segment
6209 map in this case. */
6210 if (segment->p_paddr == 0
6211 && segment->p_memsz == 0
6212 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
6213 goto rewrite;
6215 for (section = ibfd->sections;
6216 section != NULL; section = section->next)
6218 /* We mark the output section so that we know it comes
6219 from the input BFD. */
6220 osec = section->output_section;
6221 if (osec)
6222 osec->segment_mark = TRUE;
6224 /* Check if this section is covered by the segment. */
6225 this_hdr = &(elf_section_data(section)->this_hdr);
6226 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
6228 /* FIXME: Check if its output section is changed or
6229 removed. What else do we need to check? */
6230 if (osec == NULL
6231 || section->flags != osec->flags
6232 || section->lma != osec->lma
6233 || section->vma != osec->vma
6234 || section->size != osec->size
6235 || section->rawsize != osec->rawsize
6236 || section->alignment_power != osec->alignment_power)
6237 goto rewrite;
6242 /* Check to see if any output section do not come from the
6243 input BFD. */
6244 for (section = obfd->sections; section != NULL;
6245 section = section->next)
6247 if (section->segment_mark == FALSE)
6248 goto rewrite;
6249 else
6250 section->segment_mark = FALSE;
6253 return copy_elf_program_header (ibfd, obfd);
6256 rewrite:
6257 return rewrite_elf_program_header (ibfd, obfd);
6260 /* Initialize private output section information from input section. */
6262 bfd_boolean
6263 _bfd_elf_init_private_section_data (bfd *ibfd,
6264 asection *isec,
6265 bfd *obfd,
6266 asection *osec,
6267 struct bfd_link_info *link_info)
6270 Elf_Internal_Shdr *ihdr, *ohdr;
6271 bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
6273 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6274 || obfd->xvec->flavour != bfd_target_elf_flavour)
6275 return TRUE;
6277 BFD_ASSERT (elf_section_data (osec) != NULL);
6279 /* For objcopy and relocatable link, don't copy the output ELF
6280 section type from input if the output BFD section flags have been
6281 set to something different. For a final link allow some flags
6282 that the linker clears to differ. */
6283 if (elf_section_type (osec) == SHT_NULL
6284 && (osec->flags == isec->flags
6285 || (final_link
6286 && ((osec->flags ^ isec->flags)
6287 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
6288 elf_section_type (osec) = elf_section_type (isec);
6290 /* FIXME: Is this correct for all OS/PROC specific flags? */
6291 elf_section_flags (osec) |= (elf_section_flags (isec)
6292 & (SHF_MASKOS | SHF_MASKPROC));
6294 /* Set things up for objcopy and relocatable link. The output
6295 SHT_GROUP section will have its elf_next_in_group pointing back
6296 to the input group members. Ignore linker created group section.
6297 See elfNN_ia64_object_p in elfxx-ia64.c. */
6298 if (!final_link)
6300 if (elf_sec_group (isec) == NULL
6301 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6303 if (elf_section_flags (isec) & SHF_GROUP)
6304 elf_section_flags (osec) |= SHF_GROUP;
6305 elf_next_in_group (osec) = elf_next_in_group (isec);
6306 elf_section_data (osec)->group = elf_section_data (isec)->group;
6310 ihdr = &elf_section_data (isec)->this_hdr;
6312 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6313 don't use the output section of the linked-to section since it
6314 may be NULL at this point. */
6315 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6317 ohdr = &elf_section_data (osec)->this_hdr;
6318 ohdr->sh_flags |= SHF_LINK_ORDER;
6319 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6322 osec->use_rela_p = isec->use_rela_p;
6324 return TRUE;
6327 /* Copy private section information. This copies over the entsize
6328 field, and sometimes the info field. */
6330 bfd_boolean
6331 _bfd_elf_copy_private_section_data (bfd *ibfd,
6332 asection *isec,
6333 bfd *obfd,
6334 asection *osec)
6336 Elf_Internal_Shdr *ihdr, *ohdr;
6338 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6339 || obfd->xvec->flavour != bfd_target_elf_flavour)
6340 return TRUE;
6342 ihdr = &elf_section_data (isec)->this_hdr;
6343 ohdr = &elf_section_data (osec)->this_hdr;
6345 ohdr->sh_entsize = ihdr->sh_entsize;
6347 if (ihdr->sh_type == SHT_SYMTAB
6348 || ihdr->sh_type == SHT_DYNSYM
6349 || ihdr->sh_type == SHT_GNU_verneed
6350 || ihdr->sh_type == SHT_GNU_verdef)
6351 ohdr->sh_info = ihdr->sh_info;
6353 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6354 NULL);
6357 /* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6358 necessary if we are removing either the SHT_GROUP section or any of
6359 the group member sections. DISCARDED is the value that a section's
6360 output_section has if the section will be discarded, NULL when this
6361 function is called from objcopy, bfd_abs_section_ptr when called
6362 from the linker. */
6364 bfd_boolean
6365 _bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
6367 asection *isec;
6369 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6370 if (elf_section_type (isec) == SHT_GROUP)
6372 asection *first = elf_next_in_group (isec);
6373 asection *s = first;
6374 bfd_size_type removed = 0;
6376 while (s != NULL)
6378 /* If this member section is being output but the
6379 SHT_GROUP section is not, then clear the group info
6380 set up by _bfd_elf_copy_private_section_data. */
6381 if (s->output_section != discarded
6382 && isec->output_section == discarded)
6384 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6385 elf_group_name (s->output_section) = NULL;
6387 /* Conversely, if the member section is not being output
6388 but the SHT_GROUP section is, then adjust its size. */
6389 else if (s->output_section == discarded
6390 && isec->output_section != discarded)
6391 removed += 4;
6392 s = elf_next_in_group (s);
6393 if (s == first)
6394 break;
6396 if (removed != 0)
6398 if (discarded != NULL)
6400 /* If we've been called for ld -r, then we need to
6401 adjust the input section size. This function may
6402 be called multiple times, so save the original
6403 size. */
6404 if (isec->rawsize == 0)
6405 isec->rawsize = isec->size;
6406 isec->size = isec->rawsize - removed;
6408 else
6410 /* Adjust the output section size when called from
6411 objcopy. */
6412 isec->output_section->size -= removed;
6417 return TRUE;
6420 /* Copy private header information. */
6422 bfd_boolean
6423 _bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6425 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6426 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6427 return TRUE;
6429 /* Copy over private BFD data if it has not already been copied.
6430 This must be done here, rather than in the copy_private_bfd_data
6431 entry point, because the latter is called after the section
6432 contents have been set, which means that the program headers have
6433 already been worked out. */
6434 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6436 if (! copy_private_bfd_data (ibfd, obfd))
6437 return FALSE;
6440 return _bfd_elf_fixup_group_sections (ibfd, NULL);
6443 /* Copy private symbol information. If this symbol is in a section
6444 which we did not map into a BFD section, try to map the section
6445 index correctly. We use special macro definitions for the mapped
6446 section indices; these definitions are interpreted by the
6447 swap_out_syms function. */
6449 #define MAP_ONESYMTAB (SHN_HIOS + 1)
6450 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
6451 #define MAP_STRTAB (SHN_HIOS + 3)
6452 #define MAP_SHSTRTAB (SHN_HIOS + 4)
6453 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
6455 bfd_boolean
6456 _bfd_elf_copy_private_symbol_data (bfd *ibfd,
6457 asymbol *isymarg,
6458 bfd *obfd,
6459 asymbol *osymarg)
6461 elf_symbol_type *isym, *osym;
6463 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6464 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6465 return TRUE;
6467 isym = elf_symbol_from (ibfd, isymarg);
6468 osym = elf_symbol_from (obfd, osymarg);
6470 if (isym != NULL
6471 && isym->internal_elf_sym.st_shndx != 0
6472 && osym != NULL
6473 && bfd_is_abs_section (isym->symbol.section))
6475 unsigned int shndx;
6477 shndx = isym->internal_elf_sym.st_shndx;
6478 if (shndx == elf_onesymtab (ibfd))
6479 shndx = MAP_ONESYMTAB;
6480 else if (shndx == elf_dynsymtab (ibfd))
6481 shndx = MAP_DYNSYMTAB;
6482 else if (shndx == elf_tdata (ibfd)->strtab_section)
6483 shndx = MAP_STRTAB;
6484 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6485 shndx = MAP_SHSTRTAB;
6486 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6487 shndx = MAP_SYM_SHNDX;
6488 osym->internal_elf_sym.st_shndx = shndx;
6491 return TRUE;
6494 /* Swap out the symbols. */
6496 static bfd_boolean
6497 swap_out_syms (bfd *abfd,
6498 struct bfd_strtab_hash **sttp,
6499 int relocatable_p)
6501 const struct elf_backend_data *bed;
6502 int symcount;
6503 asymbol **syms;
6504 struct bfd_strtab_hash *stt;
6505 Elf_Internal_Shdr *symtab_hdr;
6506 Elf_Internal_Shdr *symtab_shndx_hdr;
6507 Elf_Internal_Shdr *symstrtab_hdr;
6508 bfd_byte *outbound_syms;
6509 bfd_byte *outbound_shndx;
6510 int idx;
6511 bfd_size_type amt;
6512 bfd_boolean name_local_sections;
6514 if (!elf_map_symbols (abfd))
6515 return FALSE;
6517 /* Dump out the symtabs. */
6518 stt = _bfd_elf_stringtab_init ();
6519 if (stt == NULL)
6520 return FALSE;
6522 bed = get_elf_backend_data (abfd);
6523 symcount = bfd_get_symcount (abfd);
6524 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6525 symtab_hdr->sh_type = SHT_SYMTAB;
6526 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6527 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6528 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
6529 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
6531 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6532 symstrtab_hdr->sh_type = SHT_STRTAB;
6534 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6535 bed->s->sizeof_sym);
6536 if (outbound_syms == NULL)
6538 _bfd_stringtab_free (stt);
6539 return FALSE;
6541 symtab_hdr->contents = outbound_syms;
6543 outbound_shndx = NULL;
6544 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6545 if (symtab_shndx_hdr->sh_name != 0)
6547 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
6548 outbound_shndx = (bfd_byte *)
6549 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
6550 if (outbound_shndx == NULL)
6552 _bfd_stringtab_free (stt);
6553 return FALSE;
6556 symtab_shndx_hdr->contents = outbound_shndx;
6557 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6558 symtab_shndx_hdr->sh_size = amt;
6559 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6560 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6563 /* Now generate the data (for "contents"). */
6565 /* Fill in zeroth symbol and swap it out. */
6566 Elf_Internal_Sym sym;
6567 sym.st_name = 0;
6568 sym.st_value = 0;
6569 sym.st_size = 0;
6570 sym.st_info = 0;
6571 sym.st_other = 0;
6572 sym.st_shndx = SHN_UNDEF;
6573 sym.st_target_internal = 0;
6574 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6575 outbound_syms += bed->s->sizeof_sym;
6576 if (outbound_shndx != NULL)
6577 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6580 name_local_sections
6581 = (bed->elf_backend_name_local_section_symbols
6582 && bed->elf_backend_name_local_section_symbols (abfd));
6584 syms = bfd_get_outsymbols (abfd);
6585 for (idx = 0; idx < symcount; idx++)
6587 Elf_Internal_Sym sym;
6588 bfd_vma value = syms[idx]->value;
6589 elf_symbol_type *type_ptr;
6590 flagword flags = syms[idx]->flags;
6591 int type;
6593 if (!name_local_sections
6594 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
6596 /* Local section symbols have no name. */
6597 sym.st_name = 0;
6599 else
6601 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6602 syms[idx]->name,
6603 TRUE, FALSE);
6604 if (sym.st_name == (unsigned long) -1)
6606 _bfd_stringtab_free (stt);
6607 return FALSE;
6611 type_ptr = elf_symbol_from (abfd, syms[idx]);
6613 if ((flags & BSF_SECTION_SYM) == 0
6614 && bfd_is_com_section (syms[idx]->section))
6616 /* ELF common symbols put the alignment into the `value' field,
6617 and the size into the `size' field. This is backwards from
6618 how BFD handles it, so reverse it here. */
6619 sym.st_size = value;
6620 if (type_ptr == NULL
6621 || type_ptr->internal_elf_sym.st_value == 0)
6622 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6623 else
6624 sym.st_value = type_ptr->internal_elf_sym.st_value;
6625 sym.st_shndx = _bfd_elf_section_from_bfd_section
6626 (abfd, syms[idx]->section);
6628 else
6630 asection *sec = syms[idx]->section;
6631 unsigned int shndx;
6633 if (sec->output_section)
6635 value += sec->output_offset;
6636 sec = sec->output_section;
6639 /* Don't add in the section vma for relocatable output. */
6640 if (! relocatable_p)
6641 value += sec->vma;
6642 sym.st_value = value;
6643 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6645 if (bfd_is_abs_section (sec)
6646 && type_ptr != NULL
6647 && type_ptr->internal_elf_sym.st_shndx != 0)
6649 /* This symbol is in a real ELF section which we did
6650 not create as a BFD section. Undo the mapping done
6651 by copy_private_symbol_data. */
6652 shndx = type_ptr->internal_elf_sym.st_shndx;
6653 switch (shndx)
6655 case MAP_ONESYMTAB:
6656 shndx = elf_onesymtab (abfd);
6657 break;
6658 case MAP_DYNSYMTAB:
6659 shndx = elf_dynsymtab (abfd);
6660 break;
6661 case MAP_STRTAB:
6662 shndx = elf_tdata (abfd)->strtab_section;
6663 break;
6664 case MAP_SHSTRTAB:
6665 shndx = elf_tdata (abfd)->shstrtab_section;
6666 break;
6667 case MAP_SYM_SHNDX:
6668 shndx = elf_tdata (abfd)->symtab_shndx_section;
6669 break;
6670 default:
6671 break;
6674 else
6676 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6678 if (shndx == SHN_BAD)
6680 asection *sec2;
6682 /* Writing this would be a hell of a lot easier if
6683 we had some decent documentation on bfd, and
6684 knew what to expect of the library, and what to
6685 demand of applications. For example, it
6686 appears that `objcopy' might not set the
6687 section of a symbol to be a section that is
6688 actually in the output file. */
6689 sec2 = bfd_get_section_by_name (abfd, sec->name);
6690 if (sec2 == NULL)
6692 _bfd_error_handler (_("\
6693 Unable to find equivalent output section for symbol '%s' from section '%s'"),
6694 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6695 sec->name);
6696 bfd_set_error (bfd_error_invalid_operation);
6697 _bfd_stringtab_free (stt);
6698 return FALSE;
6701 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6702 BFD_ASSERT (shndx != SHN_BAD);
6706 sym.st_shndx = shndx;
6709 if ((flags & BSF_THREAD_LOCAL) != 0)
6710 type = STT_TLS;
6711 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6712 type = STT_GNU_IFUNC;
6713 else if ((flags & BSF_FUNCTION) != 0)
6714 type = STT_FUNC;
6715 else if ((flags & BSF_OBJECT) != 0)
6716 type = STT_OBJECT;
6717 else if ((flags & BSF_RELC) != 0)
6718 type = STT_RELC;
6719 else if ((flags & BSF_SRELC) != 0)
6720 type = STT_SRELC;
6721 else
6722 type = STT_NOTYPE;
6724 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6725 type = STT_TLS;
6727 /* Processor-specific types. */
6728 if (type_ptr != NULL
6729 && bed->elf_backend_get_symbol_type)
6730 type = ((*bed->elf_backend_get_symbol_type)
6731 (&type_ptr->internal_elf_sym, type));
6733 if (flags & BSF_SECTION_SYM)
6735 if (flags & BSF_GLOBAL)
6736 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6737 else
6738 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6740 else if (bfd_is_com_section (syms[idx]->section))
6742 #ifdef USE_STT_COMMON
6743 if (type == STT_OBJECT)
6744 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6745 else
6746 #endif
6747 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6749 else if (bfd_is_und_section (syms[idx]->section))
6750 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6751 ? STB_WEAK
6752 : STB_GLOBAL),
6753 type);
6754 else if (flags & BSF_FILE)
6755 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6756 else
6758 int bind = STB_LOCAL;
6760 if (flags & BSF_LOCAL)
6761 bind = STB_LOCAL;
6762 else if (flags & BSF_GNU_UNIQUE)
6763 bind = STB_GNU_UNIQUE;
6764 else if (flags & BSF_WEAK)
6765 bind = STB_WEAK;
6766 else if (flags & BSF_GLOBAL)
6767 bind = STB_GLOBAL;
6769 sym.st_info = ELF_ST_INFO (bind, type);
6772 if (type_ptr != NULL)
6774 sym.st_other = type_ptr->internal_elf_sym.st_other;
6775 sym.st_target_internal
6776 = type_ptr->internal_elf_sym.st_target_internal;
6778 else
6780 sym.st_other = 0;
6781 sym.st_target_internal = 0;
6784 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
6785 outbound_syms += bed->s->sizeof_sym;
6786 if (outbound_shndx != NULL)
6787 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
6790 *sttp = stt;
6791 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6792 symstrtab_hdr->sh_type = SHT_STRTAB;
6794 symstrtab_hdr->sh_flags = 0;
6795 symstrtab_hdr->sh_addr = 0;
6796 symstrtab_hdr->sh_entsize = 0;
6797 symstrtab_hdr->sh_link = 0;
6798 symstrtab_hdr->sh_info = 0;
6799 symstrtab_hdr->sh_addralign = 1;
6801 return TRUE;
6804 /* Return the number of bytes required to hold the symtab vector.
6806 Note that we base it on the count plus 1, since we will null terminate
6807 the vector allocated based on this size. However, the ELF symbol table
6808 always has a dummy entry as symbol #0, so it ends up even. */
6810 long
6811 _bfd_elf_get_symtab_upper_bound (bfd *abfd)
6813 long symcount;
6814 long symtab_size;
6815 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6817 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6818 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6819 if (symcount > 0)
6820 symtab_size -= sizeof (asymbol *);
6822 return symtab_size;
6825 long
6826 _bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
6828 long symcount;
6829 long symtab_size;
6830 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6832 if (elf_dynsymtab (abfd) == 0)
6834 bfd_set_error (bfd_error_invalid_operation);
6835 return -1;
6838 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
6839 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6840 if (symcount > 0)
6841 symtab_size -= sizeof (asymbol *);
6843 return symtab_size;
6846 long
6847 _bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6848 sec_ptr asect)
6850 return (asect->reloc_count + 1) * sizeof (arelent *);
6853 /* Canonicalize the relocs. */
6855 long
6856 _bfd_elf_canonicalize_reloc (bfd *abfd,
6857 sec_ptr section,
6858 arelent **relptr,
6859 asymbol **symbols)
6861 arelent *tblptr;
6862 unsigned int i;
6863 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6865 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
6866 return -1;
6868 tblptr = section->relocation;
6869 for (i = 0; i < section->reloc_count; i++)
6870 *relptr++ = tblptr++;
6872 *relptr = NULL;
6874 return section->reloc_count;
6877 long
6878 _bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
6880 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6881 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
6883 if (symcount >= 0)
6884 bfd_get_symcount (abfd) = symcount;
6885 return symcount;
6888 long
6889 _bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6890 asymbol **allocation)
6892 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6893 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
6895 if (symcount >= 0)
6896 bfd_get_dynamic_symcount (abfd) = symcount;
6897 return symcount;
6900 /* Return the size required for the dynamic reloc entries. Any loadable
6901 section that was actually installed in the BFD, and has type SHT_REL
6902 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6903 dynamic reloc section. */
6905 long
6906 _bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
6908 long ret;
6909 asection *s;
6911 if (elf_dynsymtab (abfd) == 0)
6913 bfd_set_error (bfd_error_invalid_operation);
6914 return -1;
6917 ret = sizeof (arelent *);
6918 for (s = abfd->sections; s != NULL; s = s->next)
6919 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6920 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6921 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6922 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
6923 * sizeof (arelent *));
6925 return ret;
6928 /* Canonicalize the dynamic relocation entries. Note that we return the
6929 dynamic relocations as a single block, although they are actually
6930 associated with particular sections; the interface, which was
6931 designed for SunOS style shared libraries, expects that there is only
6932 one set of dynamic relocs. Any loadable section that was actually
6933 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6934 dynamic symbol table, is considered to be a dynamic reloc section. */
6936 long
6937 _bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6938 arelent **storage,
6939 asymbol **syms)
6941 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
6942 asection *s;
6943 long ret;
6945 if (elf_dynsymtab (abfd) == 0)
6947 bfd_set_error (bfd_error_invalid_operation);
6948 return -1;
6951 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6952 ret = 0;
6953 for (s = abfd->sections; s != NULL; s = s->next)
6955 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6956 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6957 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6959 arelent *p;
6960 long count, i;
6962 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
6963 return -1;
6964 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
6965 p = s->relocation;
6966 for (i = 0; i < count; i++)
6967 *storage++ = p++;
6968 ret += count;
6972 *storage = NULL;
6974 return ret;
6977 /* Read in the version information. */
6979 bfd_boolean
6980 _bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
6982 bfd_byte *contents = NULL;
6983 unsigned int freeidx = 0;
6985 if (elf_dynverref (abfd) != 0)
6987 Elf_Internal_Shdr *hdr;
6988 Elf_External_Verneed *everneed;
6989 Elf_Internal_Verneed *iverneed;
6990 unsigned int i;
6991 bfd_byte *contents_end;
6993 hdr = &elf_tdata (abfd)->dynverref_hdr;
6995 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
6996 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
6997 if (elf_tdata (abfd)->verref == NULL)
6998 goto error_return;
7000 elf_tdata (abfd)->cverrefs = hdr->sh_info;
7002 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7003 if (contents == NULL)
7005 error_return_verref:
7006 elf_tdata (abfd)->verref = NULL;
7007 elf_tdata (abfd)->cverrefs = 0;
7008 goto error_return;
7010 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7011 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7012 goto error_return_verref;
7014 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
7015 goto error_return_verref;
7017 BFD_ASSERT (sizeof (Elf_External_Verneed)
7018 == sizeof (Elf_External_Vernaux));
7019 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
7020 everneed = (Elf_External_Verneed *) contents;
7021 iverneed = elf_tdata (abfd)->verref;
7022 for (i = 0; i < hdr->sh_info; i++, iverneed++)
7024 Elf_External_Vernaux *evernaux;
7025 Elf_Internal_Vernaux *ivernaux;
7026 unsigned int j;
7028 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7030 iverneed->vn_bfd = abfd;
7032 iverneed->vn_filename =
7033 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7034 iverneed->vn_file);
7035 if (iverneed->vn_filename == NULL)
7036 goto error_return_verref;
7038 if (iverneed->vn_cnt == 0)
7039 iverneed->vn_auxptr = NULL;
7040 else
7042 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7043 bfd_alloc2 (abfd, iverneed->vn_cnt,
7044 sizeof (Elf_Internal_Vernaux));
7045 if (iverneed->vn_auxptr == NULL)
7046 goto error_return_verref;
7049 if (iverneed->vn_aux
7050 > (size_t) (contents_end - (bfd_byte *) everneed))
7051 goto error_return_verref;
7053 evernaux = ((Elf_External_Vernaux *)
7054 ((bfd_byte *) everneed + iverneed->vn_aux));
7055 ivernaux = iverneed->vn_auxptr;
7056 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
7058 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
7060 ivernaux->vna_nodename =
7061 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7062 ivernaux->vna_name);
7063 if (ivernaux->vna_nodename == NULL)
7064 goto error_return_verref;
7066 if (j + 1 < iverneed->vn_cnt)
7067 ivernaux->vna_nextptr = ivernaux + 1;
7068 else
7069 ivernaux->vna_nextptr = NULL;
7071 if (ivernaux->vna_next
7072 > (size_t) (contents_end - (bfd_byte *) evernaux))
7073 goto error_return_verref;
7075 evernaux = ((Elf_External_Vernaux *)
7076 ((bfd_byte *) evernaux + ivernaux->vna_next));
7078 if (ivernaux->vna_other > freeidx)
7079 freeidx = ivernaux->vna_other;
7082 if (i + 1 < hdr->sh_info)
7083 iverneed->vn_nextref = iverneed + 1;
7084 else
7085 iverneed->vn_nextref = NULL;
7087 if (iverneed->vn_next
7088 > (size_t) (contents_end - (bfd_byte *) everneed))
7089 goto error_return_verref;
7091 everneed = ((Elf_External_Verneed *)
7092 ((bfd_byte *) everneed + iverneed->vn_next));
7095 free (contents);
7096 contents = NULL;
7099 if (elf_dynverdef (abfd) != 0)
7101 Elf_Internal_Shdr *hdr;
7102 Elf_External_Verdef *everdef;
7103 Elf_Internal_Verdef *iverdef;
7104 Elf_Internal_Verdef *iverdefarr;
7105 Elf_Internal_Verdef iverdefmem;
7106 unsigned int i;
7107 unsigned int maxidx;
7108 bfd_byte *contents_end_def, *contents_end_aux;
7110 hdr = &elf_tdata (abfd)->dynverdef_hdr;
7112 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
7113 if (contents == NULL)
7114 goto error_return;
7115 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7116 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
7117 goto error_return;
7119 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
7120 goto error_return;
7122 BFD_ASSERT (sizeof (Elf_External_Verdef)
7123 >= sizeof (Elf_External_Verdaux));
7124 contents_end_def = contents + hdr->sh_size
7125 - sizeof (Elf_External_Verdef);
7126 contents_end_aux = contents + hdr->sh_size
7127 - sizeof (Elf_External_Verdaux);
7129 /* We know the number of entries in the section but not the maximum
7130 index. Therefore we have to run through all entries and find
7131 the maximum. */
7132 everdef = (Elf_External_Verdef *) contents;
7133 maxidx = 0;
7134 for (i = 0; i < hdr->sh_info; ++i)
7136 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7138 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
7139 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
7141 if (iverdefmem.vd_next
7142 > (size_t) (contents_end_def - (bfd_byte *) everdef))
7143 goto error_return;
7145 everdef = ((Elf_External_Verdef *)
7146 ((bfd_byte *) everdef + iverdefmem.vd_next));
7149 if (default_imported_symver)
7151 if (freeidx > maxidx)
7152 maxidx = ++freeidx;
7153 else
7154 freeidx = ++maxidx;
7156 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7157 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
7158 if (elf_tdata (abfd)->verdef == NULL)
7159 goto error_return;
7161 elf_tdata (abfd)->cverdefs = maxidx;
7163 everdef = (Elf_External_Verdef *) contents;
7164 iverdefarr = elf_tdata (abfd)->verdef;
7165 for (i = 0; i < hdr->sh_info; i++)
7167 Elf_External_Verdaux *everdaux;
7168 Elf_Internal_Verdaux *iverdaux;
7169 unsigned int j;
7171 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7173 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
7175 error_return_verdef:
7176 elf_tdata (abfd)->verdef = NULL;
7177 elf_tdata (abfd)->cverdefs = 0;
7178 goto error_return;
7181 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
7182 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
7184 iverdef->vd_bfd = abfd;
7186 if (iverdef->vd_cnt == 0)
7187 iverdef->vd_auxptr = NULL;
7188 else
7190 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7191 bfd_alloc2 (abfd, iverdef->vd_cnt,
7192 sizeof (Elf_Internal_Verdaux));
7193 if (iverdef->vd_auxptr == NULL)
7194 goto error_return_verdef;
7197 if (iverdef->vd_aux
7198 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
7199 goto error_return_verdef;
7201 everdaux = ((Elf_External_Verdaux *)
7202 ((bfd_byte *) everdef + iverdef->vd_aux));
7203 iverdaux = iverdef->vd_auxptr;
7204 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
7206 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
7208 iverdaux->vda_nodename =
7209 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7210 iverdaux->vda_name);
7211 if (iverdaux->vda_nodename == NULL)
7212 goto error_return_verdef;
7214 if (j + 1 < iverdef->vd_cnt)
7215 iverdaux->vda_nextptr = iverdaux + 1;
7216 else
7217 iverdaux->vda_nextptr = NULL;
7219 if (iverdaux->vda_next
7220 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7221 goto error_return_verdef;
7223 everdaux = ((Elf_External_Verdaux *)
7224 ((bfd_byte *) everdaux + iverdaux->vda_next));
7227 if (iverdef->vd_cnt)
7228 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
7230 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
7231 iverdef->vd_nextdef = iverdef + 1;
7232 else
7233 iverdef->vd_nextdef = NULL;
7235 everdef = ((Elf_External_Verdef *)
7236 ((bfd_byte *) everdef + iverdef->vd_next));
7239 free (contents);
7240 contents = NULL;
7242 else if (default_imported_symver)
7244 if (freeidx < 3)
7245 freeidx = 3;
7246 else
7247 freeidx++;
7249 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7250 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
7251 if (elf_tdata (abfd)->verdef == NULL)
7252 goto error_return;
7254 elf_tdata (abfd)->cverdefs = freeidx;
7257 /* Create a default version based on the soname. */
7258 if (default_imported_symver)
7260 Elf_Internal_Verdef *iverdef;
7261 Elf_Internal_Verdaux *iverdaux;
7263 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
7265 iverdef->vd_version = VER_DEF_CURRENT;
7266 iverdef->vd_flags = 0;
7267 iverdef->vd_ndx = freeidx;
7268 iverdef->vd_cnt = 1;
7270 iverdef->vd_bfd = abfd;
7272 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7273 if (iverdef->vd_nodename == NULL)
7274 goto error_return_verdef;
7275 iverdef->vd_nextdef = NULL;
7276 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7277 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
7278 if (iverdef->vd_auxptr == NULL)
7279 goto error_return_verdef;
7281 iverdaux = iverdef->vd_auxptr;
7282 iverdaux->vda_nodename = iverdef->vd_nodename;
7283 iverdaux->vda_nextptr = NULL;
7286 return TRUE;
7288 error_return:
7289 if (contents != NULL)
7290 free (contents);
7291 return FALSE;
7294 asymbol *
7295 _bfd_elf_make_empty_symbol (bfd *abfd)
7297 elf_symbol_type *newsym;
7298 bfd_size_type amt = sizeof (elf_symbol_type);
7300 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
7301 if (!newsym)
7302 return NULL;
7303 else
7305 newsym->symbol.the_bfd = abfd;
7306 return &newsym->symbol;
7310 void
7311 _bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7312 asymbol *symbol,
7313 symbol_info *ret)
7315 bfd_symbol_info (symbol, ret);
7318 /* Return whether a symbol name implies a local symbol. Most targets
7319 use this function for the is_local_label_name entry point, but some
7320 override it. */
7322 bfd_boolean
7323 _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7324 const char *name)
7326 /* Normal local symbols start with ``.L''. */
7327 if (name[0] == '.' && name[1] == 'L')
7328 return TRUE;
7330 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7331 DWARF debugging symbols starting with ``..''. */
7332 if (name[0] == '.' && name[1] == '.')
7333 return TRUE;
7335 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7336 emitting DWARF debugging output. I suspect this is actually a
7337 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7338 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7339 underscore to be emitted on some ELF targets). For ease of use,
7340 we treat such symbols as local. */
7341 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
7342 return TRUE;
7344 return FALSE;
7347 alent *
7348 _bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7349 asymbol *symbol ATTRIBUTE_UNUSED)
7351 abort ();
7352 return NULL;
7355 bfd_boolean
7356 _bfd_elf_set_arch_mach (bfd *abfd,
7357 enum bfd_architecture arch,
7358 unsigned long machine)
7360 /* If this isn't the right architecture for this backend, and this
7361 isn't the generic backend, fail. */
7362 if (arch != get_elf_backend_data (abfd)->arch
7363 && arch != bfd_arch_unknown
7364 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
7365 return FALSE;
7367 return bfd_default_set_arch_mach (abfd, arch, machine);
7370 /* Find the function to a particular section and offset,
7371 for error reporting. */
7373 static bfd_boolean
7374 elf_find_function (bfd *abfd,
7375 asection *section,
7376 asymbol **symbols,
7377 bfd_vma offset,
7378 const char **filename_ptr,
7379 const char **functionname_ptr)
7381 const char *filename;
7382 asymbol *func, *file;
7383 bfd_vma low_func;
7384 asymbol **p;
7385 /* ??? Given multiple file symbols, it is impossible to reliably
7386 choose the right file name for global symbols. File symbols are
7387 local symbols, and thus all file symbols must sort before any
7388 global symbols. The ELF spec may be interpreted to say that a
7389 file symbol must sort before other local symbols, but currently
7390 ld -r doesn't do this. So, for ld -r output, it is possible to
7391 make a better choice of file name for local symbols by ignoring
7392 file symbols appearing after a given local symbol. */
7393 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7394 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7396 if (symbols == NULL)
7397 return FALSE;
7399 filename = NULL;
7400 func = NULL;
7401 file = NULL;
7402 low_func = 0;
7403 state = nothing_seen;
7405 for (p = symbols; *p != NULL; p++)
7407 asymbol *sym = *p;
7408 asection *code_sec;
7409 bfd_vma code_off;
7411 if ((sym->flags & BSF_FILE) != 0)
7413 file = sym;
7414 if (state == symbol_seen)
7415 state = file_after_symbol_seen;
7416 continue;
7419 if (bed->maybe_function_sym (sym, &code_sec, &code_off)
7420 && code_sec == section
7421 && code_off >= low_func
7422 && code_off <= offset)
7424 func = sym;
7425 low_func = code_off;
7426 filename = NULL;
7427 if (file != NULL
7428 && ((sym->flags & BSF_LOCAL) != 0
7429 || state != file_after_symbol_seen))
7430 filename = bfd_asymbol_name (file);
7432 if (state == nothing_seen)
7433 state = symbol_seen;
7436 if (func == NULL)
7437 return FALSE;
7439 if (filename_ptr)
7440 *filename_ptr = filename;
7441 if (functionname_ptr)
7442 *functionname_ptr = bfd_asymbol_name (func);
7444 return TRUE;
7447 /* Find the nearest line to a particular section and offset,
7448 for error reporting. */
7450 bfd_boolean
7451 _bfd_elf_find_nearest_line (bfd *abfd,
7452 asection *section,
7453 asymbol **symbols,
7454 bfd_vma offset,
7455 const char **filename_ptr,
7456 const char **functionname_ptr,
7457 unsigned int *line_ptr)
7459 bfd_boolean found;
7461 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
7462 filename_ptr, functionname_ptr,
7463 line_ptr))
7465 if (!*functionname_ptr)
7466 elf_find_function (abfd, section, symbols, offset,
7467 *filename_ptr ? NULL : filename_ptr,
7468 functionname_ptr);
7470 return TRUE;
7473 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
7474 section, symbols, offset,
7475 filename_ptr, functionname_ptr,
7476 line_ptr, 0,
7477 &elf_tdata (abfd)->dwarf2_find_line_info))
7479 if (!*functionname_ptr)
7480 elf_find_function (abfd, section, symbols, offset,
7481 *filename_ptr ? NULL : filename_ptr,
7482 functionname_ptr);
7484 return TRUE;
7487 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7488 &found, filename_ptr,
7489 functionname_ptr, line_ptr,
7490 &elf_tdata (abfd)->line_info))
7491 return FALSE;
7492 if (found && (*functionname_ptr || *line_ptr))
7493 return TRUE;
7495 if (symbols == NULL)
7496 return FALSE;
7498 if (! elf_find_function (abfd, section, symbols, offset,
7499 filename_ptr, functionname_ptr))
7500 return FALSE;
7502 *line_ptr = 0;
7503 return TRUE;
7506 /* Find the line for a symbol. */
7508 bfd_boolean
7509 _bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7510 const char **filename_ptr, unsigned int *line_ptr)
7512 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7513 filename_ptr, line_ptr, 0,
7514 &elf_tdata (abfd)->dwarf2_find_line_info);
7517 /* After a call to bfd_find_nearest_line, successive calls to
7518 bfd_find_inliner_info can be used to get source information about
7519 each level of function inlining that terminated at the address
7520 passed to bfd_find_nearest_line. Currently this is only supported
7521 for DWARF2 with appropriate DWARF3 extensions. */
7523 bfd_boolean
7524 _bfd_elf_find_inliner_info (bfd *abfd,
7525 const char **filename_ptr,
7526 const char **functionname_ptr,
7527 unsigned int *line_ptr)
7529 bfd_boolean found;
7530 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7531 functionname_ptr, line_ptr,
7532 & elf_tdata (abfd)->dwarf2_find_line_info);
7533 return found;
7537 _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
7539 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7540 int ret = bed->s->sizeof_ehdr;
7542 if (!info->relocatable)
7544 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
7546 if (phdr_size == (bfd_size_type) -1)
7548 struct elf_segment_map *m;
7550 phdr_size = 0;
7551 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7552 phdr_size += bed->s->sizeof_phdr;
7554 if (phdr_size == 0)
7555 phdr_size = get_program_header_size (abfd, info);
7558 elf_tdata (abfd)->program_header_size = phdr_size;
7559 ret += phdr_size;
7562 return ret;
7565 bfd_boolean
7566 _bfd_elf_set_section_contents (bfd *abfd,
7567 sec_ptr section,
7568 const void *location,
7569 file_ptr offset,
7570 bfd_size_type count)
7572 Elf_Internal_Shdr *hdr;
7573 bfd_signed_vma pos;
7575 if (! abfd->output_has_begun
7576 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
7577 return FALSE;
7579 hdr = &elf_section_data (section)->this_hdr;
7580 pos = hdr->sh_offset + offset;
7581 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7582 || bfd_bwrite (location, count, abfd) != count)
7583 return FALSE;
7585 return TRUE;
7588 void
7589 _bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7590 arelent *cache_ptr ATTRIBUTE_UNUSED,
7591 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
7593 abort ();
7596 /* Try to convert a non-ELF reloc into an ELF one. */
7598 bfd_boolean
7599 _bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
7601 /* Check whether we really have an ELF howto. */
7603 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7605 bfd_reloc_code_real_type code;
7606 reloc_howto_type *howto;
7608 /* Alien reloc: Try to determine its type to replace it with an
7609 equivalent ELF reloc. */
7611 if (areloc->howto->pc_relative)
7613 switch (areloc->howto->bitsize)
7615 case 8:
7616 code = BFD_RELOC_8_PCREL;
7617 break;
7618 case 12:
7619 code = BFD_RELOC_12_PCREL;
7620 break;
7621 case 16:
7622 code = BFD_RELOC_16_PCREL;
7623 break;
7624 case 24:
7625 code = BFD_RELOC_24_PCREL;
7626 break;
7627 case 32:
7628 code = BFD_RELOC_32_PCREL;
7629 break;
7630 case 64:
7631 code = BFD_RELOC_64_PCREL;
7632 break;
7633 default:
7634 goto fail;
7637 howto = bfd_reloc_type_lookup (abfd, code);
7639 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7641 if (howto->pcrel_offset)
7642 areloc->addend += areloc->address;
7643 else
7644 areloc->addend -= areloc->address; /* addend is unsigned!! */
7647 else
7649 switch (areloc->howto->bitsize)
7651 case 8:
7652 code = BFD_RELOC_8;
7653 break;
7654 case 14:
7655 code = BFD_RELOC_14;
7656 break;
7657 case 16:
7658 code = BFD_RELOC_16;
7659 break;
7660 case 26:
7661 code = BFD_RELOC_26;
7662 break;
7663 case 32:
7664 code = BFD_RELOC_32;
7665 break;
7666 case 64:
7667 code = BFD_RELOC_64;
7668 break;
7669 default:
7670 goto fail;
7673 howto = bfd_reloc_type_lookup (abfd, code);
7676 if (howto)
7677 areloc->howto = howto;
7678 else
7679 goto fail;
7682 return TRUE;
7684 fail:
7685 (*_bfd_error_handler)
7686 (_("%B: unsupported relocation type %s"),
7687 abfd, areloc->howto->name);
7688 bfd_set_error (bfd_error_bad_value);
7689 return FALSE;
7692 bfd_boolean
7693 _bfd_elf_close_and_cleanup (bfd *abfd)
7695 struct elf_obj_tdata *tdata = elf_tdata (abfd);
7696 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
7698 if (elf_shstrtab (abfd) != NULL)
7699 _bfd_elf_strtab_free (elf_shstrtab (abfd));
7700 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
7703 return _bfd_generic_close_and_cleanup (abfd);
7706 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7707 in the relocation's offset. Thus we cannot allow any sort of sanity
7708 range-checking to interfere. There is nothing else to do in processing
7709 this reloc. */
7711 bfd_reloc_status_type
7712 _bfd_elf_rel_vtable_reloc_fn
7713 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
7714 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
7715 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7716 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
7718 return bfd_reloc_ok;
7721 /* Elf core file support. Much of this only works on native
7722 toolchains, since we rely on knowing the
7723 machine-dependent procfs structure in order to pick
7724 out details about the corefile. */
7726 #ifdef HAVE_SYS_PROCFS_H
7727 /* Needed for new procfs interface on sparc-solaris. */
7728 # define _STRUCTURED_PROC 1
7729 # include <sys/procfs.h>
7730 #endif
7732 /* Return a PID that identifies a "thread" for threaded cores, or the
7733 PID of the main process for non-threaded cores. */
7735 static int
7736 elfcore_make_pid (bfd *abfd)
7738 int pid;
7740 pid = elf_tdata (abfd)->core_lwpid;
7741 if (pid == 0)
7742 pid = elf_tdata (abfd)->core_pid;
7744 return pid;
7747 /* If there isn't a section called NAME, make one, using
7748 data from SECT. Note, this function will generate a
7749 reference to NAME, so you shouldn't deallocate or
7750 overwrite it. */
7752 static bfd_boolean
7753 elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
7755 asection *sect2;
7757 if (bfd_get_section_by_name (abfd, name) != NULL)
7758 return TRUE;
7760 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
7761 if (sect2 == NULL)
7762 return FALSE;
7764 sect2->size = sect->size;
7765 sect2->filepos = sect->filepos;
7766 sect2->alignment_power = sect->alignment_power;
7767 return TRUE;
7770 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
7771 actually creates up to two pseudosections:
7772 - For the single-threaded case, a section named NAME, unless
7773 such a section already exists.
7774 - For the multi-threaded case, a section named "NAME/PID", where
7775 PID is elfcore_make_pid (abfd).
7776 Both pseudosections have identical contents. */
7777 bfd_boolean
7778 _bfd_elfcore_make_pseudosection (bfd *abfd,
7779 char *name,
7780 size_t size,
7781 ufile_ptr filepos)
7783 char buf[100];
7784 char *threaded_name;
7785 size_t len;
7786 asection *sect;
7788 /* Build the section name. */
7790 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
7791 len = strlen (buf) + 1;
7792 threaded_name = (char *) bfd_alloc (abfd, len);
7793 if (threaded_name == NULL)
7794 return FALSE;
7795 memcpy (threaded_name, buf, len);
7797 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7798 SEC_HAS_CONTENTS);
7799 if (sect == NULL)
7800 return FALSE;
7801 sect->size = size;
7802 sect->filepos = filepos;
7803 sect->alignment_power = 2;
7805 return elfcore_maybe_make_sect (abfd, name, sect);
7808 /* prstatus_t exists on:
7809 solaris 2.5+
7810 linux 2.[01] + glibc
7811 unixware 4.2
7814 #if defined (HAVE_PRSTATUS_T)
7816 static bfd_boolean
7817 elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
7819 size_t size;
7820 int offset;
7822 if (note->descsz == sizeof (prstatus_t))
7824 prstatus_t prstat;
7826 size = sizeof (prstat.pr_reg);
7827 offset = offsetof (prstatus_t, pr_reg);
7828 memcpy (&prstat, note->descdata, sizeof (prstat));
7830 /* Do not overwrite the core signal if it
7831 has already been set by another thread. */
7832 if (elf_tdata (abfd)->core_signal == 0)
7833 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7834 if (elf_tdata (abfd)->core_pid == 0)
7835 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7837 /* pr_who exists on:
7838 solaris 2.5+
7839 unixware 4.2
7840 pr_who doesn't exist on:
7841 linux 2.[01]
7843 #if defined (HAVE_PRSTATUS_T_PR_WHO)
7844 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7845 #else
7846 elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
7847 #endif
7849 #if defined (HAVE_PRSTATUS32_T)
7850 else if (note->descsz == sizeof (prstatus32_t))
7852 /* 64-bit host, 32-bit corefile */
7853 prstatus32_t prstat;
7855 size = sizeof (prstat.pr_reg);
7856 offset = offsetof (prstatus32_t, pr_reg);
7857 memcpy (&prstat, note->descdata, sizeof (prstat));
7859 /* Do not overwrite the core signal if it
7860 has already been set by another thread. */
7861 if (elf_tdata (abfd)->core_signal == 0)
7862 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
7863 if (elf_tdata (abfd)->core_pid == 0)
7864 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7866 /* pr_who exists on:
7867 solaris 2.5+
7868 unixware 4.2
7869 pr_who doesn't exist on:
7870 linux 2.[01]
7872 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
7873 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7874 #else
7875 elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
7876 #endif
7878 #endif /* HAVE_PRSTATUS32_T */
7879 else
7881 /* Fail - we don't know how to handle any other
7882 note size (ie. data object type). */
7883 return TRUE;
7886 /* Make a ".reg/999" section and a ".reg" section. */
7887 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
7888 size, note->descpos + offset);
7890 #endif /* defined (HAVE_PRSTATUS_T) */
7892 /* Create a pseudosection containing the exact contents of NOTE. */
7893 static bfd_boolean
7894 elfcore_make_note_pseudosection (bfd *abfd,
7895 char *name,
7896 Elf_Internal_Note *note)
7898 return _bfd_elfcore_make_pseudosection (abfd, name,
7899 note->descsz, note->descpos);
7902 /* There isn't a consistent prfpregset_t across platforms,
7903 but it doesn't matter, because we don't have to pick this
7904 data structure apart. */
7906 static bfd_boolean
7907 elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
7909 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7912 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7913 type of NT_PRXFPREG. Just include the whole note's contents
7914 literally. */
7916 static bfd_boolean
7917 elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
7919 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7922 /* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
7923 with a note type of NT_X86_XSTATE. Just include the whole note's
7924 contents literally. */
7926 static bfd_boolean
7927 elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
7929 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
7932 static bfd_boolean
7933 elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7935 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7938 static bfd_boolean
7939 elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7941 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7944 static bfd_boolean
7945 elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
7947 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
7950 static bfd_boolean
7951 elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
7953 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
7956 static bfd_boolean
7957 elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
7959 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
7962 static bfd_boolean
7963 elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
7965 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
7968 static bfd_boolean
7969 elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
7971 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
7974 static bfd_boolean
7975 elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
7977 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
7980 static bfd_boolean
7981 elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
7983 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
7986 static bfd_boolean
7987 elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
7989 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
7992 static bfd_boolean
7993 elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
7995 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
7998 #if defined (HAVE_PRPSINFO_T)
7999 typedef prpsinfo_t elfcore_psinfo_t;
8000 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
8001 typedef prpsinfo32_t elfcore_psinfo32_t;
8002 #endif
8003 #endif
8005 #if defined (HAVE_PSINFO_T)
8006 typedef psinfo_t elfcore_psinfo_t;
8007 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
8008 typedef psinfo32_t elfcore_psinfo32_t;
8009 #endif
8010 #endif
8012 /* return a malloc'ed copy of a string at START which is at
8013 most MAX bytes long, possibly without a terminating '\0'.
8014 the copy will always have a terminating '\0'. */
8016 char *
8017 _bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
8019 char *dups;
8020 char *end = (char *) memchr (start, '\0', max);
8021 size_t len;
8023 if (end == NULL)
8024 len = max;
8025 else
8026 len = end - start;
8028 dups = (char *) bfd_alloc (abfd, len + 1);
8029 if (dups == NULL)
8030 return NULL;
8032 memcpy (dups, start, len);
8033 dups[len] = '\0';
8035 return dups;
8038 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8039 static bfd_boolean
8040 elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
8042 if (note->descsz == sizeof (elfcore_psinfo_t))
8044 elfcore_psinfo_t psinfo;
8046 memcpy (&psinfo, note->descdata, sizeof (psinfo));
8048 #if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
8049 elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8050 #endif
8051 elf_tdata (abfd)->core_program
8052 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8053 sizeof (psinfo.pr_fname));
8055 elf_tdata (abfd)->core_command
8056 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8057 sizeof (psinfo.pr_psargs));
8059 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8060 else if (note->descsz == sizeof (elfcore_psinfo32_t))
8062 /* 64-bit host, 32-bit corefile */
8063 elfcore_psinfo32_t psinfo;
8065 memcpy (&psinfo, note->descdata, sizeof (psinfo));
8067 #if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
8068 elf_tdata (abfd)->core_pid = psinfo.pr_pid;
8069 #endif
8070 elf_tdata (abfd)->core_program
8071 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8072 sizeof (psinfo.pr_fname));
8074 elf_tdata (abfd)->core_command
8075 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8076 sizeof (psinfo.pr_psargs));
8078 #endif
8080 else
8082 /* Fail - we don't know how to handle any other
8083 note size (ie. data object type). */
8084 return TRUE;
8087 /* Note that for some reason, a spurious space is tacked
8088 onto the end of the args in some (at least one anyway)
8089 implementations, so strip it off if it exists. */
8092 char *command = elf_tdata (abfd)->core_command;
8093 int n = strlen (command);
8095 if (0 < n && command[n - 1] == ' ')
8096 command[n - 1] = '\0';
8099 return TRUE;
8101 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8103 #if defined (HAVE_PSTATUS_T)
8104 static bfd_boolean
8105 elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
8107 if (note->descsz == sizeof (pstatus_t)
8108 #if defined (HAVE_PXSTATUS_T)
8109 || note->descsz == sizeof (pxstatus_t)
8110 #endif
8113 pstatus_t pstat;
8115 memcpy (&pstat, note->descdata, sizeof (pstat));
8117 elf_tdata (abfd)->core_pid = pstat.pr_pid;
8119 #if defined (HAVE_PSTATUS32_T)
8120 else if (note->descsz == sizeof (pstatus32_t))
8122 /* 64-bit host, 32-bit corefile */
8123 pstatus32_t pstat;
8125 memcpy (&pstat, note->descdata, sizeof (pstat));
8127 elf_tdata (abfd)->core_pid = pstat.pr_pid;
8129 #endif
8130 /* Could grab some more details from the "representative"
8131 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
8132 NT_LWPSTATUS note, presumably. */
8134 return TRUE;
8136 #endif /* defined (HAVE_PSTATUS_T) */
8138 #if defined (HAVE_LWPSTATUS_T)
8139 static bfd_boolean
8140 elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
8142 lwpstatus_t lwpstat;
8143 char buf[100];
8144 char *name;
8145 size_t len;
8146 asection *sect;
8148 if (note->descsz != sizeof (lwpstat)
8149 #if defined (HAVE_LWPXSTATUS_T)
8150 && note->descsz != sizeof (lwpxstatus_t)
8151 #endif
8153 return TRUE;
8155 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
8157 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
8158 /* Do not overwrite the core signal if it has already been set by
8159 another thread. */
8160 if (elf_tdata (abfd)->core_signal == 0)
8161 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
8163 /* Make a ".reg/999" section. */
8165 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
8166 len = strlen (buf) + 1;
8167 name = bfd_alloc (abfd, len);
8168 if (name == NULL)
8169 return FALSE;
8170 memcpy (name, buf, len);
8172 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8173 if (sect == NULL)
8174 return FALSE;
8176 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8177 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
8178 sect->filepos = note->descpos
8179 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
8180 #endif
8182 #if defined (HAVE_LWPSTATUS_T_PR_REG)
8183 sect->size = sizeof (lwpstat.pr_reg);
8184 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
8185 #endif
8187 sect->alignment_power = 2;
8189 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
8190 return FALSE;
8192 /* Make a ".reg2/999" section */
8194 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
8195 len = strlen (buf) + 1;
8196 name = bfd_alloc (abfd, len);
8197 if (name == NULL)
8198 return FALSE;
8199 memcpy (name, buf, len);
8201 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8202 if (sect == NULL)
8203 return FALSE;
8205 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8206 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
8207 sect->filepos = note->descpos
8208 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
8209 #endif
8211 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
8212 sect->size = sizeof (lwpstat.pr_fpreg);
8213 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
8214 #endif
8216 sect->alignment_power = 2;
8218 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
8220 #endif /* defined (HAVE_LWPSTATUS_T) */
8222 static bfd_boolean
8223 elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
8225 char buf[30];
8226 char *name;
8227 size_t len;
8228 asection *sect;
8229 int type;
8230 int is_active_thread;
8231 bfd_vma base_addr;
8233 if (note->descsz < 728)
8234 return TRUE;
8236 if (! CONST_STRNEQ (note->namedata, "win32"))
8237 return TRUE;
8239 type = bfd_get_32 (abfd, note->descdata);
8241 switch (type)
8243 case 1 /* NOTE_INFO_PROCESS */:
8244 /* FIXME: need to add ->core_command. */
8245 /* process_info.pid */
8246 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
8247 /* process_info.signal */
8248 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
8249 break;
8251 case 2 /* NOTE_INFO_THREAD */:
8252 /* Make a ".reg/999" section. */
8253 /* thread_info.tid */
8254 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
8256 len = strlen (buf) + 1;
8257 name = (char *) bfd_alloc (abfd, len);
8258 if (name == NULL)
8259 return FALSE;
8261 memcpy (name, buf, len);
8263 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8264 if (sect == NULL)
8265 return FALSE;
8267 /* sizeof (thread_info.thread_context) */
8268 sect->size = 716;
8269 /* offsetof (thread_info.thread_context) */
8270 sect->filepos = note->descpos + 12;
8271 sect->alignment_power = 2;
8273 /* thread_info.is_active_thread */
8274 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8276 if (is_active_thread)
8277 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
8278 return FALSE;
8279 break;
8281 case 3 /* NOTE_INFO_MODULE */:
8282 /* Make a ".module/xxxxxxxx" section. */
8283 /* module_info.base_address */
8284 base_addr = bfd_get_32 (abfd, note->descdata + 4);
8285 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
8287 len = strlen (buf) + 1;
8288 name = (char *) bfd_alloc (abfd, len);
8289 if (name == NULL)
8290 return FALSE;
8292 memcpy (name, buf, len);
8294 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8296 if (sect == NULL)
8297 return FALSE;
8299 sect->size = note->descsz;
8300 sect->filepos = note->descpos;
8301 sect->alignment_power = 2;
8302 break;
8304 default:
8305 return TRUE;
8308 return TRUE;
8311 static bfd_boolean
8312 elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
8314 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8316 switch (note->type)
8318 default:
8319 return TRUE;
8321 case NT_PRSTATUS:
8322 if (bed->elf_backend_grok_prstatus)
8323 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
8324 return TRUE;
8325 #if defined (HAVE_PRSTATUS_T)
8326 return elfcore_grok_prstatus (abfd, note);
8327 #else
8328 return TRUE;
8329 #endif
8331 #if defined (HAVE_PSTATUS_T)
8332 case NT_PSTATUS:
8333 return elfcore_grok_pstatus (abfd, note);
8334 #endif
8336 #if defined (HAVE_LWPSTATUS_T)
8337 case NT_LWPSTATUS:
8338 return elfcore_grok_lwpstatus (abfd, note);
8339 #endif
8341 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
8342 return elfcore_grok_prfpreg (abfd, note);
8344 case NT_WIN32PSTATUS:
8345 return elfcore_grok_win32pstatus (abfd, note);
8347 case NT_PRXFPREG: /* Linux SSE extension */
8348 if (note->namesz == 6
8349 && strcmp (note->namedata, "LINUX") == 0)
8350 return elfcore_grok_prxfpreg (abfd, note);
8351 else
8352 return TRUE;
8354 case NT_X86_XSTATE: /* Linux XSAVE extension */
8355 if (note->namesz == 6
8356 && strcmp (note->namedata, "LINUX") == 0)
8357 return elfcore_grok_xstatereg (abfd, note);
8358 else
8359 return TRUE;
8361 case NT_PPC_VMX:
8362 if (note->namesz == 6
8363 && strcmp (note->namedata, "LINUX") == 0)
8364 return elfcore_grok_ppc_vmx (abfd, note);
8365 else
8366 return TRUE;
8368 case NT_PPC_VSX:
8369 if (note->namesz == 6
8370 && strcmp (note->namedata, "LINUX") == 0)
8371 return elfcore_grok_ppc_vsx (abfd, note);
8372 else
8373 return TRUE;
8375 case NT_S390_HIGH_GPRS:
8376 if (note->namesz == 6
8377 && strcmp (note->namedata, "LINUX") == 0)
8378 return elfcore_grok_s390_high_gprs (abfd, note);
8379 else
8380 return TRUE;
8382 case NT_S390_TIMER:
8383 if (note->namesz == 6
8384 && strcmp (note->namedata, "LINUX") == 0)
8385 return elfcore_grok_s390_timer (abfd, note);
8386 else
8387 return TRUE;
8389 case NT_S390_TODCMP:
8390 if (note->namesz == 6
8391 && strcmp (note->namedata, "LINUX") == 0)
8392 return elfcore_grok_s390_todcmp (abfd, note);
8393 else
8394 return TRUE;
8396 case NT_S390_TODPREG:
8397 if (note->namesz == 6
8398 && strcmp (note->namedata, "LINUX") == 0)
8399 return elfcore_grok_s390_todpreg (abfd, note);
8400 else
8401 return TRUE;
8403 case NT_S390_CTRS:
8404 if (note->namesz == 6
8405 && strcmp (note->namedata, "LINUX") == 0)
8406 return elfcore_grok_s390_ctrs (abfd, note);
8407 else
8408 return TRUE;
8410 case NT_S390_PREFIX:
8411 if (note->namesz == 6
8412 && strcmp (note->namedata, "LINUX") == 0)
8413 return elfcore_grok_s390_prefix (abfd, note);
8414 else
8415 return TRUE;
8417 case NT_S390_LAST_BREAK:
8418 if (note->namesz == 6
8419 && strcmp (note->namedata, "LINUX") == 0)
8420 return elfcore_grok_s390_last_break (abfd, note);
8421 else
8422 return TRUE;
8424 case NT_S390_SYSTEM_CALL:
8425 if (note->namesz == 6
8426 && strcmp (note->namedata, "LINUX") == 0)
8427 return elfcore_grok_s390_system_call (abfd, note);
8428 else
8429 return TRUE;
8431 case NT_ARM_VFP:
8432 if (note->namesz == 6
8433 && strcmp (note->namedata, "LINUX") == 0)
8434 return elfcore_grok_arm_vfp (abfd, note);
8435 else
8436 return TRUE;
8438 case NT_PRPSINFO:
8439 case NT_PSINFO:
8440 if (bed->elf_backend_grok_psinfo)
8441 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
8442 return TRUE;
8443 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8444 return elfcore_grok_psinfo (abfd, note);
8445 #else
8446 return TRUE;
8447 #endif
8449 case NT_AUXV:
8451 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8452 SEC_HAS_CONTENTS);
8454 if (sect == NULL)
8455 return FALSE;
8456 sect->size = note->descsz;
8457 sect->filepos = note->descpos;
8458 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8460 return TRUE;
8465 static bfd_boolean
8466 elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8468 elf_tdata (abfd)->build_id_size = note->descsz;
8469 elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz);
8470 if (elf_tdata (abfd)->build_id == NULL)
8471 return FALSE;
8473 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8475 return TRUE;
8478 static bfd_boolean
8479 elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8481 switch (note->type)
8483 default:
8484 return TRUE;
8486 case NT_GNU_BUILD_ID:
8487 return elfobj_grok_gnu_build_id (abfd, note);
8491 static bfd_boolean
8492 elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
8494 struct sdt_note *cur =
8495 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
8496 + note->descsz);
8498 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
8499 cur->size = (bfd_size_type) note->descsz;
8500 memcpy (cur->data, note->descdata, note->descsz);
8502 elf_tdata (abfd)->sdt_note_head = cur;
8504 return TRUE;
8507 static bfd_boolean
8508 elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
8510 switch (note->type)
8512 case NT_STAPSDT:
8513 return elfobj_grok_stapsdt_note_1 (abfd, note);
8515 default:
8516 return TRUE;
8520 static bfd_boolean
8521 elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
8523 char *cp;
8525 cp = strchr (note->namedata, '@');
8526 if (cp != NULL)
8528 *lwpidp = atoi(cp + 1);
8529 return TRUE;
8531 return FALSE;
8534 static bfd_boolean
8535 elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8537 /* Signal number at offset 0x08. */
8538 elf_tdata (abfd)->core_signal
8539 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8541 /* Process ID at offset 0x50. */
8542 elf_tdata (abfd)->core_pid
8543 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8545 /* Command name at 0x7c (max 32 bytes, including nul). */
8546 elf_tdata (abfd)->core_command
8547 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8549 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8550 note);
8553 static bfd_boolean
8554 elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
8556 int lwp;
8558 if (elfcore_netbsd_get_lwpid (note, &lwp))
8559 elf_tdata (abfd)->core_lwpid = lwp;
8561 if (note->type == NT_NETBSDCORE_PROCINFO)
8563 /* NetBSD-specific core "procinfo". Note that we expect to
8564 find this note before any of the others, which is fine,
8565 since the kernel writes this note out first when it
8566 creates a core file. */
8568 return elfcore_grok_netbsd_procinfo (abfd, note);
8571 /* As of Jan 2002 there are no other machine-independent notes
8572 defined for NetBSD core files. If the note type is less
8573 than the start of the machine-dependent note types, we don't
8574 understand it. */
8576 if (note->type < NT_NETBSDCORE_FIRSTMACH)
8577 return TRUE;
8580 switch (bfd_get_arch (abfd))
8582 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8583 PT_GETFPREGS == mach+2. */
8585 case bfd_arch_alpha:
8586 case bfd_arch_sparc:
8587 switch (note->type)
8589 case NT_NETBSDCORE_FIRSTMACH+0:
8590 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8592 case NT_NETBSDCORE_FIRSTMACH+2:
8593 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8595 default:
8596 return TRUE;
8599 /* On all other arch's, PT_GETREGS == mach+1 and
8600 PT_GETFPREGS == mach+3. */
8602 default:
8603 switch (note->type)
8605 case NT_NETBSDCORE_FIRSTMACH+1:
8606 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8608 case NT_NETBSDCORE_FIRSTMACH+3:
8609 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8611 default:
8612 return TRUE;
8615 /* NOTREACHED */
8618 static bfd_boolean
8619 elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8621 /* Signal number at offset 0x08. */
8622 elf_tdata (abfd)->core_signal
8623 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8625 /* Process ID at offset 0x20. */
8626 elf_tdata (abfd)->core_pid
8627 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8629 /* Command name at 0x48 (max 32 bytes, including nul). */
8630 elf_tdata (abfd)->core_command
8631 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8633 return TRUE;
8636 static bfd_boolean
8637 elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8639 if (note->type == NT_OPENBSD_PROCINFO)
8640 return elfcore_grok_openbsd_procinfo (abfd, note);
8642 if (note->type == NT_OPENBSD_REGS)
8643 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8645 if (note->type == NT_OPENBSD_FPREGS)
8646 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8648 if (note->type == NT_OPENBSD_XFPREGS)
8649 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8651 if (note->type == NT_OPENBSD_AUXV)
8653 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8654 SEC_HAS_CONTENTS);
8656 if (sect == NULL)
8657 return FALSE;
8658 sect->size = note->descsz;
8659 sect->filepos = note->descpos;
8660 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8662 return TRUE;
8665 if (note->type == NT_OPENBSD_WCOOKIE)
8667 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8668 SEC_HAS_CONTENTS);
8670 if (sect == NULL)
8671 return FALSE;
8672 sect->size = note->descsz;
8673 sect->filepos = note->descpos;
8674 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8676 return TRUE;
8679 return TRUE;
8682 static bfd_boolean
8683 elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
8685 void *ddata = note->descdata;
8686 char buf[100];
8687 char *name;
8688 asection *sect;
8689 short sig;
8690 unsigned flags;
8692 /* nto_procfs_status 'pid' field is at offset 0. */
8693 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8695 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8696 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8698 /* nto_procfs_status 'flags' field is at offset 8. */
8699 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
8701 /* nto_procfs_status 'what' field is at offset 14. */
8702 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8704 elf_tdata (abfd)->core_signal = sig;
8705 elf_tdata (abfd)->core_lwpid = *tid;
8708 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8709 do not come from signals so we make sure we set the current
8710 thread just in case. */
8711 if (flags & 0x00000080)
8712 elf_tdata (abfd)->core_lwpid = *tid;
8714 /* Make a ".qnx_core_status/%d" section. */
8715 sprintf (buf, ".qnx_core_status/%ld", *tid);
8717 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8718 if (name == NULL)
8719 return FALSE;
8720 strcpy (name, buf);
8722 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8723 if (sect == NULL)
8724 return FALSE;
8726 sect->size = note->descsz;
8727 sect->filepos = note->descpos;
8728 sect->alignment_power = 2;
8730 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8733 static bfd_boolean
8734 elfcore_grok_nto_regs (bfd *abfd,
8735 Elf_Internal_Note *note,
8736 long tid,
8737 char *base)
8739 char buf[100];
8740 char *name;
8741 asection *sect;
8743 /* Make a "(base)/%d" section. */
8744 sprintf (buf, "%s/%ld", base, tid);
8746 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
8747 if (name == NULL)
8748 return FALSE;
8749 strcpy (name, buf);
8751 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8752 if (sect == NULL)
8753 return FALSE;
8755 sect->size = note->descsz;
8756 sect->filepos = note->descpos;
8757 sect->alignment_power = 2;
8759 /* This is the current thread. */
8760 if (elf_tdata (abfd)->core_lwpid == tid)
8761 return elfcore_maybe_make_sect (abfd, base, sect);
8763 return TRUE;
8766 #define BFD_QNT_CORE_INFO 7
8767 #define BFD_QNT_CORE_STATUS 8
8768 #define BFD_QNT_CORE_GREG 9
8769 #define BFD_QNT_CORE_FPREG 10
8771 static bfd_boolean
8772 elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
8774 /* Every GREG section has a STATUS section before it. Store the
8775 tid from the previous call to pass down to the next gregs
8776 function. */
8777 static long tid = 1;
8779 switch (note->type)
8781 case BFD_QNT_CORE_INFO:
8782 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8783 case BFD_QNT_CORE_STATUS:
8784 return elfcore_grok_nto_status (abfd, note, &tid);
8785 case BFD_QNT_CORE_GREG:
8786 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8787 case BFD_QNT_CORE_FPREG:
8788 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8789 default:
8790 return TRUE;
8794 static bfd_boolean
8795 elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8797 char *name;
8798 asection *sect;
8799 size_t len;
8801 /* Use note name as section name. */
8802 len = note->namesz;
8803 name = (char *) bfd_alloc (abfd, len);
8804 if (name == NULL)
8805 return FALSE;
8806 memcpy (name, note->namedata, len);
8807 name[len - 1] = '\0';
8809 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8810 if (sect == NULL)
8811 return FALSE;
8813 sect->size = note->descsz;
8814 sect->filepos = note->descpos;
8815 sect->alignment_power = 1;
8817 return TRUE;
8820 /* Function: elfcore_write_note
8822 Inputs:
8823 buffer to hold note, and current size of buffer
8824 name of note
8825 type of note
8826 data for note
8827 size of data for note
8829 Writes note to end of buffer. ELF64 notes are written exactly as
8830 for ELF32, despite the current (as of 2006) ELF gabi specifying
8831 that they ought to have 8-byte namesz and descsz field, and have
8832 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8834 Return:
8835 Pointer to realloc'd buffer, *BUFSIZ updated. */
8837 char *
8838 elfcore_write_note (bfd *abfd,
8839 char *buf,
8840 int *bufsiz,
8841 const char *name,
8842 int type,
8843 const void *input,
8844 int size)
8846 Elf_External_Note *xnp;
8847 size_t namesz;
8848 size_t newspace;
8849 char *dest;
8851 namesz = 0;
8852 if (name != NULL)
8853 namesz = strlen (name) + 1;
8855 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
8857 buf = (char *) realloc (buf, *bufsiz + newspace);
8858 if (buf == NULL)
8859 return buf;
8860 dest = buf + *bufsiz;
8861 *bufsiz += newspace;
8862 xnp = (Elf_External_Note *) dest;
8863 H_PUT_32 (abfd, namesz, xnp->namesz);
8864 H_PUT_32 (abfd, size, xnp->descsz);
8865 H_PUT_32 (abfd, type, xnp->type);
8866 dest = xnp->name;
8867 if (name != NULL)
8869 memcpy (dest, name, namesz);
8870 dest += namesz;
8871 while (namesz & 3)
8873 *dest++ = '\0';
8874 ++namesz;
8877 memcpy (dest, input, size);
8878 dest += size;
8879 while (size & 3)
8881 *dest++ = '\0';
8882 ++size;
8884 return buf;
8887 char *
8888 elfcore_write_prpsinfo (bfd *abfd,
8889 char *buf,
8890 int *bufsiz,
8891 const char *fname,
8892 const char *psargs)
8894 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8896 if (bed->elf_backend_write_core_note != NULL)
8898 char *ret;
8899 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8900 NT_PRPSINFO, fname, psargs);
8901 if (ret != NULL)
8902 return ret;
8905 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8906 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8907 if (bed->s->elfclass == ELFCLASS32)
8909 #if defined (HAVE_PSINFO32_T)
8910 psinfo32_t data;
8911 int note_type = NT_PSINFO;
8912 #else
8913 prpsinfo32_t data;
8914 int note_type = NT_PRPSINFO;
8915 #endif
8917 memset (&data, 0, sizeof (data));
8918 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8919 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8920 return elfcore_write_note (abfd, buf, bufsiz,
8921 "CORE", note_type, &data, sizeof (data));
8923 else
8924 #endif
8926 #if defined (HAVE_PSINFO_T)
8927 psinfo_t data;
8928 int note_type = NT_PSINFO;
8929 #else
8930 prpsinfo_t data;
8931 int note_type = NT_PRPSINFO;
8932 #endif
8934 memset (&data, 0, sizeof (data));
8935 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8936 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8937 return elfcore_write_note (abfd, buf, bufsiz,
8938 "CORE", note_type, &data, sizeof (data));
8940 #endif /* PSINFO_T or PRPSINFO_T */
8942 free (buf);
8943 return NULL;
8946 char *
8947 elfcore_write_prstatus (bfd *abfd,
8948 char *buf,
8949 int *bufsiz,
8950 long pid,
8951 int cursig,
8952 const void *gregs)
8954 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8956 if (bed->elf_backend_write_core_note != NULL)
8958 char *ret;
8959 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8960 NT_PRSTATUS,
8961 pid, cursig, gregs);
8962 if (ret != NULL)
8963 return ret;
8966 #if defined (HAVE_PRSTATUS_T)
8967 #if defined (HAVE_PRSTATUS32_T)
8968 if (bed->s->elfclass == ELFCLASS32)
8970 prstatus32_t prstat;
8972 memset (&prstat, 0, sizeof (prstat));
8973 prstat.pr_pid = pid;
8974 prstat.pr_cursig = cursig;
8975 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8976 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
8977 NT_PRSTATUS, &prstat, sizeof (prstat));
8979 else
8980 #endif
8982 prstatus_t prstat;
8984 memset (&prstat, 0, sizeof (prstat));
8985 prstat.pr_pid = pid;
8986 prstat.pr_cursig = cursig;
8987 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8988 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
8989 NT_PRSTATUS, &prstat, sizeof (prstat));
8991 #endif /* HAVE_PRSTATUS_T */
8993 free (buf);
8994 return NULL;
8997 #if defined (HAVE_LWPSTATUS_T)
8998 char *
8999 elfcore_write_lwpstatus (bfd *abfd,
9000 char *buf,
9001 int *bufsiz,
9002 long pid,
9003 int cursig,
9004 const void *gregs)
9006 lwpstatus_t lwpstat;
9007 const char *note_name = "CORE";
9009 memset (&lwpstat, 0, sizeof (lwpstat));
9010 lwpstat.pr_lwpid = pid >> 16;
9011 lwpstat.pr_cursig = cursig;
9012 #if defined (HAVE_LWPSTATUS_T_PR_REG)
9013 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
9014 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9015 #if !defined(gregs)
9016 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
9017 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
9018 #else
9019 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
9020 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
9021 #endif
9022 #endif
9023 return elfcore_write_note (abfd, buf, bufsiz, note_name,
9024 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
9026 #endif /* HAVE_LWPSTATUS_T */
9028 #if defined (HAVE_PSTATUS_T)
9029 char *
9030 elfcore_write_pstatus (bfd *abfd,
9031 char *buf,
9032 int *bufsiz,
9033 long pid,
9034 int cursig ATTRIBUTE_UNUSED,
9035 const void *gregs ATTRIBUTE_UNUSED)
9037 const char *note_name = "CORE";
9038 #if defined (HAVE_PSTATUS32_T)
9039 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9041 if (bed->s->elfclass == ELFCLASS32)
9043 pstatus32_t pstat;
9045 memset (&pstat, 0, sizeof (pstat));
9046 pstat.pr_pid = pid & 0xffff;
9047 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9048 NT_PSTATUS, &pstat, sizeof (pstat));
9049 return buf;
9051 else
9052 #endif
9054 pstatus_t pstat;
9056 memset (&pstat, 0, sizeof (pstat));
9057 pstat.pr_pid = pid & 0xffff;
9058 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9059 NT_PSTATUS, &pstat, sizeof (pstat));
9060 return buf;
9063 #endif /* HAVE_PSTATUS_T */
9065 char *
9066 elfcore_write_prfpreg (bfd *abfd,
9067 char *buf,
9068 int *bufsiz,
9069 const void *fpregs,
9070 int size)
9072 const char *note_name = "CORE";
9073 return elfcore_write_note (abfd, buf, bufsiz,
9074 note_name, NT_FPREGSET, fpregs, size);
9077 char *
9078 elfcore_write_prxfpreg (bfd *abfd,
9079 char *buf,
9080 int *bufsiz,
9081 const void *xfpregs,
9082 int size)
9084 char *note_name = "LINUX";
9085 return elfcore_write_note (abfd, buf, bufsiz,
9086 note_name, NT_PRXFPREG, xfpregs, size);
9089 char *
9090 elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
9091 const void *xfpregs, int size)
9093 char *note_name = "LINUX";
9094 return elfcore_write_note (abfd, buf, bufsiz,
9095 note_name, NT_X86_XSTATE, xfpregs, size);
9098 char *
9099 elfcore_write_ppc_vmx (bfd *abfd,
9100 char *buf,
9101 int *bufsiz,
9102 const void *ppc_vmx,
9103 int size)
9105 char *note_name = "LINUX";
9106 return elfcore_write_note (abfd, buf, bufsiz,
9107 note_name, NT_PPC_VMX, ppc_vmx, size);
9110 char *
9111 elfcore_write_ppc_vsx (bfd *abfd,
9112 char *buf,
9113 int *bufsiz,
9114 const void *ppc_vsx,
9115 int size)
9117 char *note_name = "LINUX";
9118 return elfcore_write_note (abfd, buf, bufsiz,
9119 note_name, NT_PPC_VSX, ppc_vsx, size);
9122 static char *
9123 elfcore_write_s390_high_gprs (bfd *abfd,
9124 char *buf,
9125 int *bufsiz,
9126 const void *s390_high_gprs,
9127 int size)
9129 char *note_name = "LINUX";
9130 return elfcore_write_note (abfd, buf, bufsiz,
9131 note_name, NT_S390_HIGH_GPRS,
9132 s390_high_gprs, size);
9135 char *
9136 elfcore_write_s390_timer (bfd *abfd,
9137 char *buf,
9138 int *bufsiz,
9139 const void *s390_timer,
9140 int size)
9142 char *note_name = "LINUX";
9143 return elfcore_write_note (abfd, buf, bufsiz,
9144 note_name, NT_S390_TIMER, s390_timer, size);
9147 char *
9148 elfcore_write_s390_todcmp (bfd *abfd,
9149 char *buf,
9150 int *bufsiz,
9151 const void *s390_todcmp,
9152 int size)
9154 char *note_name = "LINUX";
9155 return elfcore_write_note (abfd, buf, bufsiz,
9156 note_name, NT_S390_TODCMP, s390_todcmp, size);
9159 char *
9160 elfcore_write_s390_todpreg (bfd *abfd,
9161 char *buf,
9162 int *bufsiz,
9163 const void *s390_todpreg,
9164 int size)
9166 char *note_name = "LINUX";
9167 return elfcore_write_note (abfd, buf, bufsiz,
9168 note_name, NT_S390_TODPREG, s390_todpreg, size);
9171 char *
9172 elfcore_write_s390_ctrs (bfd *abfd,
9173 char *buf,
9174 int *bufsiz,
9175 const void *s390_ctrs,
9176 int size)
9178 char *note_name = "LINUX";
9179 return elfcore_write_note (abfd, buf, bufsiz,
9180 note_name, NT_S390_CTRS, s390_ctrs, size);
9183 char *
9184 elfcore_write_s390_prefix (bfd *abfd,
9185 char *buf,
9186 int *bufsiz,
9187 const void *s390_prefix,
9188 int size)
9190 char *note_name = "LINUX";
9191 return elfcore_write_note (abfd, buf, bufsiz,
9192 note_name, NT_S390_PREFIX, s390_prefix, size);
9195 char *
9196 elfcore_write_s390_last_break (bfd *abfd,
9197 char *buf,
9198 int *bufsiz,
9199 const void *s390_last_break,
9200 int size)
9202 char *note_name = "LINUX";
9203 return elfcore_write_note (abfd, buf, bufsiz,
9204 note_name, NT_S390_LAST_BREAK,
9205 s390_last_break, size);
9208 char *
9209 elfcore_write_s390_system_call (bfd *abfd,
9210 char *buf,
9211 int *bufsiz,
9212 const void *s390_system_call,
9213 int size)
9215 char *note_name = "LINUX";
9216 return elfcore_write_note (abfd, buf, bufsiz,
9217 note_name, NT_S390_SYSTEM_CALL,
9218 s390_system_call, size);
9221 char *
9222 elfcore_write_arm_vfp (bfd *abfd,
9223 char *buf,
9224 int *bufsiz,
9225 const void *arm_vfp,
9226 int size)
9228 char *note_name = "LINUX";
9229 return elfcore_write_note (abfd, buf, bufsiz,
9230 note_name, NT_ARM_VFP, arm_vfp, size);
9233 char *
9234 elfcore_write_register_note (bfd *abfd,
9235 char *buf,
9236 int *bufsiz,
9237 const char *section,
9238 const void *data,
9239 int size)
9241 if (strcmp (section, ".reg2") == 0)
9242 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
9243 if (strcmp (section, ".reg-xfp") == 0)
9244 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
9245 if (strcmp (section, ".reg-xstate") == 0)
9246 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
9247 if (strcmp (section, ".reg-ppc-vmx") == 0)
9248 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
9249 if (strcmp (section, ".reg-ppc-vsx") == 0)
9250 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
9251 if (strcmp (section, ".reg-s390-high-gprs") == 0)
9252 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
9253 if (strcmp (section, ".reg-s390-timer") == 0)
9254 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
9255 if (strcmp (section, ".reg-s390-todcmp") == 0)
9256 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
9257 if (strcmp (section, ".reg-s390-todpreg") == 0)
9258 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
9259 if (strcmp (section, ".reg-s390-ctrs") == 0)
9260 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
9261 if (strcmp (section, ".reg-s390-prefix") == 0)
9262 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
9263 if (strcmp (section, ".reg-s390-last-break") == 0)
9264 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
9265 if (strcmp (section, ".reg-s390-system-call") == 0)
9266 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
9267 if (strcmp (section, ".reg-arm-vfp") == 0)
9268 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
9269 return NULL;
9272 static bfd_boolean
9273 elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
9275 char *p;
9277 p = buf;
9278 while (p < buf + size)
9280 /* FIXME: bad alignment assumption. */
9281 Elf_External_Note *xnp = (Elf_External_Note *) p;
9282 Elf_Internal_Note in;
9284 if (offsetof (Elf_External_Note, name) > buf - p + size)
9285 return FALSE;
9287 in.type = H_GET_32 (abfd, xnp->type);
9289 in.namesz = H_GET_32 (abfd, xnp->namesz);
9290 in.namedata = xnp->name;
9291 if (in.namesz > buf - in.namedata + size)
9292 return FALSE;
9294 in.descsz = H_GET_32 (abfd, xnp->descsz);
9295 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
9296 in.descpos = offset + (in.descdata - buf);
9297 if (in.descsz != 0
9298 && (in.descdata >= buf + size
9299 || in.descsz > buf - in.descdata + size))
9300 return FALSE;
9302 switch (bfd_get_format (abfd))
9304 default:
9305 return TRUE;
9307 case bfd_core:
9308 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
9310 if (! elfcore_grok_netbsd_note (abfd, &in))
9311 return FALSE;
9313 else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
9315 if (! elfcore_grok_openbsd_note (abfd, &in))
9316 return FALSE;
9318 else if (CONST_STRNEQ (in.namedata, "QNX"))
9320 if (! elfcore_grok_nto_note (abfd, &in))
9321 return FALSE;
9323 else if (CONST_STRNEQ (in.namedata, "SPU/"))
9325 if (! elfcore_grok_spu_note (abfd, &in))
9326 return FALSE;
9328 else
9330 if (! elfcore_grok_note (abfd, &in))
9331 return FALSE;
9333 break;
9335 case bfd_object:
9336 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
9338 if (! elfobj_grok_gnu_note (abfd, &in))
9339 return FALSE;
9341 else if (in.namesz == sizeof "stapsdt"
9342 && strcmp (in.namedata, "stapsdt") == 0)
9344 if (! elfobj_grok_stapsdt_note (abfd, &in))
9345 return FALSE;
9347 break;
9350 p = in.descdata + BFD_ALIGN (in.descsz, 4);
9353 return TRUE;
9356 static bfd_boolean
9357 elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9359 char *buf;
9361 if (size <= 0)
9362 return TRUE;
9364 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9365 return FALSE;
9367 buf = (char *) bfd_malloc (size);
9368 if (buf == NULL)
9369 return FALSE;
9371 if (bfd_bread (buf, size, abfd) != size
9372 || !elf_parse_notes (abfd, buf, size, offset))
9374 free (buf);
9375 return FALSE;
9378 free (buf);
9379 return TRUE;
9382 /* Providing external access to the ELF program header table. */
9384 /* Return an upper bound on the number of bytes required to store a
9385 copy of ABFD's program header table entries. Return -1 if an error
9386 occurs; bfd_get_error will return an appropriate code. */
9388 long
9389 bfd_get_elf_phdr_upper_bound (bfd *abfd)
9391 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9393 bfd_set_error (bfd_error_wrong_format);
9394 return -1;
9397 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
9400 /* Copy ABFD's program header table entries to *PHDRS. The entries
9401 will be stored as an array of Elf_Internal_Phdr structures, as
9402 defined in include/elf/internal.h. To find out how large the
9403 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9405 Return the number of program header table entries read, or -1 if an
9406 error occurs; bfd_get_error will return an appropriate code. */
9409 bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
9411 int num_phdrs;
9413 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9415 bfd_set_error (bfd_error_wrong_format);
9416 return -1;
9419 num_phdrs = elf_elfheader (abfd)->e_phnum;
9420 memcpy (phdrs, elf_tdata (abfd)->phdr,
9421 num_phdrs * sizeof (Elf_Internal_Phdr));
9423 return num_phdrs;
9426 enum elf_reloc_type_class
9427 _bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
9429 return reloc_class_normal;
9432 /* For RELA architectures, return the relocation value for a
9433 relocation against a local symbol. */
9435 bfd_vma
9436 _bfd_elf_rela_local_sym (bfd *abfd,
9437 Elf_Internal_Sym *sym,
9438 asection **psec,
9439 Elf_Internal_Rela *rel)
9441 asection *sec = *psec;
9442 bfd_vma relocation;
9444 relocation = (sec->output_section->vma
9445 + sec->output_offset
9446 + sym->st_value);
9447 if ((sec->flags & SEC_MERGE)
9448 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
9449 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
9451 rel->r_addend =
9452 _bfd_merged_section_offset (abfd, psec,
9453 elf_section_data (sec)->sec_info,
9454 sym->st_value + rel->r_addend);
9455 if (sec != *psec)
9457 /* If we have changed the section, and our original section is
9458 marked with SEC_EXCLUDE, it means that the original
9459 SEC_MERGE section has been completely subsumed in some
9460 other SEC_MERGE section. In this case, we need to leave
9461 some info around for --emit-relocs. */
9462 if ((sec->flags & SEC_EXCLUDE) != 0)
9463 sec->kept_section = *psec;
9464 sec = *psec;
9466 rel->r_addend -= relocation;
9467 rel->r_addend += sec->output_section->vma + sec->output_offset;
9469 return relocation;
9472 bfd_vma
9473 _bfd_elf_rel_local_sym (bfd *abfd,
9474 Elf_Internal_Sym *sym,
9475 asection **psec,
9476 bfd_vma addend)
9478 asection *sec = *psec;
9480 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
9481 return sym->st_value + addend;
9483 return _bfd_merged_section_offset (abfd, psec,
9484 elf_section_data (sec)->sec_info,
9485 sym->st_value + addend);
9488 bfd_vma
9489 _bfd_elf_section_offset (bfd *abfd,
9490 struct bfd_link_info *info,
9491 asection *sec,
9492 bfd_vma offset)
9494 switch (sec->sec_info_type)
9496 case ELF_INFO_TYPE_STABS:
9497 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9498 offset);
9499 case ELF_INFO_TYPE_EH_FRAME:
9500 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
9501 default:
9502 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
9504 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9505 bfd_size_type address_size = bed->s->arch_size / 8;
9506 offset = sec->size - offset - address_size;
9508 return offset;
9512 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
9513 reconstruct an ELF file by reading the segments out of remote memory
9514 based on the ELF file header at EHDR_VMA and the ELF program headers it
9515 points to. If not null, *LOADBASEP is filled in with the difference
9516 between the VMAs from which the segments were read, and the VMAs the
9517 file headers (and hence BFD's idea of each section's VMA) put them at.
9519 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9520 remote memory at target address VMA into the local buffer at MYADDR; it
9521 should return zero on success or an `errno' code on failure. TEMPL must
9522 be a BFD for an ELF target with the word size and byte order found in
9523 the remote memory. */
9525 bfd *
9526 bfd_elf_bfd_from_remote_memory
9527 (bfd *templ,
9528 bfd_vma ehdr_vma,
9529 bfd_vma *loadbasep,
9530 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
9532 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9533 (templ, ehdr_vma, loadbasep, target_read_memory);
9536 long
9537 _bfd_elf_get_synthetic_symtab (bfd *abfd,
9538 long symcount ATTRIBUTE_UNUSED,
9539 asymbol **syms ATTRIBUTE_UNUSED,
9540 long dynsymcount,
9541 asymbol **dynsyms,
9542 asymbol **ret)
9544 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9545 asection *relplt;
9546 asymbol *s;
9547 const char *relplt_name;
9548 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9549 arelent *p;
9550 long count, i, n;
9551 size_t size;
9552 Elf_Internal_Shdr *hdr;
9553 char *names;
9554 asection *plt;
9556 *ret = NULL;
9558 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9559 return 0;
9561 if (dynsymcount <= 0)
9562 return 0;
9564 if (!bed->plt_sym_val)
9565 return 0;
9567 relplt_name = bed->relplt_name;
9568 if (relplt_name == NULL)
9569 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
9570 relplt = bfd_get_section_by_name (abfd, relplt_name);
9571 if (relplt == NULL)
9572 return 0;
9574 hdr = &elf_section_data (relplt)->this_hdr;
9575 if (hdr->sh_link != elf_dynsymtab (abfd)
9576 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9577 return 0;
9579 plt = bfd_get_section_by_name (abfd, ".plt");
9580 if (plt == NULL)
9581 return 0;
9583 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
9584 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
9585 return -1;
9587 count = relplt->size / hdr->sh_entsize;
9588 size = count * sizeof (asymbol);
9589 p = relplt->relocation;
9590 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9592 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9593 if (p->addend != 0)
9595 #ifdef BFD64
9596 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9597 #else
9598 size += sizeof ("+0x") - 1 + 8;
9599 #endif
9603 s = *ret = (asymbol *) bfd_malloc (size);
9604 if (s == NULL)
9605 return -1;
9607 names = (char *) (s + count);
9608 p = relplt->relocation;
9609 n = 0;
9610 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
9612 size_t len;
9613 bfd_vma addr;
9615 addr = bed->plt_sym_val (i, plt, p);
9616 if (addr == (bfd_vma) -1)
9617 continue;
9619 *s = **p->sym_ptr_ptr;
9620 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
9621 we are defining a symbol, ensure one of them is set. */
9622 if ((s->flags & BSF_LOCAL) == 0)
9623 s->flags |= BSF_GLOBAL;
9624 s->flags |= BSF_SYNTHETIC;
9625 s->section = plt;
9626 s->value = addr - plt->vma;
9627 s->name = names;
9628 s->udata.p = NULL;
9629 len = strlen ((*p->sym_ptr_ptr)->name);
9630 memcpy (names, (*p->sym_ptr_ptr)->name, len);
9631 names += len;
9632 if (p->addend != 0)
9634 char buf[30], *a;
9636 memcpy (names, "+0x", sizeof ("+0x") - 1);
9637 names += sizeof ("+0x") - 1;
9638 bfd_sprintf_vma (abfd, buf, p->addend);
9639 for (a = buf; *a == '0'; ++a)
9641 len = strlen (a);
9642 memcpy (names, a, len);
9643 names += len;
9645 memcpy (names, "@plt", sizeof ("@plt"));
9646 names += sizeof ("@plt");
9647 ++s, ++n;
9650 return n;
9653 /* It is only used by x86-64 so far. */
9654 asection _bfd_elf_large_com_section
9655 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
9656 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
9658 void
9659 _bfd_elf_set_osabi (bfd * abfd,
9660 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9662 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
9664 i_ehdrp = elf_elfheader (abfd);
9666 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
9668 /* To make things simpler for the loader on Linux systems we set the
9669 osabi field to ELFOSABI_GNU if the binary contains symbols of
9670 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
9671 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
9672 && elf_tdata (abfd)->has_gnu_symbols)
9673 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
9677 /* Return TRUE for ELF symbol types that represent functions.
9678 This is the default version of this function, which is sufficient for
9679 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
9681 bfd_boolean
9682 _bfd_elf_is_function_type (unsigned int type)
9684 return (type == STT_FUNC
9685 || type == STT_GNU_IFUNC);
9688 /* Return TRUE iff the ELF symbol SYM might be a function. Set *CODE_SEC
9689 and *CODE_OFF to the function's entry point. */
9691 bfd_boolean
9692 _bfd_elf_maybe_function_sym (const asymbol *sym,
9693 asection **code_sec, bfd_vma *code_off)
9695 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
9696 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
9697 return FALSE;
9699 *code_sec = sym->section;
9700 *code_off = sym->value;
9701 return TRUE;