* Makefile.am: Run "make dep-am".
[binutils.git] / bfd / elf.c
blobc1e2d118071e25c92919e180b627a680b7d249d6
1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* SECTION
23 ELF backends
25 BFD support for ELF formats is being worked on.
26 Currently, the best supported back ends are for sparc and i386
27 (running svr4 or Solaris 2).
29 Documentation of the internals of the support code still needs
30 to be written. The code is changing quickly enough that we
31 haven't bothered yet. */
33 /* For sparc64-cross-sparc32. */
34 #define _SYSCALL32
35 #include "bfd.h"
36 #include "sysdep.h"
37 #include "bfdlink.h"
38 #include "libbfd.h"
39 #define ARCH_SIZE 0
40 #include "elf-bfd.h"
41 #include "libiberty.h"
43 static INLINE struct elf_segment_map *make_mapping
44 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
45 static boolean map_sections_to_segments PARAMS ((bfd *));
46 static int elf_sort_sections PARAMS ((const PTR, const PTR));
47 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
48 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
49 static boolean prep_headers PARAMS ((bfd *));
50 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
51 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
52 static char *elf_read PARAMS ((bfd *, file_ptr, bfd_size_type));
53 static const char *group_signature PARAMS ((bfd *, Elf_Internal_Shdr *));
54 static boolean setup_group PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
55 static void merge_sections_remove_hook PARAMS ((bfd *, asection *));
56 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
57 static boolean assign_section_numbers PARAMS ((bfd *));
58 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
59 static boolean elf_map_symbols PARAMS ((bfd *));
60 static bfd_size_type get_program_header_size PARAMS ((bfd *));
61 static boolean elfcore_read_notes PARAMS ((bfd *, file_ptr, bfd_size_type));
62 static boolean elf_find_function PARAMS ((bfd *, asection *, asymbol **,
63 bfd_vma, const char **,
64 const char **));
65 static int elfcore_make_pid PARAMS ((bfd *));
66 static boolean elfcore_maybe_make_sect PARAMS ((bfd *, char *, asection *));
67 static boolean elfcore_make_note_pseudosection PARAMS ((bfd *, char *,
68 Elf_Internal_Note *));
69 static boolean elfcore_grok_prfpreg PARAMS ((bfd *, Elf_Internal_Note *));
70 static boolean elfcore_grok_prxfpreg PARAMS ((bfd *, Elf_Internal_Note *));
71 static boolean elfcore_grok_note PARAMS ((bfd *, Elf_Internal_Note *));
73 static boolean elfcore_netbsd_get_lwpid PARAMS ((Elf_Internal_Note *, int *));
74 static boolean elfcore_grok_netbsd_procinfo PARAMS ((bfd *,
75 Elf_Internal_Note *));
76 static boolean elfcore_grok_netbsd_note PARAMS ((bfd *, Elf_Internal_Note *));
78 /* Swap version information in and out. The version information is
79 currently size independent. If that ever changes, this code will
80 need to move into elfcode.h. */
82 /* Swap in a Verdef structure. */
84 void
85 _bfd_elf_swap_verdef_in (abfd, src, dst)
86 bfd *abfd;
87 const Elf_External_Verdef *src;
88 Elf_Internal_Verdef *dst;
90 dst->vd_version = H_GET_16 (abfd, src->vd_version);
91 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
92 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
93 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
94 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
95 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
96 dst->vd_next = H_GET_32 (abfd, src->vd_next);
99 /* Swap out a Verdef structure. */
101 void
102 _bfd_elf_swap_verdef_out (abfd, src, dst)
103 bfd *abfd;
104 const Elf_Internal_Verdef *src;
105 Elf_External_Verdef *dst;
107 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
108 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
109 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
110 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
111 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
112 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
113 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
116 /* Swap in a Verdaux structure. */
118 void
119 _bfd_elf_swap_verdaux_in (abfd, src, dst)
120 bfd *abfd;
121 const Elf_External_Verdaux *src;
122 Elf_Internal_Verdaux *dst;
124 dst->vda_name = H_GET_32 (abfd, src->vda_name);
125 dst->vda_next = H_GET_32 (abfd, src->vda_next);
128 /* Swap out a Verdaux structure. */
130 void
131 _bfd_elf_swap_verdaux_out (abfd, src, dst)
132 bfd *abfd;
133 const Elf_Internal_Verdaux *src;
134 Elf_External_Verdaux *dst;
136 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
137 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
140 /* Swap in a Verneed structure. */
142 void
143 _bfd_elf_swap_verneed_in (abfd, src, dst)
144 bfd *abfd;
145 const Elf_External_Verneed *src;
146 Elf_Internal_Verneed *dst;
148 dst->vn_version = H_GET_16 (abfd, src->vn_version);
149 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
150 dst->vn_file = H_GET_32 (abfd, src->vn_file);
151 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
152 dst->vn_next = H_GET_32 (abfd, src->vn_next);
155 /* Swap out a Verneed structure. */
157 void
158 _bfd_elf_swap_verneed_out (abfd, src, dst)
159 bfd *abfd;
160 const Elf_Internal_Verneed *src;
161 Elf_External_Verneed *dst;
163 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
164 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
165 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
166 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
167 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
170 /* Swap in a Vernaux structure. */
172 void
173 _bfd_elf_swap_vernaux_in (abfd, src, dst)
174 bfd *abfd;
175 const Elf_External_Vernaux *src;
176 Elf_Internal_Vernaux *dst;
178 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
179 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
180 dst->vna_other = H_GET_16 (abfd, src->vna_other);
181 dst->vna_name = H_GET_32 (abfd, src->vna_name);
182 dst->vna_next = H_GET_32 (abfd, src->vna_next);
185 /* Swap out a Vernaux structure. */
187 void
188 _bfd_elf_swap_vernaux_out (abfd, src, dst)
189 bfd *abfd;
190 const Elf_Internal_Vernaux *src;
191 Elf_External_Vernaux *dst;
193 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
194 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
195 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
196 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
197 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
200 /* Swap in a Versym structure. */
202 void
203 _bfd_elf_swap_versym_in (abfd, src, dst)
204 bfd *abfd;
205 const Elf_External_Versym *src;
206 Elf_Internal_Versym *dst;
208 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
211 /* Swap out a Versym structure. */
213 void
214 _bfd_elf_swap_versym_out (abfd, src, dst)
215 bfd *abfd;
216 const Elf_Internal_Versym *src;
217 Elf_External_Versym *dst;
219 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
222 /* Standard ELF hash function. Do not change this function; you will
223 cause invalid hash tables to be generated. */
225 unsigned long
226 bfd_elf_hash (namearg)
227 const char *namearg;
229 const unsigned char *name = (const unsigned char *) namearg;
230 unsigned long h = 0;
231 unsigned long g;
232 int ch;
234 while ((ch = *name++) != '\0')
236 h = (h << 4) + ch;
237 if ((g = (h & 0xf0000000)) != 0)
239 h ^= g >> 24;
240 /* The ELF ABI says `h &= ~g', but this is equivalent in
241 this case and on some machines one insn instead of two. */
242 h ^= g;
245 return h;
248 /* Read a specified number of bytes at a specified offset in an ELF
249 file, into a newly allocated buffer, and return a pointer to the
250 buffer. */
252 static char *
253 elf_read (abfd, offset, size)
254 bfd *abfd;
255 file_ptr offset;
256 bfd_size_type size;
258 char *buf;
260 if ((buf = bfd_alloc (abfd, size)) == NULL)
261 return NULL;
262 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
263 return NULL;
264 if (bfd_bread ((PTR) buf, size, abfd) != size)
266 if (bfd_get_error () != bfd_error_system_call)
267 bfd_set_error (bfd_error_file_truncated);
268 return NULL;
270 return buf;
273 boolean
274 bfd_elf_mkobject (abfd)
275 bfd *abfd;
277 /* This just does initialization. */
278 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
279 bfd_size_type amt = sizeof (struct elf_obj_tdata);
280 elf_tdata (abfd) = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
281 if (elf_tdata (abfd) == 0)
282 return false;
283 /* Since everything is done at close time, do we need any
284 initialization? */
286 return true;
289 boolean
290 bfd_elf_mkcorefile (abfd)
291 bfd *abfd;
293 /* I think this can be done just like an object file. */
294 return bfd_elf_mkobject (abfd);
297 char *
298 bfd_elf_get_str_section (abfd, shindex)
299 bfd *abfd;
300 unsigned int shindex;
302 Elf_Internal_Shdr **i_shdrp;
303 char *shstrtab = NULL;
304 file_ptr offset;
305 bfd_size_type shstrtabsize;
307 i_shdrp = elf_elfsections (abfd);
308 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
309 return 0;
311 shstrtab = (char *) i_shdrp[shindex]->contents;
312 if (shstrtab == NULL)
314 /* No cached one, attempt to read, and cache what we read. */
315 offset = i_shdrp[shindex]->sh_offset;
316 shstrtabsize = i_shdrp[shindex]->sh_size;
317 shstrtab = elf_read (abfd, offset, shstrtabsize);
318 i_shdrp[shindex]->contents = (PTR) shstrtab;
320 return shstrtab;
323 char *
324 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
325 bfd *abfd;
326 unsigned int shindex;
327 unsigned int strindex;
329 Elf_Internal_Shdr *hdr;
331 if (strindex == 0)
332 return "";
334 hdr = elf_elfsections (abfd)[shindex];
336 if (hdr->contents == NULL
337 && bfd_elf_get_str_section (abfd, shindex) == NULL)
338 return NULL;
340 if (strindex >= hdr->sh_size)
342 (*_bfd_error_handler)
343 (_("%s: invalid string offset %u >= %lu for section `%s'"),
344 bfd_archive_filename (abfd), strindex, (unsigned long) hdr->sh_size,
345 ((shindex == elf_elfheader(abfd)->e_shstrndx
346 && strindex == hdr->sh_name)
347 ? ".shstrtab"
348 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
349 return "";
352 return ((char *) hdr->contents) + strindex;
355 /* Read and convert symbols to internal format.
356 SYMCOUNT specifies the number of symbols to read, starting from
357 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
358 are non-NULL, they are used to store the internal symbols, external
359 symbols, and symbol section index extensions, respectively. */
361 Elf_Internal_Sym *
362 bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, symoffset,
363 intsym_buf, extsym_buf, extshndx_buf)
364 bfd *ibfd;
365 Elf_Internal_Shdr *symtab_hdr;
366 size_t symcount;
367 size_t symoffset;
368 Elf_Internal_Sym *intsym_buf;
369 PTR extsym_buf;
370 Elf_External_Sym_Shndx *extshndx_buf;
372 Elf_Internal_Shdr *shndx_hdr;
373 PTR alloc_ext;
374 const bfd_byte *esym;
375 Elf_External_Sym_Shndx *alloc_extshndx;
376 Elf_External_Sym_Shndx *shndx;
377 Elf_Internal_Sym *isym;
378 Elf_Internal_Sym *isymend;
379 struct elf_backend_data *bed;
380 size_t extsym_size;
381 bfd_size_type amt;
382 file_ptr pos;
384 if (symcount == 0)
385 return intsym_buf;
387 /* Normal syms might have section extension entries. */
388 shndx_hdr = NULL;
389 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
390 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
392 /* Read the symbols. */
393 alloc_ext = NULL;
394 alloc_extshndx = NULL;
395 bed = get_elf_backend_data (ibfd);
396 extsym_size = bed->s->sizeof_sym;
397 amt = symcount * extsym_size;
398 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
399 if (extsym_buf == NULL)
401 alloc_ext = bfd_malloc (amt);
402 extsym_buf = alloc_ext;
404 if (extsym_buf == NULL
405 || bfd_seek (ibfd, pos, SEEK_SET) != 0
406 || bfd_bread (extsym_buf, amt, ibfd) != amt)
408 intsym_buf = NULL;
409 goto out;
412 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
413 extshndx_buf = NULL;
414 else
416 amt = symcount * sizeof (Elf_External_Sym_Shndx);
417 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
418 if (extshndx_buf == NULL)
420 alloc_extshndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
421 extshndx_buf = alloc_extshndx;
423 if (extshndx_buf == NULL
424 || bfd_seek (ibfd, pos, SEEK_SET) != 0
425 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
427 intsym_buf = NULL;
428 goto out;
432 if (intsym_buf == NULL)
434 bfd_size_type amt = symcount * sizeof (Elf_Internal_Sym);
435 intsym_buf = (Elf_Internal_Sym *) bfd_malloc (amt);
436 if (intsym_buf == NULL)
437 goto out;
440 /* Convert the symbols to internal form. */
441 isymend = intsym_buf + symcount;
442 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
443 isym < isymend;
444 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
445 (*bed->s->swap_symbol_in) (ibfd, esym, (const PTR) shndx, isym);
447 out:
448 if (alloc_ext != NULL)
449 free (alloc_ext);
450 if (alloc_extshndx != NULL)
451 free (alloc_extshndx);
453 return intsym_buf;
456 /* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
457 sections. The first element is the flags, the rest are section
458 pointers. */
460 typedef union elf_internal_group {
461 Elf_Internal_Shdr *shdr;
462 unsigned int flags;
463 } Elf_Internal_Group;
465 /* Return the name of the group signature symbol. Why isn't the
466 signature just a string? */
468 static const char *
469 group_signature (abfd, ghdr)
470 bfd *abfd;
471 Elf_Internal_Shdr *ghdr;
473 Elf_Internal_Shdr *hdr;
474 unsigned char esym[sizeof (Elf64_External_Sym)];
475 Elf_External_Sym_Shndx eshndx;
476 Elf_Internal_Sym isym;
477 unsigned int iname;
478 unsigned int shindex;
480 /* First we need to ensure the symbol table is available. */
481 if (! bfd_section_from_shdr (abfd, ghdr->sh_link))
482 return NULL;
484 /* Go read the symbol. */
485 hdr = &elf_tdata (abfd)->symtab_hdr;
486 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
487 &isym, esym, &eshndx) == NULL)
488 return NULL;
490 /* Look up the symbol name. */
491 iname = isym.st_name;
492 shindex = hdr->sh_link;
493 if (iname == 0 && ELF_ST_TYPE (isym.st_info) == STT_SECTION)
495 iname = elf_elfsections (abfd)[isym.st_shndx]->sh_name;
496 shindex = elf_elfheader (abfd)->e_shstrndx;
499 return bfd_elf_string_from_elf_section (abfd, shindex, iname);
502 /* Set next_in_group list pointer, and group name for NEWSECT. */
504 static boolean
505 setup_group (abfd, hdr, newsect)
506 bfd *abfd;
507 Elf_Internal_Shdr *hdr;
508 asection *newsect;
510 unsigned int num_group = elf_tdata (abfd)->num_group;
512 /* If num_group is zero, read in all SHT_GROUP sections. The count
513 is set to -1 if there are no SHT_GROUP sections. */
514 if (num_group == 0)
516 unsigned int i, shnum;
518 /* First count the number of groups. If we have a SHT_GROUP
519 section with just a flag word (ie. sh_size is 4), ignore it. */
520 shnum = elf_numsections (abfd);
521 num_group = 0;
522 for (i = 0; i < shnum; i++)
524 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
525 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
526 num_group += 1;
529 if (num_group == 0)
530 num_group = (unsigned) -1;
531 elf_tdata (abfd)->num_group = num_group;
533 if (num_group > 0)
535 /* We keep a list of elf section headers for group sections,
536 so we can find them quickly. */
537 bfd_size_type amt = num_group * sizeof (Elf_Internal_Shdr *);
538 elf_tdata (abfd)->group_sect_ptr = bfd_alloc (abfd, amt);
539 if (elf_tdata (abfd)->group_sect_ptr == NULL)
540 return false;
542 num_group = 0;
543 for (i = 0; i < shnum; i++)
545 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
546 if (shdr->sh_type == SHT_GROUP && shdr->sh_size >= 8)
548 unsigned char *src;
549 Elf_Internal_Group *dest;
551 /* Add to list of sections. */
552 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
553 num_group += 1;
555 /* Read the raw contents. */
556 BFD_ASSERT (sizeof (*dest) >= 4);
557 amt = shdr->sh_size * sizeof (*dest) / 4;
558 shdr->contents = bfd_alloc (abfd, amt);
559 if (shdr->contents == NULL
560 || bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
561 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
562 != shdr->sh_size))
563 return false;
565 /* Translate raw contents, a flag word followed by an
566 array of elf section indices all in target byte order,
567 to the flag word followed by an array of elf section
568 pointers. */
569 src = shdr->contents + shdr->sh_size;
570 dest = (Elf_Internal_Group *) (shdr->contents + amt);
571 while (1)
573 unsigned int idx;
575 src -= 4;
576 --dest;
577 idx = H_GET_32 (abfd, src);
578 if (src == shdr->contents)
580 dest->flags = idx;
581 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
582 shdr->bfd_section->flags
583 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
584 break;
586 if (idx >= shnum)
588 ((*_bfd_error_handler)
589 (_("%s: invalid SHT_GROUP entry"),
590 bfd_archive_filename (abfd)));
591 idx = 0;
593 dest->shdr = elf_elfsections (abfd)[idx];
600 if (num_group != (unsigned) -1)
602 unsigned int i;
604 for (i = 0; i < num_group; i++)
606 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
607 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
608 unsigned int n_elt = shdr->sh_size / 4;
610 /* Look through this group's sections to see if current
611 section is a member. */
612 while (--n_elt != 0)
613 if ((++idx)->shdr == hdr)
615 asection *s = NULL;
617 /* We are a member of this group. Go looking through
618 other members to see if any others are linked via
619 next_in_group. */
620 idx = (Elf_Internal_Group *) shdr->contents;
621 n_elt = shdr->sh_size / 4;
622 while (--n_elt != 0)
623 if ((s = (++idx)->shdr->bfd_section) != NULL
624 && elf_next_in_group (s) != NULL)
625 break;
626 if (n_elt != 0)
628 /* Snarf the group name from other member, and
629 insert current section in circular list. */
630 elf_group_name (newsect) = elf_group_name (s);
631 elf_next_in_group (newsect) = elf_next_in_group (s);
632 elf_next_in_group (s) = newsect;
634 else
636 const char *gname;
638 gname = group_signature (abfd, shdr);
639 if (gname == NULL)
640 return false;
641 elf_group_name (newsect) = gname;
643 /* Start a circular list with one element. */
644 elf_next_in_group (newsect) = newsect;
647 /* If the group section has been created, point to the
648 new member. */
649 if (shdr->bfd_section != NULL)
650 elf_next_in_group (shdr->bfd_section) = newsect;
652 i = num_group - 1;
653 break;
658 if (elf_group_name (newsect) == NULL)
660 (*_bfd_error_handler) (_("%s: no group info for section %s"),
661 bfd_archive_filename (abfd), newsect->name);
663 return true;
666 boolean
667 bfd_elf_discard_group (abfd, group)
668 bfd *abfd ATTRIBUTE_UNUSED;
669 asection *group;
671 asection *first = elf_next_in_group (group);
672 asection *s = first;
674 while (s != NULL)
676 s->output_section = bfd_abs_section_ptr;
677 s = elf_next_in_group (s);
678 /* These lists are circular. */
679 if (s == first)
680 break;
682 return true;
685 /* Make a BFD section from an ELF section. We store a pointer to the
686 BFD section in the bfd_section field of the header. */
688 boolean
689 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
690 bfd *abfd;
691 Elf_Internal_Shdr *hdr;
692 const char *name;
694 asection *newsect;
695 flagword flags;
696 struct elf_backend_data *bed;
698 if (hdr->bfd_section != NULL)
700 BFD_ASSERT (strcmp (name,
701 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
702 return true;
705 newsect = bfd_make_section_anyway (abfd, name);
706 if (newsect == NULL)
707 return false;
709 newsect->filepos = hdr->sh_offset;
711 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
712 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
713 || ! bfd_set_section_alignment (abfd, newsect,
714 bfd_log2 ((bfd_vma) hdr->sh_addralign)))
715 return false;
717 flags = SEC_NO_FLAGS;
718 if (hdr->sh_type != SHT_NOBITS)
719 flags |= SEC_HAS_CONTENTS;
720 if (hdr->sh_type == SHT_GROUP)
721 flags |= SEC_GROUP | SEC_EXCLUDE;
722 if ((hdr->sh_flags & SHF_ALLOC) != 0)
724 flags |= SEC_ALLOC;
725 if (hdr->sh_type != SHT_NOBITS)
726 flags |= SEC_LOAD;
728 if ((hdr->sh_flags & SHF_WRITE) == 0)
729 flags |= SEC_READONLY;
730 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
731 flags |= SEC_CODE;
732 else if ((flags & SEC_LOAD) != 0)
733 flags |= SEC_DATA;
734 if ((hdr->sh_flags & SHF_MERGE) != 0)
736 flags |= SEC_MERGE;
737 newsect->entsize = hdr->sh_entsize;
738 if ((hdr->sh_flags & SHF_STRINGS) != 0)
739 flags |= SEC_STRINGS;
741 if (hdr->sh_flags & SHF_GROUP)
742 if (!setup_group (abfd, hdr, newsect))
743 return false;
744 if ((hdr->sh_flags & SHF_TLS) != 0)
745 flags |= SEC_THREAD_LOCAL;
747 /* The debugging sections appear to be recognized only by name, not
748 any sort of flag. */
750 static const char *debug_sec_names [] =
752 ".debug",
753 ".gnu.linkonce.wi.",
754 ".line",
755 ".stab"
757 int i;
759 for (i = ARRAY_SIZE (debug_sec_names); i--;)
760 if (strncmp (name, debug_sec_names[i], strlen (debug_sec_names[i])) == 0)
761 break;
763 if (i >= 0)
764 flags |= SEC_DEBUGGING;
767 /* As a GNU extension, if the name begins with .gnu.linkonce, we
768 only link a single copy of the section. This is used to support
769 g++. g++ will emit each template expansion in its own section.
770 The symbols will be defined as weak, so that multiple definitions
771 are permitted. The GNU linker extension is to actually discard
772 all but one of the sections. */
773 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0
774 && elf_next_in_group (newsect) == NULL)
775 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
777 bed = get_elf_backend_data (abfd);
778 if (bed->elf_backend_section_flags)
779 if (! bed->elf_backend_section_flags (&flags, hdr))
780 return false;
782 if (! bfd_set_section_flags (abfd, newsect, flags))
783 return false;
785 if ((flags & SEC_ALLOC) != 0)
787 Elf_Internal_Phdr *phdr;
788 unsigned int i;
790 /* Look through the phdrs to see if we need to adjust the lma.
791 If all the p_paddr fields are zero, we ignore them, since
792 some ELF linkers produce such output. */
793 phdr = elf_tdata (abfd)->phdr;
794 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
796 if (phdr->p_paddr != 0)
797 break;
799 if (i < elf_elfheader (abfd)->e_phnum)
801 phdr = elf_tdata (abfd)->phdr;
802 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
804 /* This section is part of this segment if its file
805 offset plus size lies within the segment's memory
806 span and, if the section is loaded, the extent of the
807 loaded data lies within the extent of the segment.
809 Note - we used to check the p_paddr field as well, and
810 refuse to set the LMA if it was 0. This is wrong
811 though, as a perfectly valid initialised segment can
812 have a p_paddr of zero. Some architectures, eg ARM,
813 place special significance on the address 0 and
814 executables need to be able to have a segment which
815 covers this address. */
816 if (phdr->p_type == PT_LOAD
817 && (bfd_vma) hdr->sh_offset >= phdr->p_offset
818 && (hdr->sh_offset + hdr->sh_size
819 <= phdr->p_offset + phdr->p_memsz)
820 && ((flags & SEC_LOAD) == 0
821 || (hdr->sh_offset + hdr->sh_size
822 <= phdr->p_offset + phdr->p_filesz)))
824 if ((flags & SEC_LOAD) == 0)
825 newsect->lma = (phdr->p_paddr
826 + hdr->sh_addr - phdr->p_vaddr);
827 else
828 /* We used to use the same adjustment for SEC_LOAD
829 sections, but that doesn't work if the segment
830 is packed with code from multiple VMAs.
831 Instead we calculate the section LMA based on
832 the segment LMA. It is assumed that the
833 segment will contain sections with contiguous
834 LMAs, even if the VMAs are not. */
835 newsect->lma = (phdr->p_paddr
836 + hdr->sh_offset - phdr->p_offset);
838 /* With contiguous segments, we can't tell from file
839 offsets whether a section with zero size should
840 be placed at the end of one segment or the
841 beginning of the next. Decide based on vaddr. */
842 if (hdr->sh_addr >= phdr->p_vaddr
843 && (hdr->sh_addr + hdr->sh_size
844 <= phdr->p_vaddr + phdr->p_memsz))
845 break;
851 hdr->bfd_section = newsect;
852 elf_section_data (newsect)->this_hdr = *hdr;
854 return true;
858 INTERNAL_FUNCTION
859 bfd_elf_find_section
861 SYNOPSIS
862 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
864 DESCRIPTION
865 Helper functions for GDB to locate the string tables.
866 Since BFD hides string tables from callers, GDB needs to use an
867 internal hook to find them. Sun's .stabstr, in particular,
868 isn't even pointed to by the .stab section, so ordinary
869 mechanisms wouldn't work to find it, even if we had some.
872 struct elf_internal_shdr *
873 bfd_elf_find_section (abfd, name)
874 bfd *abfd;
875 char *name;
877 Elf_Internal_Shdr **i_shdrp;
878 char *shstrtab;
879 unsigned int max;
880 unsigned int i;
882 i_shdrp = elf_elfsections (abfd);
883 if (i_shdrp != NULL)
885 shstrtab = bfd_elf_get_str_section (abfd,
886 elf_elfheader (abfd)->e_shstrndx);
887 if (shstrtab != NULL)
889 max = elf_numsections (abfd);
890 for (i = 1; i < max; i++)
891 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
892 return i_shdrp[i];
895 return 0;
898 const char *const bfd_elf_section_type_names[] = {
899 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
900 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
901 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
904 /* ELF relocs are against symbols. If we are producing relocateable
905 output, and the reloc is against an external symbol, and nothing
906 has given us any additional addend, the resulting reloc will also
907 be against the same symbol. In such a case, we don't want to
908 change anything about the way the reloc is handled, since it will
909 all be done at final link time. Rather than put special case code
910 into bfd_perform_relocation, all the reloc types use this howto
911 function. It just short circuits the reloc if producing
912 relocateable output against an external symbol. */
914 bfd_reloc_status_type
915 bfd_elf_generic_reloc (abfd,
916 reloc_entry,
917 symbol,
918 data,
919 input_section,
920 output_bfd,
921 error_message)
922 bfd *abfd ATTRIBUTE_UNUSED;
923 arelent *reloc_entry;
924 asymbol *symbol;
925 PTR data ATTRIBUTE_UNUSED;
926 asection *input_section;
927 bfd *output_bfd;
928 char **error_message ATTRIBUTE_UNUSED;
930 if (output_bfd != (bfd *) NULL
931 && (symbol->flags & BSF_SECTION_SYM) == 0
932 && (! reloc_entry->howto->partial_inplace
933 || reloc_entry->addend == 0))
935 reloc_entry->address += input_section->output_offset;
936 return bfd_reloc_ok;
939 return bfd_reloc_continue;
942 /* Make sure sec_info_type is cleared if sec_info is cleared too. */
944 static void
945 merge_sections_remove_hook (abfd, sec)
946 bfd *abfd ATTRIBUTE_UNUSED;
947 asection *sec;
949 struct bfd_elf_section_data *sec_data;
951 sec_data = elf_section_data (sec);
952 BFD_ASSERT (sec_data->sec_info_type == ELF_INFO_TYPE_MERGE);
953 sec_data->sec_info_type = ELF_INFO_TYPE_NONE;
956 /* Finish SHF_MERGE section merging. */
958 boolean
959 _bfd_elf_merge_sections (abfd, info)
960 bfd *abfd;
961 struct bfd_link_info *info;
963 if (!is_elf_hash_table (info))
964 return false;
965 if (elf_hash_table (info)->merge_info)
966 _bfd_merge_sections (abfd, elf_hash_table (info)->merge_info,
967 merge_sections_remove_hook);
968 return true;
971 void
972 _bfd_elf_link_just_syms (sec, info)
973 asection *sec;
974 struct bfd_link_info *info;
976 sec->output_section = bfd_abs_section_ptr;
977 sec->output_offset = sec->vma;
978 if (!is_elf_hash_table (info))
979 return;
981 elf_section_data (sec)->sec_info_type = ELF_INFO_TYPE_JUST_SYMS;
984 /* Copy the program header and other data from one object module to
985 another. */
987 boolean
988 _bfd_elf_copy_private_bfd_data (ibfd, obfd)
989 bfd *ibfd;
990 bfd *obfd;
992 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
993 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
994 return true;
996 BFD_ASSERT (!elf_flags_init (obfd)
997 || (elf_elfheader (obfd)->e_flags
998 == elf_elfheader (ibfd)->e_flags));
1000 elf_gp (obfd) = elf_gp (ibfd);
1001 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1002 elf_flags_init (obfd) = true;
1003 return true;
1006 /* Print out the program headers. */
1008 boolean
1009 _bfd_elf_print_private_bfd_data (abfd, farg)
1010 bfd *abfd;
1011 PTR farg;
1013 FILE *f = (FILE *) farg;
1014 Elf_Internal_Phdr *p;
1015 asection *s;
1016 bfd_byte *dynbuf = NULL;
1018 p = elf_tdata (abfd)->phdr;
1019 if (p != NULL)
1021 unsigned int i, c;
1023 fprintf (f, _("\nProgram Header:\n"));
1024 c = elf_elfheader (abfd)->e_phnum;
1025 for (i = 0; i < c; i++, p++)
1027 const char *pt;
1028 char buf[20];
1030 switch (p->p_type)
1032 case PT_NULL: pt = "NULL"; break;
1033 case PT_LOAD: pt = "LOAD"; break;
1034 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1035 case PT_INTERP: pt = "INTERP"; break;
1036 case PT_NOTE: pt = "NOTE"; break;
1037 case PT_SHLIB: pt = "SHLIB"; break;
1038 case PT_PHDR: pt = "PHDR"; break;
1039 case PT_TLS: pt = "TLS"; break;
1040 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
1041 default: sprintf (buf, "0x%lx", p->p_type); pt = buf; break;
1043 fprintf (f, "%8s off 0x", pt);
1044 bfd_fprintf_vma (abfd, f, p->p_offset);
1045 fprintf (f, " vaddr 0x");
1046 bfd_fprintf_vma (abfd, f, p->p_vaddr);
1047 fprintf (f, " paddr 0x");
1048 bfd_fprintf_vma (abfd, f, p->p_paddr);
1049 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1050 fprintf (f, " filesz 0x");
1051 bfd_fprintf_vma (abfd, f, p->p_filesz);
1052 fprintf (f, " memsz 0x");
1053 bfd_fprintf_vma (abfd, f, p->p_memsz);
1054 fprintf (f, " flags %c%c%c",
1055 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1056 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1057 (p->p_flags & PF_X) != 0 ? 'x' : '-');
1058 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1059 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
1060 fprintf (f, "\n");
1064 s = bfd_get_section_by_name (abfd, ".dynamic");
1065 if (s != NULL)
1067 int elfsec;
1068 unsigned long shlink;
1069 bfd_byte *extdyn, *extdynend;
1070 size_t extdynsize;
1071 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1073 fprintf (f, _("\nDynamic Section:\n"));
1075 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1076 if (dynbuf == NULL)
1077 goto error_return;
1078 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1079 s->_raw_size))
1080 goto error_return;
1082 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1083 if (elfsec == -1)
1084 goto error_return;
1085 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1087 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1088 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1090 extdyn = dynbuf;
1091 extdynend = extdyn + s->_raw_size;
1092 for (; extdyn < extdynend; extdyn += extdynsize)
1094 Elf_Internal_Dyn dyn;
1095 const char *name;
1096 char ab[20];
1097 boolean stringp;
1099 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1101 if (dyn.d_tag == DT_NULL)
1102 break;
1104 stringp = false;
1105 switch (dyn.d_tag)
1107 default:
1108 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1109 name = ab;
1110 break;
1112 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
1113 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1114 case DT_PLTGOT: name = "PLTGOT"; break;
1115 case DT_HASH: name = "HASH"; break;
1116 case DT_STRTAB: name = "STRTAB"; break;
1117 case DT_SYMTAB: name = "SYMTAB"; break;
1118 case DT_RELA: name = "RELA"; break;
1119 case DT_RELASZ: name = "RELASZ"; break;
1120 case DT_RELAENT: name = "RELAENT"; break;
1121 case DT_STRSZ: name = "STRSZ"; break;
1122 case DT_SYMENT: name = "SYMENT"; break;
1123 case DT_INIT: name = "INIT"; break;
1124 case DT_FINI: name = "FINI"; break;
1125 case DT_SONAME: name = "SONAME"; stringp = true; break;
1126 case DT_RPATH: name = "RPATH"; stringp = true; break;
1127 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1128 case DT_REL: name = "REL"; break;
1129 case DT_RELSZ: name = "RELSZ"; break;
1130 case DT_RELENT: name = "RELENT"; break;
1131 case DT_PLTREL: name = "PLTREL"; break;
1132 case DT_DEBUG: name = "DEBUG"; break;
1133 case DT_TEXTREL: name = "TEXTREL"; break;
1134 case DT_JMPREL: name = "JMPREL"; break;
1135 case DT_BIND_NOW: name = "BIND_NOW"; break;
1136 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1137 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1138 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1139 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
1140 case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
1141 case DT_FLAGS: name = "FLAGS"; break;
1142 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1143 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
1144 case DT_CHECKSUM: name = "CHECKSUM"; break;
1145 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1146 case DT_MOVEENT: name = "MOVEENT"; break;
1147 case DT_MOVESZ: name = "MOVESZ"; break;
1148 case DT_FEATURE: name = "FEATURE"; break;
1149 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1150 case DT_SYMINSZ: name = "SYMINSZ"; break;
1151 case DT_SYMINENT: name = "SYMINENT"; break;
1152 case DT_CONFIG: name = "CONFIG"; stringp = true; break;
1153 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
1154 case DT_AUDIT: name = "AUDIT"; stringp = true; break;
1155 case DT_PLTPAD: name = "PLTPAD"; break;
1156 case DT_MOVETAB: name = "MOVETAB"; break;
1157 case DT_SYMINFO: name = "SYMINFO"; break;
1158 case DT_RELACOUNT: name = "RELACOUNT"; break;
1159 case DT_RELCOUNT: name = "RELCOUNT"; break;
1160 case DT_FLAGS_1: name = "FLAGS_1"; break;
1161 case DT_VERSYM: name = "VERSYM"; break;
1162 case DT_VERDEF: name = "VERDEF"; break;
1163 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1164 case DT_VERNEED: name = "VERNEED"; break;
1165 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
1166 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
1167 case DT_USED: name = "USED"; break;
1168 case DT_FILTER: name = "FILTER"; stringp = true; break;
1171 fprintf (f, " %-11s ", name);
1172 if (! stringp)
1173 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
1174 else
1176 const char *string;
1177 unsigned int tagv = dyn.d_un.d_val;
1179 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1180 if (string == NULL)
1181 goto error_return;
1182 fprintf (f, "%s", string);
1184 fprintf (f, "\n");
1187 free (dynbuf);
1188 dynbuf = NULL;
1191 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1192 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1194 if (! _bfd_elf_slurp_version_tables (abfd))
1195 return false;
1198 if (elf_dynverdef (abfd) != 0)
1200 Elf_Internal_Verdef *t;
1202 fprintf (f, _("\nVersion definitions:\n"));
1203 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1205 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
1206 t->vd_flags, t->vd_hash, t->vd_nodename);
1207 if (t->vd_auxptr->vda_nextptr != NULL)
1209 Elf_Internal_Verdaux *a;
1211 fprintf (f, "\t");
1212 for (a = t->vd_auxptr->vda_nextptr;
1213 a != NULL;
1214 a = a->vda_nextptr)
1215 fprintf (f, "%s ", a->vda_nodename);
1216 fprintf (f, "\n");
1221 if (elf_dynverref (abfd) != 0)
1223 Elf_Internal_Verneed *t;
1225 fprintf (f, _("\nVersion References:\n"));
1226 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1228 Elf_Internal_Vernaux *a;
1230 fprintf (f, _(" required from %s:\n"), t->vn_filename);
1231 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1232 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
1233 a->vna_flags, a->vna_other, a->vna_nodename);
1237 return true;
1239 error_return:
1240 if (dynbuf != NULL)
1241 free (dynbuf);
1242 return false;
1245 /* Display ELF-specific fields of a symbol. */
1247 void
1248 bfd_elf_print_symbol (abfd, filep, symbol, how)
1249 bfd *abfd;
1250 PTR filep;
1251 asymbol *symbol;
1252 bfd_print_symbol_type how;
1254 FILE *file = (FILE *) filep;
1255 switch (how)
1257 case bfd_print_symbol_name:
1258 fprintf (file, "%s", symbol->name);
1259 break;
1260 case bfd_print_symbol_more:
1261 fprintf (file, "elf ");
1262 bfd_fprintf_vma (abfd, file, symbol->value);
1263 fprintf (file, " %lx", (long) symbol->flags);
1264 break;
1265 case bfd_print_symbol_all:
1267 const char *section_name;
1268 const char *name = NULL;
1269 struct elf_backend_data *bed;
1270 unsigned char st_other;
1271 bfd_vma val;
1273 section_name = symbol->section ? symbol->section->name : "(*none*)";
1275 bed = get_elf_backend_data (abfd);
1276 if (bed->elf_backend_print_symbol_all)
1277 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
1279 if (name == NULL)
1281 name = symbol->name;
1282 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
1285 fprintf (file, " %s\t", section_name);
1286 /* Print the "other" value for a symbol. For common symbols,
1287 we've already printed the size; now print the alignment.
1288 For other symbols, we have no specified alignment, and
1289 we've printed the address; now print the size. */
1290 if (bfd_is_com_section (symbol->section))
1291 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1292 else
1293 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1294 bfd_fprintf_vma (abfd, file, val);
1296 /* If we have version information, print it. */
1297 if (elf_tdata (abfd)->dynversym_section != 0
1298 && (elf_tdata (abfd)->dynverdef_section != 0
1299 || elf_tdata (abfd)->dynverref_section != 0))
1301 unsigned int vernum;
1302 const char *version_string;
1304 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1306 if (vernum == 0)
1307 version_string = "";
1308 else if (vernum == 1)
1309 version_string = "Base";
1310 else if (vernum <= elf_tdata (abfd)->cverdefs)
1311 version_string =
1312 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1313 else
1315 Elf_Internal_Verneed *t;
1317 version_string = "";
1318 for (t = elf_tdata (abfd)->verref;
1319 t != NULL;
1320 t = t->vn_nextref)
1322 Elf_Internal_Vernaux *a;
1324 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1326 if (a->vna_other == vernum)
1328 version_string = a->vna_nodename;
1329 break;
1335 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1336 fprintf (file, " %-11s", version_string);
1337 else
1339 int i;
1341 fprintf (file, " (%s)", version_string);
1342 for (i = 10 - strlen (version_string); i > 0; --i)
1343 putc (' ', file);
1347 /* If the st_other field is not zero, print it. */
1348 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
1350 switch (st_other)
1352 case 0: break;
1353 case STV_INTERNAL: fprintf (file, " .internal"); break;
1354 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1355 case STV_PROTECTED: fprintf (file, " .protected"); break;
1356 default:
1357 /* Some other non-defined flags are also present, so print
1358 everything hex. */
1359 fprintf (file, " 0x%02x", (unsigned int) st_other);
1362 fprintf (file, " %s", name);
1364 break;
1368 /* Create an entry in an ELF linker hash table. */
1370 struct bfd_hash_entry *
1371 _bfd_elf_link_hash_newfunc (entry, table, string)
1372 struct bfd_hash_entry *entry;
1373 struct bfd_hash_table *table;
1374 const char *string;
1376 /* Allocate the structure if it has not already been allocated by a
1377 subclass. */
1378 if (entry == NULL)
1380 entry = bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
1381 if (entry == NULL)
1382 return entry;
1385 /* Call the allocation method of the superclass. */
1386 entry = _bfd_link_hash_newfunc (entry, table, string);
1387 if (entry != NULL)
1389 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
1390 struct elf_link_hash_table *htab = (struct elf_link_hash_table *) table;
1392 /* Set local fields. */
1393 ret->indx = -1;
1394 ret->size = 0;
1395 ret->dynindx = -1;
1396 ret->dynstr_index = 0;
1397 ret->weakdef = NULL;
1398 ret->got.refcount = htab->init_refcount;
1399 ret->plt.refcount = htab->init_refcount;
1400 ret->linker_section_pointer = NULL;
1401 ret->verinfo.verdef = NULL;
1402 ret->vtable_entries_used = NULL;
1403 ret->vtable_entries_size = 0;
1404 ret->vtable_parent = NULL;
1405 ret->type = STT_NOTYPE;
1406 ret->other = 0;
1407 /* Assume that we have been called by a non-ELF symbol reader.
1408 This flag is then reset by the code which reads an ELF input
1409 file. This ensures that a symbol created by a non-ELF symbol
1410 reader will have the flag set correctly. */
1411 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
1414 return entry;
1417 /* Copy data from an indirect symbol to its direct symbol, hiding the
1418 old indirect symbol. Also used for copying flags to a weakdef. */
1420 void
1421 _bfd_elf_link_hash_copy_indirect (bed, dir, ind)
1422 struct elf_backend_data *bed;
1423 struct elf_link_hash_entry *dir, *ind;
1425 bfd_signed_vma tmp;
1426 bfd_signed_vma lowest_valid = bed->can_refcount;
1428 /* Copy down any references that we may have already seen to the
1429 symbol which just became indirect. */
1431 dir->elf_link_hash_flags |=
1432 (ind->elf_link_hash_flags
1433 & (ELF_LINK_HASH_REF_DYNAMIC
1434 | ELF_LINK_HASH_REF_REGULAR
1435 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1436 | ELF_LINK_NON_GOT_REF));
1438 if (ind->root.type != bfd_link_hash_indirect)
1439 return;
1441 /* Copy over the global and procedure linkage table refcount entries.
1442 These may have been already set up by a check_relocs routine. */
1443 tmp = dir->got.refcount;
1444 if (tmp < lowest_valid)
1446 dir->got.refcount = ind->got.refcount;
1447 ind->got.refcount = tmp;
1449 else
1450 BFD_ASSERT (ind->got.refcount < lowest_valid);
1452 tmp = dir->plt.refcount;
1453 if (tmp < lowest_valid)
1455 dir->plt.refcount = ind->plt.refcount;
1456 ind->plt.refcount = tmp;
1458 else
1459 BFD_ASSERT (ind->plt.refcount < lowest_valid);
1461 if (dir->dynindx == -1)
1463 dir->dynindx = ind->dynindx;
1464 dir->dynstr_index = ind->dynstr_index;
1465 ind->dynindx = -1;
1466 ind->dynstr_index = 0;
1468 else
1469 BFD_ASSERT (ind->dynindx == -1);
1472 void
1473 _bfd_elf_link_hash_hide_symbol (info, h, force_local)
1474 struct bfd_link_info *info;
1475 struct elf_link_hash_entry *h;
1476 boolean force_local;
1478 h->plt.offset = (bfd_vma) -1;
1479 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1480 if (force_local)
1482 h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
1483 if (h->dynindx != -1)
1485 h->dynindx = -1;
1486 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1487 h->dynstr_index);
1492 /* Initialize an ELF linker hash table. */
1494 boolean
1495 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
1496 struct elf_link_hash_table *table;
1497 bfd *abfd;
1498 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1499 struct bfd_hash_table *,
1500 const char *));
1502 boolean ret;
1504 table->dynamic_sections_created = false;
1505 table->dynobj = NULL;
1506 table->init_refcount = get_elf_backend_data (abfd)->can_refcount - 1;
1507 /* The first dynamic symbol is a dummy. */
1508 table->dynsymcount = 1;
1509 table->dynstr = NULL;
1510 table->bucketcount = 0;
1511 table->needed = NULL;
1512 table->runpath = NULL;
1513 table->loaded = NULL;
1514 table->hgot = NULL;
1515 table->stab_info = NULL;
1516 table->merge_info = NULL;
1517 table->dynlocal = NULL;
1518 ret = _bfd_link_hash_table_init (& table->root, abfd, newfunc);
1519 table->root.type = bfd_link_elf_hash_table;
1521 return ret;
1524 /* Create an ELF linker hash table. */
1526 struct bfd_link_hash_table *
1527 _bfd_elf_link_hash_table_create (abfd)
1528 bfd *abfd;
1530 struct elf_link_hash_table *ret;
1531 bfd_size_type amt = sizeof (struct elf_link_hash_table);
1533 ret = (struct elf_link_hash_table *) bfd_malloc (amt);
1534 if (ret == (struct elf_link_hash_table *) NULL)
1535 return NULL;
1537 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1539 free (ret);
1540 return NULL;
1543 return &ret->root;
1546 /* This is a hook for the ELF emulation code in the generic linker to
1547 tell the backend linker what file name to use for the DT_NEEDED
1548 entry for a dynamic object. The generic linker passes name as an
1549 empty string to indicate that no DT_NEEDED entry should be made. */
1551 void
1552 bfd_elf_set_dt_needed_name (abfd, name)
1553 bfd *abfd;
1554 const char *name;
1556 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1557 && bfd_get_format (abfd) == bfd_object)
1558 elf_dt_name (abfd) = name;
1561 void
1562 bfd_elf_set_dt_needed_soname (abfd, name)
1563 bfd *abfd;
1564 const char *name;
1566 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1567 && bfd_get_format (abfd) == bfd_object)
1568 elf_dt_soname (abfd) = name;
1571 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1572 the linker ELF emulation code. */
1574 struct bfd_link_needed_list *
1575 bfd_elf_get_needed_list (abfd, info)
1576 bfd *abfd ATTRIBUTE_UNUSED;
1577 struct bfd_link_info *info;
1579 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1580 return NULL;
1581 return elf_hash_table (info)->needed;
1584 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1585 hook for the linker ELF emulation code. */
1587 struct bfd_link_needed_list *
1588 bfd_elf_get_runpath_list (abfd, info)
1589 bfd *abfd ATTRIBUTE_UNUSED;
1590 struct bfd_link_info *info;
1592 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1593 return NULL;
1594 return elf_hash_table (info)->runpath;
1597 /* Get the name actually used for a dynamic object for a link. This
1598 is the SONAME entry if there is one. Otherwise, it is the string
1599 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1601 const char *
1602 bfd_elf_get_dt_soname (abfd)
1603 bfd *abfd;
1605 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1606 && bfd_get_format (abfd) == bfd_object)
1607 return elf_dt_name (abfd);
1608 return NULL;
1611 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1612 the ELF linker emulation code. */
1614 boolean
1615 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1616 bfd *abfd;
1617 struct bfd_link_needed_list **pneeded;
1619 asection *s;
1620 bfd_byte *dynbuf = NULL;
1621 int elfsec;
1622 unsigned long shlink;
1623 bfd_byte *extdyn, *extdynend;
1624 size_t extdynsize;
1625 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1627 *pneeded = NULL;
1629 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1630 || bfd_get_format (abfd) != bfd_object)
1631 return true;
1633 s = bfd_get_section_by_name (abfd, ".dynamic");
1634 if (s == NULL || s->_raw_size == 0)
1635 return true;
1637 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1638 if (dynbuf == NULL)
1639 goto error_return;
1641 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1642 s->_raw_size))
1643 goto error_return;
1645 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1646 if (elfsec == -1)
1647 goto error_return;
1649 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
1651 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1652 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1654 extdyn = dynbuf;
1655 extdynend = extdyn + s->_raw_size;
1656 for (; extdyn < extdynend; extdyn += extdynsize)
1658 Elf_Internal_Dyn dyn;
1660 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1662 if (dyn.d_tag == DT_NULL)
1663 break;
1665 if (dyn.d_tag == DT_NEEDED)
1667 const char *string;
1668 struct bfd_link_needed_list *l;
1669 unsigned int tagv = dyn.d_un.d_val;
1670 bfd_size_type amt;
1672 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
1673 if (string == NULL)
1674 goto error_return;
1676 amt = sizeof *l;
1677 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, amt);
1678 if (l == NULL)
1679 goto error_return;
1681 l->by = abfd;
1682 l->name = string;
1683 l->next = *pneeded;
1684 *pneeded = l;
1688 free (dynbuf);
1690 return true;
1692 error_return:
1693 if (dynbuf != NULL)
1694 free (dynbuf);
1695 return false;
1698 /* Allocate an ELF string table--force the first byte to be zero. */
1700 struct bfd_strtab_hash *
1701 _bfd_elf_stringtab_init ()
1703 struct bfd_strtab_hash *ret;
1705 ret = _bfd_stringtab_init ();
1706 if (ret != NULL)
1708 bfd_size_type loc;
1710 loc = _bfd_stringtab_add (ret, "", true, false);
1711 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1712 if (loc == (bfd_size_type) -1)
1714 _bfd_stringtab_free (ret);
1715 ret = NULL;
1718 return ret;
1721 /* ELF .o/exec file reading */
1723 /* Create a new bfd section from an ELF section header. */
1725 boolean
1726 bfd_section_from_shdr (abfd, shindex)
1727 bfd *abfd;
1728 unsigned int shindex;
1730 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1731 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1732 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1733 const char *name;
1735 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1737 switch (hdr->sh_type)
1739 case SHT_NULL:
1740 /* Inactive section. Throw it away. */
1741 return true;
1743 case SHT_PROGBITS: /* Normal section with contents. */
1744 case SHT_NOBITS: /* .bss section. */
1745 case SHT_HASH: /* .hash section. */
1746 case SHT_NOTE: /* .note section. */
1747 case SHT_INIT_ARRAY: /* .init_array section. */
1748 case SHT_FINI_ARRAY: /* .fini_array section. */
1749 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
1750 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1752 case SHT_DYNAMIC: /* Dynamic linking information. */
1753 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1754 return false;
1755 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
1757 Elf_Internal_Shdr *dynsymhdr;
1759 /* The shared libraries distributed with hpux11 have a bogus
1760 sh_link field for the ".dynamic" section. Find the
1761 string table for the ".dynsym" section instead. */
1762 if (elf_dynsymtab (abfd) != 0)
1764 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1765 hdr->sh_link = dynsymhdr->sh_link;
1767 else
1769 unsigned int i, num_sec;
1771 num_sec = elf_numsections (abfd);
1772 for (i = 1; i < num_sec; i++)
1774 dynsymhdr = elf_elfsections (abfd)[i];
1775 if (dynsymhdr->sh_type == SHT_DYNSYM)
1777 hdr->sh_link = dynsymhdr->sh_link;
1778 break;
1783 break;
1785 case SHT_SYMTAB: /* A symbol table */
1786 if (elf_onesymtab (abfd) == shindex)
1787 return true;
1789 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1790 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1791 elf_onesymtab (abfd) = shindex;
1792 elf_tdata (abfd)->symtab_hdr = *hdr;
1793 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1794 abfd->flags |= HAS_SYMS;
1796 /* Sometimes a shared object will map in the symbol table. If
1797 SHF_ALLOC is set, and this is a shared object, then we also
1798 treat this section as a BFD section. We can not base the
1799 decision purely on SHF_ALLOC, because that flag is sometimes
1800 set in a relocateable object file, which would confuse the
1801 linker. */
1802 if ((hdr->sh_flags & SHF_ALLOC) != 0
1803 && (abfd->flags & DYNAMIC) != 0
1804 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1805 return false;
1807 return true;
1809 case SHT_DYNSYM: /* A dynamic symbol table */
1810 if (elf_dynsymtab (abfd) == shindex)
1811 return true;
1813 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1814 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1815 elf_dynsymtab (abfd) = shindex;
1816 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1817 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1818 abfd->flags |= HAS_SYMS;
1820 /* Besides being a symbol table, we also treat this as a regular
1821 section, so that objcopy can handle it. */
1822 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1824 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1825 if (elf_symtab_shndx (abfd) == shindex)
1826 return true;
1828 /* Get the associated symbol table. */
1829 if (! bfd_section_from_shdr (abfd, hdr->sh_link)
1830 || hdr->sh_link != elf_onesymtab (abfd))
1831 return false;
1833 elf_symtab_shndx (abfd) = shindex;
1834 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1835 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
1836 return true;
1838 case SHT_STRTAB: /* A string table */
1839 if (hdr->bfd_section != NULL)
1840 return true;
1841 if (ehdr->e_shstrndx == shindex)
1843 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1844 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1845 return true;
1848 unsigned int i, num_sec;
1850 num_sec = elf_numsections (abfd);
1851 for (i = 1; i < num_sec; i++)
1853 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1854 if (hdr2->sh_link == shindex)
1856 if (! bfd_section_from_shdr (abfd, i))
1857 return false;
1858 if (elf_onesymtab (abfd) == i)
1860 elf_tdata (abfd)->strtab_hdr = *hdr;
1861 elf_elfsections (abfd)[shindex] =
1862 &elf_tdata (abfd)->strtab_hdr;
1863 return true;
1865 if (elf_dynsymtab (abfd) == i)
1867 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1868 elf_elfsections (abfd)[shindex] = hdr =
1869 &elf_tdata (abfd)->dynstrtab_hdr;
1870 /* We also treat this as a regular section, so
1871 that objcopy can handle it. */
1872 break;
1874 #if 0 /* Not handling other string tables specially right now. */
1875 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1876 /* We have a strtab for some random other section. */
1877 newsect = (asection *) hdr2->bfd_section;
1878 if (!newsect)
1879 break;
1880 hdr->bfd_section = newsect;
1881 hdr2 = &elf_section_data (newsect)->str_hdr;
1882 *hdr2 = *hdr;
1883 elf_elfsections (abfd)[shindex] = hdr2;
1884 #endif
1889 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1891 case SHT_REL:
1892 case SHT_RELA:
1893 /* *These* do a lot of work -- but build no sections! */
1895 asection *target_sect;
1896 Elf_Internal_Shdr *hdr2;
1897 unsigned int num_sec = elf_numsections (abfd);
1899 /* Check for a bogus link to avoid crashing. */
1900 if ((hdr->sh_link >= SHN_LORESERVE && hdr->sh_link <= SHN_HIRESERVE)
1901 || hdr->sh_link >= num_sec)
1903 ((*_bfd_error_handler)
1904 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1905 bfd_archive_filename (abfd), hdr->sh_link, name, shindex));
1906 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1909 /* For some incomprehensible reason Oracle distributes
1910 libraries for Solaris in which some of the objects have
1911 bogus sh_link fields. It would be nice if we could just
1912 reject them, but, unfortunately, some people need to use
1913 them. We scan through the section headers; if we find only
1914 one suitable symbol table, we clobber the sh_link to point
1915 to it. I hope this doesn't break anything. */
1916 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1917 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1919 unsigned int scan;
1920 int found;
1922 found = 0;
1923 for (scan = 1; scan < num_sec; scan++)
1925 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1926 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1928 if (found != 0)
1930 found = 0;
1931 break;
1933 found = scan;
1936 if (found != 0)
1937 hdr->sh_link = found;
1940 /* Get the symbol table. */
1941 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1942 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1943 return false;
1945 /* If this reloc section does not use the main symbol table we
1946 don't treat it as a reloc section. BFD can't adequately
1947 represent such a section, so at least for now, we don't
1948 try. We just present it as a normal section. We also
1949 can't use it as a reloc section if it points to the null
1950 section. */
1951 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1952 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1954 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1955 return false;
1956 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1957 if (target_sect == NULL)
1958 return false;
1960 if ((target_sect->flags & SEC_RELOC) == 0
1961 || target_sect->reloc_count == 0)
1962 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1963 else
1965 bfd_size_type amt;
1966 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1967 amt = sizeof (*hdr2);
1968 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1969 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1971 *hdr2 = *hdr;
1972 elf_elfsections (abfd)[shindex] = hdr2;
1973 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
1974 target_sect->flags |= SEC_RELOC;
1975 target_sect->relocation = NULL;
1976 target_sect->rel_filepos = hdr->sh_offset;
1977 /* In the section to which the relocations apply, mark whether
1978 its relocations are of the REL or RELA variety. */
1979 if (hdr->sh_size != 0)
1980 elf_section_data (target_sect)->use_rela_p
1981 = (hdr->sh_type == SHT_RELA);
1982 abfd->flags |= HAS_RELOC;
1983 return true;
1985 break;
1987 case SHT_GNU_verdef:
1988 elf_dynverdef (abfd) = shindex;
1989 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1990 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1991 break;
1993 case SHT_GNU_versym:
1994 elf_dynversym (abfd) = shindex;
1995 elf_tdata (abfd)->dynversym_hdr = *hdr;
1996 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1997 break;
1999 case SHT_GNU_verneed:
2000 elf_dynverref (abfd) = shindex;
2001 elf_tdata (abfd)->dynverref_hdr = *hdr;
2002 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
2003 break;
2005 case SHT_SHLIB:
2006 return true;
2008 case SHT_GROUP:
2009 /* We need a BFD section for objcopy and relocatable linking,
2010 and it's handy to have the signature available as the section
2011 name. */
2012 name = group_signature (abfd, hdr);
2013 if (name == NULL)
2014 return false;
2015 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name))
2016 return false;
2017 if (hdr->contents != NULL)
2019 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
2020 unsigned int n_elt = hdr->sh_size / 4;
2021 asection *s;
2023 if (idx->flags & GRP_COMDAT)
2024 hdr->bfd_section->flags
2025 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
2027 while (--n_elt != 0)
2028 if ((s = (++idx)->shdr->bfd_section) != NULL
2029 && elf_next_in_group (s) != NULL)
2031 elf_next_in_group (hdr->bfd_section) = s;
2032 break;
2035 break;
2037 default:
2038 /* Check for any processor-specific section types. */
2040 if (bed->elf_backend_section_from_shdr)
2041 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
2043 break;
2046 return true;
2049 /* Return the section for the local symbol specified by ABFD, R_SYMNDX.
2050 Return SEC for sections that have no elf section, and NULL on error. */
2052 asection *
2053 bfd_section_from_r_symndx (abfd, cache, sec, r_symndx)
2054 bfd *abfd;
2055 struct sym_sec_cache *cache;
2056 asection *sec;
2057 unsigned long r_symndx;
2059 Elf_Internal_Shdr *symtab_hdr;
2060 unsigned char esym[sizeof (Elf64_External_Sym)];
2061 Elf_External_Sym_Shndx eshndx;
2062 Elf_Internal_Sym isym;
2063 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2065 if (cache->abfd == abfd && cache->indx[ent] == r_symndx)
2066 return cache->sec[ent];
2068 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2069 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
2070 &isym, esym, &eshndx) == NULL)
2071 return NULL;
2073 if (cache->abfd != abfd)
2075 memset (cache->indx, -1, sizeof (cache->indx));
2076 cache->abfd = abfd;
2078 cache->indx[ent] = r_symndx;
2079 cache->sec[ent] = sec;
2080 if (isym.st_shndx < SHN_LORESERVE || isym.st_shndx > SHN_HIRESERVE)
2082 asection *s;
2083 s = bfd_section_from_elf_index (abfd, isym.st_shndx);
2084 if (s != NULL)
2085 cache->sec[ent] = s;
2087 return cache->sec[ent];
2090 /* Given an ELF section number, retrieve the corresponding BFD
2091 section. */
2093 asection *
2094 bfd_section_from_elf_index (abfd, index)
2095 bfd *abfd;
2096 unsigned int index;
2098 if (index >= elf_numsections (abfd))
2099 return NULL;
2100 return elf_elfsections (abfd)[index]->bfd_section;
2103 boolean
2104 _bfd_elf_new_section_hook (abfd, sec)
2105 bfd *abfd;
2106 asection *sec;
2108 struct bfd_elf_section_data *sdata;
2109 bfd_size_type amt = sizeof (*sdata);
2111 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, amt);
2112 if (!sdata)
2113 return false;
2114 sec->used_by_bfd = (PTR) sdata;
2116 /* Indicate whether or not this section should use RELA relocations. */
2117 sdata->use_rela_p
2118 = get_elf_backend_data (abfd)->default_use_rela_p;
2120 return true;
2123 /* Create a new bfd section from an ELF program header.
2125 Since program segments have no names, we generate a synthetic name
2126 of the form segment<NUM>, where NUM is generally the index in the
2127 program header table. For segments that are split (see below) we
2128 generate the names segment<NUM>a and segment<NUM>b.
2130 Note that some program segments may have a file size that is different than
2131 (less than) the memory size. All this means is that at execution the
2132 system must allocate the amount of memory specified by the memory size,
2133 but only initialize it with the first "file size" bytes read from the
2134 file. This would occur for example, with program segments consisting
2135 of combined data+bss.
2137 To handle the above situation, this routine generates TWO bfd sections
2138 for the single program segment. The first has the length specified by
2139 the file size of the segment, and the second has the length specified
2140 by the difference between the two sizes. In effect, the segment is split
2141 into it's initialized and uninitialized parts.
2145 boolean
2146 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
2147 bfd *abfd;
2148 Elf_Internal_Phdr *hdr;
2149 int index;
2150 const char *typename;
2152 asection *newsect;
2153 char *name;
2154 char namebuf[64];
2155 size_t len;
2156 int split;
2158 split = ((hdr->p_memsz > 0)
2159 && (hdr->p_filesz > 0)
2160 && (hdr->p_memsz > hdr->p_filesz));
2161 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2162 len = strlen (namebuf) + 1;
2163 name = bfd_alloc (abfd, (bfd_size_type) len);
2164 if (!name)
2165 return false;
2166 memcpy (name, namebuf, len);
2167 newsect = bfd_make_section (abfd, name);
2168 if (newsect == NULL)
2169 return false;
2170 newsect->vma = hdr->p_vaddr;
2171 newsect->lma = hdr->p_paddr;
2172 newsect->_raw_size = hdr->p_filesz;
2173 newsect->filepos = hdr->p_offset;
2174 newsect->flags |= SEC_HAS_CONTENTS;
2175 if (hdr->p_type == PT_LOAD)
2177 newsect->flags |= SEC_ALLOC;
2178 newsect->flags |= SEC_LOAD;
2179 if (hdr->p_flags & PF_X)
2181 /* FIXME: all we known is that it has execute PERMISSION,
2182 may be data. */
2183 newsect->flags |= SEC_CODE;
2186 if (!(hdr->p_flags & PF_W))
2188 newsect->flags |= SEC_READONLY;
2191 if (split)
2193 sprintf (namebuf, "%s%db", typename, index);
2194 len = strlen (namebuf) + 1;
2195 name = bfd_alloc (abfd, (bfd_size_type) len);
2196 if (!name)
2197 return false;
2198 memcpy (name, namebuf, len);
2199 newsect = bfd_make_section (abfd, name);
2200 if (newsect == NULL)
2201 return false;
2202 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2203 newsect->lma = hdr->p_paddr + hdr->p_filesz;
2204 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
2205 if (hdr->p_type == PT_LOAD)
2207 newsect->flags |= SEC_ALLOC;
2208 if (hdr->p_flags & PF_X)
2209 newsect->flags |= SEC_CODE;
2211 if (!(hdr->p_flags & PF_W))
2212 newsect->flags |= SEC_READONLY;
2215 return true;
2218 boolean
2219 bfd_section_from_phdr (abfd, hdr, index)
2220 bfd *abfd;
2221 Elf_Internal_Phdr *hdr;
2222 int index;
2224 struct elf_backend_data *bed;
2226 switch (hdr->p_type)
2228 case PT_NULL:
2229 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2231 case PT_LOAD:
2232 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2234 case PT_DYNAMIC:
2235 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2237 case PT_INTERP:
2238 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2240 case PT_NOTE:
2241 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
2242 return false;
2243 if (! elfcore_read_notes (abfd, (file_ptr) hdr->p_offset, hdr->p_filesz))
2244 return false;
2245 return true;
2247 case PT_SHLIB:
2248 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2250 case PT_PHDR:
2251 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2253 default:
2254 /* Check for any processor-specific program segment types.
2255 If no handler for them, default to making "segment" sections. */
2256 bed = get_elf_backend_data (abfd);
2257 if (bed->elf_backend_section_from_phdr)
2258 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
2259 else
2260 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
2264 /* Initialize REL_HDR, the section-header for new section, containing
2265 relocations against ASECT. If USE_RELA_P is true, we use RELA
2266 relocations; otherwise, we use REL relocations. */
2268 boolean
2269 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
2270 bfd *abfd;
2271 Elf_Internal_Shdr *rel_hdr;
2272 asection *asect;
2273 boolean use_rela_p;
2275 char *name;
2276 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2277 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
2279 name = bfd_alloc (abfd, amt);
2280 if (name == NULL)
2281 return false;
2282 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2283 rel_hdr->sh_name =
2284 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
2285 false);
2286 if (rel_hdr->sh_name == (unsigned int) -1)
2287 return false;
2288 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2289 rel_hdr->sh_entsize = (use_rela_p
2290 ? bed->s->sizeof_rela
2291 : bed->s->sizeof_rel);
2292 rel_hdr->sh_addralign = bed->s->file_align;
2293 rel_hdr->sh_flags = 0;
2294 rel_hdr->sh_addr = 0;
2295 rel_hdr->sh_size = 0;
2296 rel_hdr->sh_offset = 0;
2298 return true;
2301 /* Set up an ELF internal section header for a section. */
2303 static void
2304 elf_fake_sections (abfd, asect, failedptrarg)
2305 bfd *abfd;
2306 asection *asect;
2307 PTR failedptrarg;
2309 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2310 boolean *failedptr = (boolean *) failedptrarg;
2311 Elf_Internal_Shdr *this_hdr;
2313 if (*failedptr)
2315 /* We already failed; just get out of the bfd_map_over_sections
2316 loop. */
2317 return;
2320 this_hdr = &elf_section_data (asect)->this_hdr;
2322 this_hdr->sh_name = (unsigned long) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2323 asect->name, false);
2324 if (this_hdr->sh_name == (unsigned long) -1)
2326 *failedptr = true;
2327 return;
2330 this_hdr->sh_flags = 0;
2332 if ((asect->flags & SEC_ALLOC) != 0
2333 || asect->user_set_vma)
2334 this_hdr->sh_addr = asect->vma;
2335 else
2336 this_hdr->sh_addr = 0;
2338 this_hdr->sh_offset = 0;
2339 this_hdr->sh_size = asect->_raw_size;
2340 this_hdr->sh_link = 0;
2341 this_hdr->sh_addralign = 1 << asect->alignment_power;
2342 /* The sh_entsize and sh_info fields may have been set already by
2343 copy_private_section_data. */
2345 this_hdr->bfd_section = asect;
2346 this_hdr->contents = NULL;
2348 /* FIXME: This should not be based on section names. */
2349 if (strcmp (asect->name, ".dynstr") == 0)
2350 this_hdr->sh_type = SHT_STRTAB;
2351 else if (strcmp (asect->name, ".hash") == 0)
2353 this_hdr->sh_type = SHT_HASH;
2354 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2356 else if (strcmp (asect->name, ".dynsym") == 0)
2358 this_hdr->sh_type = SHT_DYNSYM;
2359 this_hdr->sh_entsize = bed->s->sizeof_sym;
2361 else if (strcmp (asect->name, ".dynamic") == 0)
2363 this_hdr->sh_type = SHT_DYNAMIC;
2364 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2366 else if (strncmp (asect->name, ".rela", 5) == 0
2367 && get_elf_backend_data (abfd)->may_use_rela_p)
2369 this_hdr->sh_type = SHT_RELA;
2370 this_hdr->sh_entsize = bed->s->sizeof_rela;
2372 else if (strncmp (asect->name, ".rel", 4) == 0
2373 && get_elf_backend_data (abfd)->may_use_rel_p)
2375 this_hdr->sh_type = SHT_REL;
2376 this_hdr->sh_entsize = bed->s->sizeof_rel;
2378 else if (strcmp (asect->name, ".init_array") == 0)
2379 this_hdr->sh_type = SHT_INIT_ARRAY;
2380 else if (strcmp (asect->name, ".fini_array") == 0)
2381 this_hdr->sh_type = SHT_FINI_ARRAY;
2382 else if (strcmp (asect->name, ".preinit_array") == 0)
2383 this_hdr->sh_type = SHT_PREINIT_ARRAY;
2384 else if (strncmp (asect->name, ".note", 5) == 0)
2385 this_hdr->sh_type = SHT_NOTE;
2386 else if (strncmp (asect->name, ".stab", 5) == 0
2387 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
2388 this_hdr->sh_type = SHT_STRTAB;
2389 else if (strcmp (asect->name, ".gnu.version") == 0)
2391 this_hdr->sh_type = SHT_GNU_versym;
2392 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2394 else if (strcmp (asect->name, ".gnu.version_d") == 0)
2396 this_hdr->sh_type = SHT_GNU_verdef;
2397 this_hdr->sh_entsize = 0;
2398 /* objcopy or strip will copy over sh_info, but may not set
2399 cverdefs. The linker will set cverdefs, but sh_info will be
2400 zero. */
2401 if (this_hdr->sh_info == 0)
2402 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2403 else
2404 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2405 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2407 else if (strcmp (asect->name, ".gnu.version_r") == 0)
2409 this_hdr->sh_type = SHT_GNU_verneed;
2410 this_hdr->sh_entsize = 0;
2411 /* objcopy or strip will copy over sh_info, but may not set
2412 cverrefs. The linker will set cverrefs, but sh_info will be
2413 zero. */
2414 if (this_hdr->sh_info == 0)
2415 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2416 else
2417 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2418 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2420 else if ((asect->flags & SEC_GROUP) != 0)
2422 this_hdr->sh_type = SHT_GROUP;
2423 this_hdr->sh_entsize = 4;
2425 else if ((asect->flags & SEC_ALLOC) != 0
2426 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2427 || (asect->flags & SEC_NEVER_LOAD) != 0))
2428 this_hdr->sh_type = SHT_NOBITS;
2429 else
2430 this_hdr->sh_type = SHT_PROGBITS;
2432 if ((asect->flags & SEC_ALLOC) != 0)
2433 this_hdr->sh_flags |= SHF_ALLOC;
2434 if ((asect->flags & SEC_READONLY) == 0)
2435 this_hdr->sh_flags |= SHF_WRITE;
2436 if ((asect->flags & SEC_CODE) != 0)
2437 this_hdr->sh_flags |= SHF_EXECINSTR;
2438 if ((asect->flags & SEC_MERGE) != 0)
2440 this_hdr->sh_flags |= SHF_MERGE;
2441 this_hdr->sh_entsize = asect->entsize;
2442 if ((asect->flags & SEC_STRINGS) != 0)
2443 this_hdr->sh_flags |= SHF_STRINGS;
2445 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
2446 this_hdr->sh_flags |= SHF_GROUP;
2447 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
2449 this_hdr->sh_flags |= SHF_TLS;
2450 if (asect->_raw_size == 0 && (asect->flags & SEC_HAS_CONTENTS) == 0)
2452 struct bfd_link_order *o;
2454 this_hdr->sh_size = 0;
2455 for (o = asect->link_order_head; o != NULL; o = o->next)
2456 if (this_hdr->sh_size < o->offset + o->size)
2457 this_hdr->sh_size = o->offset + o->size;
2458 if (this_hdr->sh_size)
2459 this_hdr->sh_type = SHT_NOBITS;
2463 /* Check for processor-specific section types. */
2464 if (bed->elf_backend_fake_sections
2465 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
2466 *failedptr = true;
2468 /* If the section has relocs, set up a section header for the
2469 SHT_REL[A] section. If two relocation sections are required for
2470 this section, it is up to the processor-specific back-end to
2471 create the other. */
2472 if ((asect->flags & SEC_RELOC) != 0
2473 && !_bfd_elf_init_reloc_shdr (abfd,
2474 &elf_section_data (asect)->rel_hdr,
2475 asect,
2476 elf_section_data (asect)->use_rela_p))
2477 *failedptr = true;
2480 /* Fill in the contents of a SHT_GROUP section. */
2482 void
2483 bfd_elf_set_group_contents (abfd, sec, failedptrarg)
2484 bfd *abfd;
2485 asection *sec;
2486 PTR failedptrarg;
2488 boolean *failedptr = (boolean *) failedptrarg;
2489 unsigned long symindx;
2490 asection *elt, *first;
2491 unsigned char *loc;
2492 struct bfd_link_order *l;
2493 boolean gas;
2495 if (elf_section_data (sec)->this_hdr.sh_type != SHT_GROUP
2496 || *failedptr)
2497 return;
2499 symindx = 0;
2500 if (elf_group_id (sec) != NULL)
2501 symindx = elf_group_id (sec)->udata.i;
2503 if (symindx == 0)
2505 /* If called from the assembler, swap_out_syms will have set up
2506 elf_section_syms; If called for "ld -r", use target_index. */
2507 if (elf_section_syms (abfd) != NULL)
2508 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2509 else
2510 symindx = sec->target_index;
2512 elf_section_data (sec)->this_hdr.sh_info = symindx;
2514 /* The contents won't be allocated for "ld -r" or objcopy. */
2515 gas = true;
2516 if (sec->contents == NULL)
2518 gas = false;
2519 sec->contents = bfd_alloc (abfd, sec->_raw_size);
2521 /* Arrange for the section to be written out. */
2522 elf_section_data (sec)->this_hdr.contents = sec->contents;
2523 if (sec->contents == NULL)
2525 *failedptr = true;
2526 return;
2530 loc = sec->contents + sec->_raw_size;
2532 /* Get the pointer to the first section in the group that gas
2533 squirreled away here. objcopy arranges for this to be set to the
2534 start of the input section group. */
2535 first = elt = elf_next_in_group (sec);
2537 /* First element is a flag word. Rest of section is elf section
2538 indices for all the sections of the group. Write them backwards
2539 just to keep the group in the same order as given in .section
2540 directives, not that it matters. */
2541 while (elt != NULL)
2543 asection *s;
2544 unsigned int idx;
2546 loc -= 4;
2547 s = elt;
2548 if (!gas)
2549 s = s->output_section;
2550 idx = 0;
2551 if (s != NULL)
2552 idx = elf_section_data (s)->this_idx;
2553 H_PUT_32 (abfd, idx, loc);
2554 elt = elf_next_in_group (elt);
2555 if (elt == first)
2556 break;
2559 /* If this is a relocatable link, then the above did nothing because
2560 SEC is the output section. Look through the input sections
2561 instead. */
2562 for (l = sec->link_order_head; l != NULL; l = l->next)
2563 if (l->type == bfd_indirect_link_order
2564 && (elt = elf_next_in_group (l->u.indirect.section)) != NULL)
2567 loc -= 4;
2568 H_PUT_32 (abfd,
2569 elf_section_data (elt->output_section)->this_idx, loc);
2570 elt = elf_next_in_group (elt);
2571 /* During a relocatable link, the lists are circular. */
2573 while (elt != elf_next_in_group (l->u.indirect.section));
2575 /* With ld -r, merging SHT_GROUP sections results in wasted space
2576 due to allowing for the flag word on each input. We may well
2577 duplicate entries too. */
2578 while ((loc -= 4) > sec->contents)
2579 H_PUT_32 (abfd, 0, loc);
2581 if (loc != sec->contents)
2582 abort ();
2584 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
2587 /* Assign all ELF section numbers. The dummy first section is handled here
2588 too. The link/info pointers for the standard section types are filled
2589 in here too, while we're at it. */
2591 static boolean
2592 assign_section_numbers (abfd)
2593 bfd *abfd;
2595 struct elf_obj_tdata *t = elf_tdata (abfd);
2596 asection *sec;
2597 unsigned int section_number, secn;
2598 Elf_Internal_Shdr **i_shdrp;
2599 bfd_size_type amt;
2601 section_number = 1;
2603 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2605 for (sec = abfd->sections; sec; sec = sec->next)
2607 struct bfd_elf_section_data *d = elf_section_data (sec);
2609 if (section_number == SHN_LORESERVE)
2610 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2611 d->this_idx = section_number++;
2612 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
2613 if ((sec->flags & SEC_RELOC) == 0)
2614 d->rel_idx = 0;
2615 else
2617 if (section_number == SHN_LORESERVE)
2618 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2619 d->rel_idx = section_number++;
2620 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2623 if (d->rel_hdr2)
2625 if (section_number == SHN_LORESERVE)
2626 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2627 d->rel_idx2 = section_number++;
2628 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2630 else
2631 d->rel_idx2 = 0;
2634 if (section_number == SHN_LORESERVE)
2635 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2636 t->shstrtab_section = section_number++;
2637 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
2638 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
2640 if (bfd_get_symcount (abfd) > 0)
2642 if (section_number == SHN_LORESERVE)
2643 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2644 t->symtab_section = section_number++;
2645 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
2646 if (section_number > SHN_LORESERVE - 2)
2648 if (section_number == SHN_LORESERVE)
2649 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2650 t->symtab_shndx_section = section_number++;
2651 t->symtab_shndx_hdr.sh_name
2652 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2653 ".symtab_shndx", false);
2654 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
2655 return false;
2657 if (section_number == SHN_LORESERVE)
2658 section_number += SHN_HIRESERVE + 1 - SHN_LORESERVE;
2659 t->strtab_section = section_number++;
2660 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
2663 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2664 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
2666 elf_numsections (abfd) = section_number;
2667 elf_elfheader (abfd)->e_shnum = section_number;
2668 if (section_number > SHN_LORESERVE)
2669 elf_elfheader (abfd)->e_shnum -= SHN_HIRESERVE + 1 - SHN_LORESERVE;
2671 /* Set up the list of section header pointers, in agreement with the
2672 indices. */
2673 amt = section_number * sizeof (Elf_Internal_Shdr *);
2674 i_shdrp = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
2675 if (i_shdrp == NULL)
2676 return false;
2678 amt = sizeof (Elf_Internal_Shdr);
2679 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
2680 if (i_shdrp[0] == NULL)
2682 bfd_release (abfd, i_shdrp);
2683 return false;
2685 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
2687 elf_elfsections (abfd) = i_shdrp;
2689 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2690 if (bfd_get_symcount (abfd) > 0)
2692 i_shdrp[t->symtab_section] = &t->symtab_hdr;
2693 if (elf_numsections (abfd) > SHN_LORESERVE)
2695 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2696 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2698 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2699 t->symtab_hdr.sh_link = t->strtab_section;
2701 for (sec = abfd->sections; sec; sec = sec->next)
2703 struct bfd_elf_section_data *d = elf_section_data (sec);
2704 asection *s;
2705 const char *name;
2707 i_shdrp[d->this_idx] = &d->this_hdr;
2708 if (d->rel_idx != 0)
2709 i_shdrp[d->rel_idx] = &d->rel_hdr;
2710 if (d->rel_idx2 != 0)
2711 i_shdrp[d->rel_idx2] = d->rel_hdr2;
2713 /* Fill in the sh_link and sh_info fields while we're at it. */
2715 /* sh_link of a reloc section is the section index of the symbol
2716 table. sh_info is the section index of the section to which
2717 the relocation entries apply. */
2718 if (d->rel_idx != 0)
2720 d->rel_hdr.sh_link = t->symtab_section;
2721 d->rel_hdr.sh_info = d->this_idx;
2723 if (d->rel_idx2 != 0)
2725 d->rel_hdr2->sh_link = t->symtab_section;
2726 d->rel_hdr2->sh_info = d->this_idx;
2729 switch (d->this_hdr.sh_type)
2731 case SHT_REL:
2732 case SHT_RELA:
2733 /* A reloc section which we are treating as a normal BFD
2734 section. sh_link is the section index of the symbol
2735 table. sh_info is the section index of the section to
2736 which the relocation entries apply. We assume that an
2737 allocated reloc section uses the dynamic symbol table.
2738 FIXME: How can we be sure? */
2739 s = bfd_get_section_by_name (abfd, ".dynsym");
2740 if (s != NULL)
2741 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2743 /* We look up the section the relocs apply to by name. */
2744 name = sec->name;
2745 if (d->this_hdr.sh_type == SHT_REL)
2746 name += 4;
2747 else
2748 name += 5;
2749 s = bfd_get_section_by_name (abfd, name);
2750 if (s != NULL)
2751 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2752 break;
2754 case SHT_STRTAB:
2755 /* We assume that a section named .stab*str is a stabs
2756 string section. We look for a section with the same name
2757 but without the trailing ``str'', and set its sh_link
2758 field to point to this section. */
2759 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
2760 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
2762 size_t len;
2763 char *alc;
2765 len = strlen (sec->name);
2766 alc = (char *) bfd_malloc ((bfd_size_type) (len - 2));
2767 if (alc == NULL)
2768 return false;
2769 memcpy (alc, sec->name, len - 3);
2770 alc[len - 3] = '\0';
2771 s = bfd_get_section_by_name (abfd, alc);
2772 free (alc);
2773 if (s != NULL)
2775 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
2777 /* This is a .stab section. */
2778 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
2779 elf_section_data (s)->this_hdr.sh_entsize
2780 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
2783 break;
2785 case SHT_DYNAMIC:
2786 case SHT_DYNSYM:
2787 case SHT_GNU_verneed:
2788 case SHT_GNU_verdef:
2789 /* sh_link is the section header index of the string table
2790 used for the dynamic entries, or the symbol table, or the
2791 version strings. */
2792 s = bfd_get_section_by_name (abfd, ".dynstr");
2793 if (s != NULL)
2794 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2795 break;
2797 case SHT_HASH:
2798 case SHT_GNU_versym:
2799 /* sh_link is the section header index of the symbol table
2800 this hash table or version table is for. */
2801 s = bfd_get_section_by_name (abfd, ".dynsym");
2802 if (s != NULL)
2803 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2804 break;
2806 case SHT_GROUP:
2807 d->this_hdr.sh_link = t->symtab_section;
2811 for (secn = 1; secn < section_number; ++secn)
2812 if (i_shdrp[secn] == NULL)
2813 i_shdrp[secn] = i_shdrp[0];
2814 else
2815 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
2816 i_shdrp[secn]->sh_name);
2817 return true;
2820 /* Map symbol from it's internal number to the external number, moving
2821 all local symbols to be at the head of the list. */
2823 static INLINE int
2824 sym_is_global (abfd, sym)
2825 bfd *abfd;
2826 asymbol *sym;
2828 /* If the backend has a special mapping, use it. */
2829 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2830 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2831 (abfd, sym));
2833 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2834 || bfd_is_und_section (bfd_get_section (sym))
2835 || bfd_is_com_section (bfd_get_section (sym)));
2838 static boolean
2839 elf_map_symbols (abfd)
2840 bfd *abfd;
2842 unsigned int symcount = bfd_get_symcount (abfd);
2843 asymbol **syms = bfd_get_outsymbols (abfd);
2844 asymbol **sect_syms;
2845 unsigned int num_locals = 0;
2846 unsigned int num_globals = 0;
2847 unsigned int num_locals2 = 0;
2848 unsigned int num_globals2 = 0;
2849 int max_index = 0;
2850 unsigned int idx;
2851 asection *asect;
2852 asymbol **new_syms;
2853 bfd_size_type amt;
2855 #ifdef DEBUG
2856 fprintf (stderr, "elf_map_symbols\n");
2857 fflush (stderr);
2858 #endif
2860 for (asect = abfd->sections; asect; asect = asect->next)
2862 if (max_index < asect->index)
2863 max_index = asect->index;
2866 max_index++;
2867 amt = max_index * sizeof (asymbol *);
2868 sect_syms = (asymbol **) bfd_zalloc (abfd, amt);
2869 if (sect_syms == NULL)
2870 return false;
2871 elf_section_syms (abfd) = sect_syms;
2872 elf_num_section_syms (abfd) = max_index;
2874 /* Init sect_syms entries for any section symbols we have already
2875 decided to output. */
2876 for (idx = 0; idx < symcount; idx++)
2878 asymbol *sym = syms[idx];
2880 if ((sym->flags & BSF_SECTION_SYM) != 0
2881 && sym->value == 0)
2883 asection *sec;
2885 sec = sym->section;
2887 if (sec->owner != NULL)
2889 if (sec->owner != abfd)
2891 if (sec->output_offset != 0)
2892 continue;
2894 sec = sec->output_section;
2896 /* Empty sections in the input files may have had a
2897 section symbol created for them. (See the comment
2898 near the end of _bfd_generic_link_output_symbols in
2899 linker.c). If the linker script discards such
2900 sections then we will reach this point. Since we know
2901 that we cannot avoid this case, we detect it and skip
2902 the abort and the assignment to the sect_syms array.
2903 To reproduce this particular case try running the
2904 linker testsuite test ld-scripts/weak.exp for an ELF
2905 port that uses the generic linker. */
2906 if (sec->owner == NULL)
2907 continue;
2909 BFD_ASSERT (sec->owner == abfd);
2911 sect_syms[sec->index] = syms[idx];
2916 /* Classify all of the symbols. */
2917 for (idx = 0; idx < symcount; idx++)
2919 if (!sym_is_global (abfd, syms[idx]))
2920 num_locals++;
2921 else
2922 num_globals++;
2925 /* We will be adding a section symbol for each BFD section. Most normal
2926 sections will already have a section symbol in outsymbols, but
2927 eg. SHT_GROUP sections will not, and we need the section symbol mapped
2928 at least in that case. */
2929 for (asect = abfd->sections; asect; asect = asect->next)
2931 if (sect_syms[asect->index] == NULL)
2933 if (!sym_is_global (abfd, asect->symbol))
2934 num_locals++;
2935 else
2936 num_globals++;
2940 /* Now sort the symbols so the local symbols are first. */
2941 amt = (num_locals + num_globals) * sizeof (asymbol *);
2942 new_syms = (asymbol **) bfd_alloc (abfd, amt);
2944 if (new_syms == NULL)
2945 return false;
2947 for (idx = 0; idx < symcount; idx++)
2949 asymbol *sym = syms[idx];
2950 unsigned int i;
2952 if (!sym_is_global (abfd, sym))
2953 i = num_locals2++;
2954 else
2955 i = num_locals + num_globals2++;
2956 new_syms[i] = sym;
2957 sym->udata.i = i + 1;
2959 for (asect = abfd->sections; asect; asect = asect->next)
2961 if (sect_syms[asect->index] == NULL)
2963 asymbol *sym = asect->symbol;
2964 unsigned int i;
2966 sect_syms[asect->index] = sym;
2967 if (!sym_is_global (abfd, sym))
2968 i = num_locals2++;
2969 else
2970 i = num_locals + num_globals2++;
2971 new_syms[i] = sym;
2972 sym->udata.i = i + 1;
2976 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2978 elf_num_locals (abfd) = num_locals;
2979 elf_num_globals (abfd) = num_globals;
2980 return true;
2983 /* Align to the maximum file alignment that could be required for any
2984 ELF data structure. */
2986 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2987 static INLINE file_ptr
2988 align_file_position (off, align)
2989 file_ptr off;
2990 int align;
2992 return (off + align - 1) & ~(align - 1);
2995 /* Assign a file position to a section, optionally aligning to the
2996 required section alignment. */
2998 INLINE file_ptr
2999 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
3000 Elf_Internal_Shdr *i_shdrp;
3001 file_ptr offset;
3002 boolean align;
3004 if (align)
3006 unsigned int al;
3008 al = i_shdrp->sh_addralign;
3009 if (al > 1)
3010 offset = BFD_ALIGN (offset, al);
3012 i_shdrp->sh_offset = offset;
3013 if (i_shdrp->bfd_section != NULL)
3014 i_shdrp->bfd_section->filepos = offset;
3015 if (i_shdrp->sh_type != SHT_NOBITS)
3016 offset += i_shdrp->sh_size;
3017 return offset;
3020 /* Compute the file positions we are going to put the sections at, and
3021 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3022 is not NULL, this is being called by the ELF backend linker. */
3024 boolean
3025 _bfd_elf_compute_section_file_positions (abfd, link_info)
3026 bfd *abfd;
3027 struct bfd_link_info *link_info;
3029 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3030 boolean failed;
3031 struct bfd_strtab_hash *strtab;
3032 Elf_Internal_Shdr *shstrtab_hdr;
3034 if (abfd->output_has_begun)
3035 return true;
3037 /* Do any elf backend specific processing first. */
3038 if (bed->elf_backend_begin_write_processing)
3039 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3041 if (! prep_headers (abfd))
3042 return false;
3044 /* Post process the headers if necessary. */
3045 if (bed->elf_backend_post_process_headers)
3046 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3048 failed = false;
3049 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3050 if (failed)
3051 return false;
3053 if (!assign_section_numbers (abfd))
3054 return false;
3056 /* The backend linker builds symbol table information itself. */
3057 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3059 /* Non-zero if doing a relocatable link. */
3060 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3062 if (! swap_out_syms (abfd, &strtab, relocatable_p))
3063 return false;
3066 if (link_info == NULL)
3068 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
3069 if (failed)
3070 return false;
3073 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3074 /* sh_name was set in prep_headers. */
3075 shstrtab_hdr->sh_type = SHT_STRTAB;
3076 shstrtab_hdr->sh_flags = 0;
3077 shstrtab_hdr->sh_addr = 0;
3078 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
3079 shstrtab_hdr->sh_entsize = 0;
3080 shstrtab_hdr->sh_link = 0;
3081 shstrtab_hdr->sh_info = 0;
3082 /* sh_offset is set in assign_file_positions_except_relocs. */
3083 shstrtab_hdr->sh_addralign = 1;
3085 if (!assign_file_positions_except_relocs (abfd))
3086 return false;
3088 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3090 file_ptr off;
3091 Elf_Internal_Shdr *hdr;
3093 off = elf_tdata (abfd)->next_file_pos;
3095 hdr = &elf_tdata (abfd)->symtab_hdr;
3096 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3098 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3099 if (hdr->sh_size != 0)
3100 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3102 hdr = &elf_tdata (abfd)->strtab_hdr;
3103 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3105 elf_tdata (abfd)->next_file_pos = off;
3107 /* Now that we know where the .strtab section goes, write it
3108 out. */
3109 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3110 || ! _bfd_stringtab_emit (abfd, strtab))
3111 return false;
3112 _bfd_stringtab_free (strtab);
3115 abfd->output_has_begun = true;
3117 return true;
3120 /* Create a mapping from a set of sections to a program segment. */
3122 static INLINE struct elf_segment_map *
3123 make_mapping (abfd, sections, from, to, phdr)
3124 bfd *abfd;
3125 asection **sections;
3126 unsigned int from;
3127 unsigned int to;
3128 boolean phdr;
3130 struct elf_segment_map *m;
3131 unsigned int i;
3132 asection **hdrpp;
3133 bfd_size_type amt;
3135 amt = sizeof (struct elf_segment_map);
3136 amt += (to - from - 1) * sizeof (asection *);
3137 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3138 if (m == NULL)
3139 return NULL;
3140 m->next = NULL;
3141 m->p_type = PT_LOAD;
3142 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3143 m->sections[i - from] = *hdrpp;
3144 m->count = to - from;
3146 if (from == 0 && phdr)
3148 /* Include the headers in the first PT_LOAD segment. */
3149 m->includes_filehdr = 1;
3150 m->includes_phdrs = 1;
3153 return m;
3156 /* Set up a mapping from BFD sections to program segments. */
3158 static boolean
3159 map_sections_to_segments (abfd)
3160 bfd *abfd;
3162 asection **sections = NULL;
3163 asection *s;
3164 unsigned int i;
3165 unsigned int count;
3166 struct elf_segment_map *mfirst;
3167 struct elf_segment_map **pm;
3168 struct elf_segment_map *m;
3169 asection *last_hdr;
3170 unsigned int phdr_index;
3171 bfd_vma maxpagesize;
3172 asection **hdrpp;
3173 boolean phdr_in_segment = true;
3174 boolean writable;
3175 int tls_count = 0;
3176 asection *first_tls = NULL;
3177 asection *dynsec, *eh_frame_hdr;
3178 bfd_size_type amt;
3180 if (elf_tdata (abfd)->segment_map != NULL)
3181 return true;
3183 if (bfd_count_sections (abfd) == 0)
3184 return true;
3186 /* Select the allocated sections, and sort them. */
3188 amt = bfd_count_sections (abfd) * sizeof (asection *);
3189 sections = (asection **) bfd_malloc (amt);
3190 if (sections == NULL)
3191 goto error_return;
3193 i = 0;
3194 for (s = abfd->sections; s != NULL; s = s->next)
3196 if ((s->flags & SEC_ALLOC) != 0)
3198 sections[i] = s;
3199 ++i;
3202 BFD_ASSERT (i <= bfd_count_sections (abfd));
3203 count = i;
3205 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
3207 /* Build the mapping. */
3209 mfirst = NULL;
3210 pm = &mfirst;
3212 /* If we have a .interp section, then create a PT_PHDR segment for
3213 the program headers and a PT_INTERP segment for the .interp
3214 section. */
3215 s = bfd_get_section_by_name (abfd, ".interp");
3216 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3218 amt = sizeof (struct elf_segment_map);
3219 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3220 if (m == NULL)
3221 goto error_return;
3222 m->next = NULL;
3223 m->p_type = PT_PHDR;
3224 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3225 m->p_flags = PF_R | PF_X;
3226 m->p_flags_valid = 1;
3227 m->includes_phdrs = 1;
3229 *pm = m;
3230 pm = &m->next;
3232 amt = sizeof (struct elf_segment_map);
3233 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3234 if (m == NULL)
3235 goto error_return;
3236 m->next = NULL;
3237 m->p_type = PT_INTERP;
3238 m->count = 1;
3239 m->sections[0] = s;
3241 *pm = m;
3242 pm = &m->next;
3245 /* Look through the sections. We put sections in the same program
3246 segment when the start of the second section can be placed within
3247 a few bytes of the end of the first section. */
3248 last_hdr = NULL;
3249 phdr_index = 0;
3250 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
3251 writable = false;
3252 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3253 if (dynsec != NULL
3254 && (dynsec->flags & SEC_LOAD) == 0)
3255 dynsec = NULL;
3257 /* Deal with -Ttext or something similar such that the first section
3258 is not adjacent to the program headers. This is an
3259 approximation, since at this point we don't know exactly how many
3260 program headers we will need. */
3261 if (count > 0)
3263 bfd_size_type phdr_size;
3265 phdr_size = elf_tdata (abfd)->program_header_size;
3266 if (phdr_size == 0)
3267 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
3268 if ((abfd->flags & D_PAGED) == 0
3269 || sections[0]->lma < phdr_size
3270 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3271 phdr_in_segment = false;
3274 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
3276 asection *hdr;
3277 boolean new_segment;
3279 hdr = *hdrpp;
3281 /* See if this section and the last one will fit in the same
3282 segment. */
3284 if (last_hdr == NULL)
3286 /* If we don't have a segment yet, then we don't need a new
3287 one (we build the last one after this loop). */
3288 new_segment = false;
3290 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3292 /* If this section has a different relation between the
3293 virtual address and the load address, then we need a new
3294 segment. */
3295 new_segment = true;
3297 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
3298 < BFD_ALIGN (hdr->lma, maxpagesize))
3300 /* If putting this section in this segment would force us to
3301 skip a page in the segment, then we need a new segment. */
3302 new_segment = true;
3304 else if ((last_hdr->flags & SEC_LOAD) == 0
3305 && (hdr->flags & SEC_LOAD) != 0)
3307 /* We don't want to put a loadable section after a
3308 nonloadable section in the same segment. */
3309 new_segment = true;
3311 else if ((abfd->flags & D_PAGED) == 0)
3313 /* If the file is not demand paged, which means that we
3314 don't require the sections to be correctly aligned in the
3315 file, then there is no other reason for a new segment. */
3316 new_segment = false;
3318 else if (! writable
3319 && (hdr->flags & SEC_READONLY) == 0
3320 && (((last_hdr->lma + last_hdr->_raw_size - 1)
3321 & ~(maxpagesize - 1))
3322 != (hdr->lma & ~(maxpagesize - 1))))
3324 /* We don't want to put a writable section in a read only
3325 segment, unless they are on the same page in memory
3326 anyhow. We already know that the last section does not
3327 bring us past the current section on the page, so the
3328 only case in which the new section is not on the same
3329 page as the previous section is when the previous section
3330 ends precisely on a page boundary. */
3331 new_segment = true;
3333 else
3335 /* Otherwise, we can use the same segment. */
3336 new_segment = false;
3339 if (! new_segment)
3341 if ((hdr->flags & SEC_READONLY) == 0)
3342 writable = true;
3343 last_hdr = hdr;
3344 continue;
3347 /* We need a new program segment. We must create a new program
3348 header holding all the sections from phdr_index until hdr. */
3350 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3351 if (m == NULL)
3352 goto error_return;
3354 *pm = m;
3355 pm = &m->next;
3357 if ((hdr->flags & SEC_READONLY) == 0)
3358 writable = true;
3359 else
3360 writable = false;
3362 last_hdr = hdr;
3363 phdr_index = i;
3364 phdr_in_segment = false;
3367 /* Create a final PT_LOAD program segment. */
3368 if (last_hdr != NULL)
3370 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3371 if (m == NULL)
3372 goto error_return;
3374 *pm = m;
3375 pm = &m->next;
3378 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3379 if (dynsec != NULL)
3381 amt = sizeof (struct elf_segment_map);
3382 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3383 if (m == NULL)
3384 goto error_return;
3385 m->next = NULL;
3386 m->p_type = PT_DYNAMIC;
3387 m->count = 1;
3388 m->sections[0] = dynsec;
3390 *pm = m;
3391 pm = &m->next;
3394 /* For each loadable .note section, add a PT_NOTE segment. We don't
3395 use bfd_get_section_by_name, because if we link together
3396 nonloadable .note sections and loadable .note sections, we will
3397 generate two .note sections in the output file. FIXME: Using
3398 names for section types is bogus anyhow. */
3399 for (s = abfd->sections; s != NULL; s = s->next)
3401 if ((s->flags & SEC_LOAD) != 0
3402 && strncmp (s->name, ".note", 5) == 0)
3404 amt = sizeof (struct elf_segment_map);
3405 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3406 if (m == NULL)
3407 goto error_return;
3408 m->next = NULL;
3409 m->p_type = PT_NOTE;
3410 m->count = 1;
3411 m->sections[0] = s;
3413 *pm = m;
3414 pm = &m->next;
3416 if (s->flags & SEC_THREAD_LOCAL)
3418 if (! tls_count)
3419 first_tls = s;
3420 tls_count++;
3424 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3425 if (tls_count > 0)
3427 int i;
3429 amt = sizeof (struct elf_segment_map);
3430 amt += (tls_count - 1) * sizeof (asection *);
3431 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3432 if (m == NULL)
3433 goto error_return;
3434 m->next = NULL;
3435 m->p_type = PT_TLS;
3436 m->count = tls_count;
3437 /* Mandated PF_R. */
3438 m->p_flags = PF_R;
3439 m->p_flags_valid = 1;
3440 for (i = 0; i < tls_count; ++i)
3442 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3443 m->sections[i] = first_tls;
3444 first_tls = first_tls->next;
3447 *pm = m;
3448 pm = &m->next;
3451 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3452 segment. */
3453 eh_frame_hdr = NULL;
3454 if (elf_tdata (abfd)->eh_frame_hdr)
3455 eh_frame_hdr = bfd_get_section_by_name (abfd, ".eh_frame_hdr");
3456 if (eh_frame_hdr != NULL && (eh_frame_hdr->flags & SEC_LOAD))
3458 amt = sizeof (struct elf_segment_map);
3459 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
3460 if (m == NULL)
3461 goto error_return;
3462 m->next = NULL;
3463 m->p_type = PT_GNU_EH_FRAME;
3464 m->count = 1;
3465 m->sections[0] = eh_frame_hdr;
3467 *pm = m;
3468 pm = &m->next;
3471 free (sections);
3472 sections = NULL;
3474 elf_tdata (abfd)->segment_map = mfirst;
3475 return true;
3477 error_return:
3478 if (sections != NULL)
3479 free (sections);
3480 return false;
3483 /* Sort sections by address. */
3485 static int
3486 elf_sort_sections (arg1, arg2)
3487 const PTR arg1;
3488 const PTR arg2;
3490 const asection *sec1 = *(const asection **) arg1;
3491 const asection *sec2 = *(const asection **) arg2;
3493 /* Sort by LMA first, since this is the address used to
3494 place the section into a segment. */
3495 if (sec1->lma < sec2->lma)
3496 return -1;
3497 else if (sec1->lma > sec2->lma)
3498 return 1;
3500 /* Then sort by VMA. Normally the LMA and the VMA will be
3501 the same, and this will do nothing. */
3502 if (sec1->vma < sec2->vma)
3503 return -1;
3504 else if (sec1->vma > sec2->vma)
3505 return 1;
3507 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
3509 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
3511 if (TOEND (sec1))
3513 if (TOEND (sec2))
3515 /* If the indicies are the same, do not return 0
3516 here, but continue to try the next comparison. */
3517 if (sec1->target_index - sec2->target_index != 0)
3518 return sec1->target_index - sec2->target_index;
3520 else
3521 return 1;
3523 else if (TOEND (sec2))
3524 return -1;
3526 #undef TOEND
3528 /* Sort by size, to put zero sized sections
3529 before others at the same address. */
3531 if (sec1->_raw_size < sec2->_raw_size)
3532 return -1;
3533 if (sec1->_raw_size > sec2->_raw_size)
3534 return 1;
3536 return sec1->target_index - sec2->target_index;
3539 /* Assign file positions to the sections based on the mapping from
3540 sections to segments. This function also sets up some fields in
3541 the file header, and writes out the program headers. */
3543 static boolean
3544 assign_file_positions_for_segments (abfd)
3545 bfd *abfd;
3547 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3548 unsigned int count;
3549 struct elf_segment_map *m;
3550 unsigned int alloc;
3551 Elf_Internal_Phdr *phdrs;
3552 file_ptr off, voff;
3553 bfd_vma filehdr_vaddr, filehdr_paddr;
3554 bfd_vma phdrs_vaddr, phdrs_paddr;
3555 Elf_Internal_Phdr *p;
3556 bfd_size_type amt;
3558 if (elf_tdata (abfd)->segment_map == NULL)
3560 if (! map_sections_to_segments (abfd))
3561 return false;
3563 else
3565 /* The placement algorithm assumes that non allocated sections are
3566 not in PT_LOAD segments. We ensure this here by removing such
3567 sections from the segment map. */
3568 for (m = elf_tdata (abfd)->segment_map;
3569 m != NULL;
3570 m = m->next)
3572 unsigned int new_count;
3573 unsigned int i;
3575 if (m->p_type != PT_LOAD)
3576 continue;
3578 new_count = 0;
3579 for (i = 0; i < m->count; i ++)
3581 if ((m->sections[i]->flags & SEC_ALLOC) != 0)
3583 if (i != new_count)
3584 m->sections[new_count] = m->sections[i];
3586 new_count ++;
3590 if (new_count != m->count)
3591 m->count = new_count;
3595 if (bed->elf_backend_modify_segment_map)
3597 if (! (*bed->elf_backend_modify_segment_map) (abfd))
3598 return false;
3601 count = 0;
3602 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3603 ++count;
3605 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
3606 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
3607 elf_elfheader (abfd)->e_phnum = count;
3609 if (count == 0)
3610 return true;
3612 /* If we already counted the number of program segments, make sure
3613 that we allocated enough space. This happens when SIZEOF_HEADERS
3614 is used in a linker script. */
3615 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3616 if (alloc != 0 && count > alloc)
3618 ((*_bfd_error_handler)
3619 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
3620 bfd_get_filename (abfd), alloc, count));
3621 bfd_set_error (bfd_error_bad_value);
3622 return false;
3625 if (alloc == 0)
3626 alloc = count;
3628 amt = alloc * sizeof (Elf_Internal_Phdr);
3629 phdrs = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
3630 if (phdrs == NULL)
3631 return false;
3633 off = bed->s->sizeof_ehdr;
3634 off += alloc * bed->s->sizeof_phdr;
3636 filehdr_vaddr = 0;
3637 filehdr_paddr = 0;
3638 phdrs_vaddr = 0;
3639 phdrs_paddr = 0;
3641 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3642 m != NULL;
3643 m = m->next, p++)
3645 unsigned int i;
3646 asection **secpp;
3648 /* If elf_segment_map is not from map_sections_to_segments, the
3649 sections may not be correctly ordered. NOTE: sorting should
3650 not be done to the PT_NOTE section of a corefile, which may
3651 contain several pseudo-sections artificially created by bfd.
3652 Sorting these pseudo-sections breaks things badly. */
3653 if (m->count > 1
3654 && !(elf_elfheader (abfd)->e_type == ET_CORE
3655 && m->p_type == PT_NOTE))
3656 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3657 elf_sort_sections);
3659 p->p_type = m->p_type;
3660 p->p_flags = m->p_flags;
3662 if (p->p_type == PT_LOAD
3663 && m->count > 0
3664 && (m->sections[0]->flags & SEC_ALLOC) != 0)
3666 if ((abfd->flags & D_PAGED) != 0)
3667 off += (m->sections[0]->vma - off) % bed->maxpagesize;
3668 else
3670 bfd_size_type align;
3672 align = 0;
3673 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3675 bfd_size_type secalign;
3677 secalign = bfd_get_section_alignment (abfd, *secpp);
3678 if (secalign > align)
3679 align = secalign;
3682 off += (m->sections[0]->vma - off) % (1 << align);
3686 if (m->count == 0)
3687 p->p_vaddr = 0;
3688 else
3689 p->p_vaddr = m->sections[0]->vma;
3691 if (m->p_paddr_valid)
3692 p->p_paddr = m->p_paddr;
3693 else if (m->count == 0)
3694 p->p_paddr = 0;
3695 else
3696 p->p_paddr = m->sections[0]->lma;
3698 if (p->p_type == PT_LOAD
3699 && (abfd->flags & D_PAGED) != 0)
3700 p->p_align = bed->maxpagesize;
3701 else if (m->count == 0)
3702 p->p_align = bed->s->file_align;
3703 else
3704 p->p_align = 0;
3706 p->p_offset = 0;
3707 p->p_filesz = 0;
3708 p->p_memsz = 0;
3710 if (m->includes_filehdr)
3712 if (! m->p_flags_valid)
3713 p->p_flags |= PF_R;
3714 p->p_offset = 0;
3715 p->p_filesz = bed->s->sizeof_ehdr;
3716 p->p_memsz = bed->s->sizeof_ehdr;
3717 if (m->count > 0)
3719 BFD_ASSERT (p->p_type == PT_LOAD);
3721 if (p->p_vaddr < (bfd_vma) off)
3723 (*_bfd_error_handler)
3724 (_("%s: Not enough room for program headers, try linking with -N"),
3725 bfd_get_filename (abfd));
3726 bfd_set_error (bfd_error_bad_value);
3727 return false;
3730 p->p_vaddr -= off;
3731 if (! m->p_paddr_valid)
3732 p->p_paddr -= off;
3734 if (p->p_type == PT_LOAD)
3736 filehdr_vaddr = p->p_vaddr;
3737 filehdr_paddr = p->p_paddr;
3741 if (m->includes_phdrs)
3743 if (! m->p_flags_valid)
3744 p->p_flags |= PF_R;
3746 if (m->includes_filehdr)
3748 if (p->p_type == PT_LOAD)
3750 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
3751 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
3754 else
3756 p->p_offset = bed->s->sizeof_ehdr;
3758 if (m->count > 0)
3760 BFD_ASSERT (p->p_type == PT_LOAD);
3761 p->p_vaddr -= off - p->p_offset;
3762 if (! m->p_paddr_valid)
3763 p->p_paddr -= off - p->p_offset;
3766 if (p->p_type == PT_LOAD)
3768 phdrs_vaddr = p->p_vaddr;
3769 phdrs_paddr = p->p_paddr;
3771 else
3772 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
3775 p->p_filesz += alloc * bed->s->sizeof_phdr;
3776 p->p_memsz += alloc * bed->s->sizeof_phdr;
3779 if (p->p_type == PT_LOAD
3780 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
3782 if (! m->includes_filehdr && ! m->includes_phdrs)
3783 p->p_offset = off;
3784 else
3786 file_ptr adjust;
3788 adjust = off - (p->p_offset + p->p_filesz);
3789 p->p_filesz += adjust;
3790 p->p_memsz += adjust;
3794 voff = off;
3796 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3798 asection *sec;
3799 flagword flags;
3800 bfd_size_type align;
3802 sec = *secpp;
3803 flags = sec->flags;
3804 align = 1 << bfd_get_section_alignment (abfd, sec);
3806 /* The section may have artificial alignment forced by a
3807 link script. Notice this case by the gap between the
3808 cumulative phdr lma and the section's lma. */
3809 if (p->p_paddr + p->p_memsz < sec->lma)
3811 bfd_vma adjust = sec->lma - (p->p_paddr + p->p_memsz);
3813 p->p_memsz += adjust;
3814 off += adjust;
3815 voff += adjust;
3816 if ((flags & SEC_LOAD) != 0)
3817 p->p_filesz += adjust;
3820 if (p->p_type == PT_LOAD)
3822 bfd_signed_vma adjust;
3824 if ((flags & SEC_LOAD) != 0)
3826 adjust = sec->lma - (p->p_paddr + p->p_memsz);
3827 if (adjust < 0)
3828 adjust = 0;
3830 else if ((flags & SEC_ALLOC) != 0)
3832 /* The section VMA must equal the file position
3833 modulo the page size. FIXME: I'm not sure if
3834 this adjustment is really necessary. We used to
3835 not have the SEC_LOAD case just above, and then
3836 this was necessary, but now I'm not sure. */
3837 if ((abfd->flags & D_PAGED) != 0)
3838 adjust = (sec->vma - voff) % bed->maxpagesize;
3839 else
3840 adjust = (sec->vma - voff) % align;
3842 else
3843 adjust = 0;
3845 if (adjust != 0)
3847 if (i == 0)
3849 (* _bfd_error_handler) (_("\
3850 Error: First section in segment (%s) starts at 0x%x whereas the segment starts at 0x%x"),
3851 bfd_section_name (abfd, sec),
3852 sec->lma,
3853 p->p_paddr);
3854 return false;
3856 p->p_memsz += adjust;
3857 off += adjust;
3858 voff += adjust;
3859 if ((flags & SEC_LOAD) != 0)
3860 p->p_filesz += adjust;
3863 sec->filepos = off;
3865 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
3866 used in a linker script we may have a section with
3867 SEC_LOAD clear but which is supposed to have
3868 contents. */
3869 if ((flags & SEC_LOAD) != 0
3870 || (flags & SEC_HAS_CONTENTS) != 0)
3871 off += sec->_raw_size;
3873 if ((flags & SEC_ALLOC) != 0)
3874 voff += sec->_raw_size;
3877 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
3879 /* The actual "note" segment has i == 0.
3880 This is the one that actually contains everything. */
3881 if (i == 0)
3883 sec->filepos = off;
3884 p->p_filesz = sec->_raw_size;
3885 off += sec->_raw_size;
3886 voff = off;
3888 else
3890 /* Fake sections -- don't need to be written. */
3891 sec->filepos = 0;
3892 sec->_raw_size = 0;
3893 flags = sec->flags = 0;
3895 p->p_memsz = 0;
3896 p->p_align = 1;
3898 else
3900 p->p_memsz += sec->_raw_size;
3902 if ((flags & SEC_LOAD) != 0)
3903 p->p_filesz += sec->_raw_size;
3905 if (p->p_type == PT_TLS
3906 && sec->_raw_size == 0
3907 && (sec->flags & SEC_HAS_CONTENTS) == 0)
3909 struct bfd_link_order *o;
3910 bfd_vma tbss_size = 0;
3912 for (o = sec->link_order_head; o != NULL; o = o->next)
3913 if (tbss_size < o->offset + o->size)
3914 tbss_size = o->offset + o->size;
3916 p->p_memsz += tbss_size;
3919 if (align > p->p_align
3920 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
3921 p->p_align = align;
3924 if (! m->p_flags_valid)
3926 p->p_flags |= PF_R;
3927 if ((flags & SEC_CODE) != 0)
3928 p->p_flags |= PF_X;
3929 if ((flags & SEC_READONLY) == 0)
3930 p->p_flags |= PF_W;
3935 /* Now that we have set the section file positions, we can set up
3936 the file positions for the non PT_LOAD segments. */
3937 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3938 m != NULL;
3939 m = m->next, p++)
3941 if (p->p_type != PT_LOAD && m->count > 0)
3943 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3944 p->p_offset = m->sections[0]->filepos;
3946 if (m->count == 0)
3948 if (m->includes_filehdr)
3950 p->p_vaddr = filehdr_vaddr;
3951 if (! m->p_paddr_valid)
3952 p->p_paddr = filehdr_paddr;
3954 else if (m->includes_phdrs)
3956 p->p_vaddr = phdrs_vaddr;
3957 if (! m->p_paddr_valid)
3958 p->p_paddr = phdrs_paddr;
3963 /* If additional nonloadable filepos adjustments are required,
3964 do them now. */
3965 if (bed->set_nonloadable_filepos)
3966 (*bed->set_nonloadable_filepos) (abfd, phdrs);
3968 /* Clear out any program headers we allocated but did not use. */
3969 for (; count < alloc; count++, p++)
3971 memset (p, 0, sizeof *p);
3972 p->p_type = PT_NULL;
3975 elf_tdata (abfd)->phdr = phdrs;
3977 elf_tdata (abfd)->next_file_pos = off;
3979 /* Write out the program headers. */
3980 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
3981 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3982 return false;
3984 return true;
3987 /* Get the size of the program header.
3989 If this is called by the linker before any of the section VMA's are set, it
3990 can't calculate the correct value for a strange memory layout. This only
3991 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3992 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3993 data segment (exclusive of .interp and .dynamic).
3995 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3996 will be two segments. */
3998 static bfd_size_type
3999 get_program_header_size (abfd)
4000 bfd *abfd;
4002 size_t segs;
4003 asection *s;
4004 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4006 /* We can't return a different result each time we're called. */
4007 if (elf_tdata (abfd)->program_header_size != 0)
4008 return elf_tdata (abfd)->program_header_size;
4010 if (elf_tdata (abfd)->segment_map != NULL)
4012 struct elf_segment_map *m;
4014 segs = 0;
4015 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4016 ++segs;
4017 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4018 return elf_tdata (abfd)->program_header_size;
4021 /* Assume we will need exactly two PT_LOAD segments: one for text
4022 and one for data. */
4023 segs = 2;
4025 s = bfd_get_section_by_name (abfd, ".interp");
4026 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4028 /* If we have a loadable interpreter section, we need a
4029 PT_INTERP segment. In this case, assume we also need a
4030 PT_PHDR segment, although that may not be true for all
4031 targets. */
4032 segs += 2;
4035 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4037 /* We need a PT_DYNAMIC segment. */
4038 ++segs;
4041 if (elf_tdata (abfd)->eh_frame_hdr
4042 && bfd_get_section_by_name (abfd, ".eh_frame_hdr") != NULL)
4044 /* We need a PT_GNU_EH_FRAME segment. */
4045 ++segs;
4048 for (s = abfd->sections; s != NULL; s = s->next)
4050 if ((s->flags & SEC_LOAD) != 0
4051 && strncmp (s->name, ".note", 5) == 0)
4053 /* We need a PT_NOTE segment. */
4054 ++segs;
4058 for (s = abfd->sections; s != NULL; s = s->next)
4060 if (s->flags & SEC_THREAD_LOCAL)
4062 /* We need a PT_TLS segment. */
4063 ++segs;
4064 break;
4068 /* Let the backend count up any program headers it might need. */
4069 if (bed->elf_backend_additional_program_headers)
4071 int a;
4073 a = (*bed->elf_backend_additional_program_headers) (abfd);
4074 if (a == -1)
4075 abort ();
4076 segs += a;
4079 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4080 return elf_tdata (abfd)->program_header_size;
4083 /* Work out the file positions of all the sections. This is called by
4084 _bfd_elf_compute_section_file_positions. All the section sizes and
4085 VMAs must be known before this is called.
4087 We do not consider reloc sections at this point, unless they form
4088 part of the loadable image. Reloc sections are assigned file
4089 positions in assign_file_positions_for_relocs, which is called by
4090 write_object_contents and final_link.
4092 We also don't set the positions of the .symtab and .strtab here. */
4094 static boolean
4095 assign_file_positions_except_relocs (abfd)
4096 bfd *abfd;
4098 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4099 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4100 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4101 unsigned int num_sec = elf_numsections (abfd);
4102 file_ptr off;
4103 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4105 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4106 && bfd_get_format (abfd) != bfd_core)
4108 Elf_Internal_Shdr **hdrpp;
4109 unsigned int i;
4111 /* Start after the ELF header. */
4112 off = i_ehdrp->e_ehsize;
4114 /* We are not creating an executable, which means that we are
4115 not creating a program header, and that the actual order of
4116 the sections in the file is unimportant. */
4117 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4119 Elf_Internal_Shdr *hdr;
4121 hdr = *hdrpp;
4122 if (hdr->sh_type == SHT_REL
4123 || hdr->sh_type == SHT_RELA
4124 || i == tdata->symtab_section
4125 || i == tdata->symtab_shndx_section
4126 || i == tdata->strtab_section)
4128 hdr->sh_offset = -1;
4130 else
4131 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
4133 if (i == SHN_LORESERVE - 1)
4135 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4136 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4140 else
4142 unsigned int i;
4143 Elf_Internal_Shdr **hdrpp;
4145 /* Assign file positions for the loaded sections based on the
4146 assignment of sections to segments. */
4147 if (! assign_file_positions_for_segments (abfd))
4148 return false;
4150 /* Assign file positions for the other sections. */
4152 off = elf_tdata (abfd)->next_file_pos;
4153 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4155 Elf_Internal_Shdr *hdr;
4157 hdr = *hdrpp;
4158 if (hdr->bfd_section != NULL
4159 && hdr->bfd_section->filepos != 0)
4160 hdr->sh_offset = hdr->bfd_section->filepos;
4161 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4163 ((*_bfd_error_handler)
4164 (_("%s: warning: allocated section `%s' not in segment"),
4165 bfd_get_filename (abfd),
4166 (hdr->bfd_section == NULL
4167 ? "*unknown*"
4168 : hdr->bfd_section->name)));
4169 if ((abfd->flags & D_PAGED) != 0)
4170 off += (hdr->sh_addr - off) % bed->maxpagesize;
4171 else
4172 off += (hdr->sh_addr - off) % hdr->sh_addralign;
4173 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4174 false);
4176 else if (hdr->sh_type == SHT_REL
4177 || hdr->sh_type == SHT_RELA
4178 || hdr == i_shdrpp[tdata->symtab_section]
4179 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4180 || hdr == i_shdrpp[tdata->strtab_section])
4181 hdr->sh_offset = -1;
4182 else
4183 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
4185 if (i == SHN_LORESERVE - 1)
4187 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4188 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4193 /* Place the section headers. */
4194 off = align_file_position (off, bed->s->file_align);
4195 i_ehdrp->e_shoff = off;
4196 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4198 elf_tdata (abfd)->next_file_pos = off;
4200 return true;
4203 static boolean
4204 prep_headers (abfd)
4205 bfd *abfd;
4207 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4208 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4209 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
4210 struct elf_strtab_hash *shstrtab;
4211 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4213 i_ehdrp = elf_elfheader (abfd);
4214 i_shdrp = elf_elfsections (abfd);
4216 shstrtab = _bfd_elf_strtab_init ();
4217 if (shstrtab == NULL)
4218 return false;
4220 elf_shstrtab (abfd) = shstrtab;
4222 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4223 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4224 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4225 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4227 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4228 i_ehdrp->e_ident[EI_DATA] =
4229 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4230 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4232 if ((abfd->flags & DYNAMIC) != 0)
4233 i_ehdrp->e_type = ET_DYN;
4234 else if ((abfd->flags & EXEC_P) != 0)
4235 i_ehdrp->e_type = ET_EXEC;
4236 else if (bfd_get_format (abfd) == bfd_core)
4237 i_ehdrp->e_type = ET_CORE;
4238 else
4239 i_ehdrp->e_type = ET_REL;
4241 switch (bfd_get_arch (abfd))
4243 case bfd_arch_unknown:
4244 i_ehdrp->e_machine = EM_NONE;
4245 break;
4247 /* There used to be a long list of cases here, each one setting
4248 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4249 in the corresponding bfd definition. To avoid duplication,
4250 the switch was removed. Machines that need special handling
4251 can generally do it in elf_backend_final_write_processing(),
4252 unless they need the information earlier than the final write.
4253 Such need can generally be supplied by replacing the tests for
4254 e_machine with the conditions used to determine it. */
4255 default:
4256 if (get_elf_backend_data (abfd) != NULL)
4257 i_ehdrp->e_machine = get_elf_backend_data (abfd)->elf_machine_code;
4258 else
4259 i_ehdrp->e_machine = EM_NONE;
4262 i_ehdrp->e_version = bed->s->ev_current;
4263 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4265 /* No program header, for now. */
4266 i_ehdrp->e_phoff = 0;
4267 i_ehdrp->e_phentsize = 0;
4268 i_ehdrp->e_phnum = 0;
4270 /* Each bfd section is section header entry. */
4271 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4272 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4274 /* If we're building an executable, we'll need a program header table. */
4275 if (abfd->flags & EXEC_P)
4277 /* It all happens later. */
4278 #if 0
4279 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
4281 /* elf_build_phdrs() returns a (NULL-terminated) array of
4282 Elf_Internal_Phdrs. */
4283 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
4284 i_ehdrp->e_phoff = outbase;
4285 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
4286 #endif
4288 else
4290 i_ehdrp->e_phentsize = 0;
4291 i_phdrp = 0;
4292 i_ehdrp->e_phoff = 0;
4295 elf_tdata (abfd)->symtab_hdr.sh_name =
4296 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", false);
4297 elf_tdata (abfd)->strtab_hdr.sh_name =
4298 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", false);
4299 elf_tdata (abfd)->shstrtab_hdr.sh_name =
4300 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", false);
4301 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4302 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4303 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
4304 return false;
4306 return true;
4309 /* Assign file positions for all the reloc sections which are not part
4310 of the loadable file image. */
4312 void
4313 _bfd_elf_assign_file_positions_for_relocs (abfd)
4314 bfd *abfd;
4316 file_ptr off;
4317 unsigned int i, num_sec;
4318 Elf_Internal_Shdr **shdrpp;
4320 off = elf_tdata (abfd)->next_file_pos;
4322 num_sec = elf_numsections (abfd);
4323 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
4325 Elf_Internal_Shdr *shdrp;
4327 shdrp = *shdrpp;
4328 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4329 && shdrp->sh_offset == -1)
4330 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
4333 elf_tdata (abfd)->next_file_pos = off;
4336 boolean
4337 _bfd_elf_write_object_contents (abfd)
4338 bfd *abfd;
4340 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4341 Elf_Internal_Ehdr *i_ehdrp;
4342 Elf_Internal_Shdr **i_shdrp;
4343 boolean failed;
4344 unsigned int count, num_sec;
4346 if (! abfd->output_has_begun
4347 && ! _bfd_elf_compute_section_file_positions
4348 (abfd, (struct bfd_link_info *) NULL))
4349 return false;
4351 i_shdrp = elf_elfsections (abfd);
4352 i_ehdrp = elf_elfheader (abfd);
4354 failed = false;
4355 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4356 if (failed)
4357 return false;
4359 _bfd_elf_assign_file_positions_for_relocs (abfd);
4361 /* After writing the headers, we need to write the sections too... */
4362 num_sec = elf_numsections (abfd);
4363 for (count = 1; count < num_sec; count++)
4365 if (bed->elf_backend_section_processing)
4366 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4367 if (i_shdrp[count]->contents)
4369 bfd_size_type amt = i_shdrp[count]->sh_size;
4371 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
4372 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
4373 return false;
4375 if (count == SHN_LORESERVE - 1)
4376 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4379 /* Write out the section header names. */
4380 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
4381 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
4382 return false;
4384 if (bed->elf_backend_final_write_processing)
4385 (*bed->elf_backend_final_write_processing) (abfd,
4386 elf_tdata (abfd)->linker);
4388 return bed->s->write_shdrs_and_ehdr (abfd);
4391 boolean
4392 _bfd_elf_write_corefile_contents (abfd)
4393 bfd *abfd;
4395 /* Hopefully this can be done just like an object file. */
4396 return _bfd_elf_write_object_contents (abfd);
4399 /* Given a section, search the header to find them. */
4402 _bfd_elf_section_from_bfd_section (abfd, asect)
4403 bfd *abfd;
4404 struct sec *asect;
4406 struct elf_backend_data *bed;
4407 int index;
4409 if (elf_section_data (asect) != NULL
4410 && elf_section_data (asect)->this_idx != 0)
4411 return elf_section_data (asect)->this_idx;
4413 if (bfd_is_abs_section (asect))
4414 index = SHN_ABS;
4415 else if (bfd_is_com_section (asect))
4416 index = SHN_COMMON;
4417 else if (bfd_is_und_section (asect))
4418 index = SHN_UNDEF;
4419 else
4421 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4422 int maxindex = elf_numsections (abfd);
4424 for (index = 1; index < maxindex; index++)
4426 Elf_Internal_Shdr *hdr = i_shdrp[index];
4428 if (hdr != NULL && hdr->bfd_section == asect)
4429 return index;
4431 index = -1;
4434 bed = get_elf_backend_data (abfd);
4435 if (bed->elf_backend_section_from_bfd_section)
4437 int retval = index;
4439 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4440 return retval;
4443 if (index == -1)
4444 bfd_set_error (bfd_error_nonrepresentable_section);
4446 return index;
4449 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
4450 on error. */
4453 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
4454 bfd *abfd;
4455 asymbol **asym_ptr_ptr;
4457 asymbol *asym_ptr = *asym_ptr_ptr;
4458 int idx;
4459 flagword flags = asym_ptr->flags;
4461 /* When gas creates relocations against local labels, it creates its
4462 own symbol for the section, but does put the symbol into the
4463 symbol chain, so udata is 0. When the linker is generating
4464 relocatable output, this section symbol may be for one of the
4465 input sections rather than the output section. */
4466 if (asym_ptr->udata.i == 0
4467 && (flags & BSF_SECTION_SYM)
4468 && asym_ptr->section)
4470 int indx;
4472 if (asym_ptr->section->output_section != NULL)
4473 indx = asym_ptr->section->output_section->index;
4474 else
4475 indx = asym_ptr->section->index;
4476 if (indx < elf_num_section_syms (abfd)
4477 && elf_section_syms (abfd)[indx] != NULL)
4478 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4481 idx = asym_ptr->udata.i;
4483 if (idx == 0)
4485 /* This case can occur when using --strip-symbol on a symbol
4486 which is used in a relocation entry. */
4487 (*_bfd_error_handler)
4488 (_("%s: symbol `%s' required but not present"),
4489 bfd_archive_filename (abfd), bfd_asymbol_name (asym_ptr));
4490 bfd_set_error (bfd_error_no_symbols);
4491 return -1;
4494 #if DEBUG & 4
4496 fprintf (stderr,
4497 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
4498 (long) asym_ptr, asym_ptr->name, idx, flags,
4499 elf_symbol_flags (flags));
4500 fflush (stderr);
4502 #endif
4504 return idx;
4507 /* Copy private BFD data. This copies any program header information. */
4509 static boolean
4510 copy_private_bfd_data (ibfd, obfd)
4511 bfd *ibfd;
4512 bfd *obfd;
4514 Elf_Internal_Ehdr * iehdr;
4515 struct elf_segment_map * map;
4516 struct elf_segment_map * map_first;
4517 struct elf_segment_map ** pointer_to_map;
4518 Elf_Internal_Phdr * segment;
4519 asection * section;
4520 unsigned int i;
4521 unsigned int num_segments;
4522 boolean phdr_included = false;
4523 bfd_vma maxpagesize;
4524 struct elf_segment_map * phdr_adjust_seg = NULL;
4525 unsigned int phdr_adjust_num = 0;
4526 struct elf_backend_data * bed;
4528 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4529 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4530 return true;
4532 if (elf_tdata (ibfd)->phdr == NULL)
4533 return true;
4535 bed = get_elf_backend_data (ibfd);
4536 iehdr = elf_elfheader (ibfd);
4538 map_first = NULL;
4539 pointer_to_map = &map_first;
4541 num_segments = elf_elfheader (ibfd)->e_phnum;
4542 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4544 /* Returns the end address of the segment + 1. */
4545 #define SEGMENT_END(segment, start) \
4546 (start + (segment->p_memsz > segment->p_filesz \
4547 ? segment->p_memsz : segment->p_filesz))
4549 /* Returns true if the given section is contained within
4550 the given segment. VMA addresses are compared. */
4551 #define IS_CONTAINED_BY_VMA(section, segment) \
4552 (section->vma >= segment->p_vaddr \
4553 && (section->vma + section->_raw_size \
4554 <= (SEGMENT_END (segment, segment->p_vaddr))))
4556 /* Returns true if the given section is contained within
4557 the given segment. LMA addresses are compared. */
4558 #define IS_CONTAINED_BY_LMA(section, segment, base) \
4559 (section->lma >= base \
4560 && (section->lma + section->_raw_size \
4561 <= SEGMENT_END (segment, base)))
4563 /* Returns true if the given section is contained within the
4564 given segment. Filepos addresses are compared in an elf
4565 backend function. */
4566 #define IS_CONTAINED_BY_FILEPOS(sec, seg, bed) \
4567 (bed->is_contained_by_filepos \
4568 && (*bed->is_contained_by_filepos) (sec, seg))
4570 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
4571 #define IS_COREFILE_NOTE(p, s) \
4572 (p->p_type == PT_NOTE \
4573 && bfd_get_format (ibfd) == bfd_core \
4574 && s->vma == 0 && s->lma == 0 \
4575 && (bfd_vma) s->filepos >= p->p_offset \
4576 && ((bfd_vma) s->filepos + s->_raw_size \
4577 <= p->p_offset + p->p_filesz))
4579 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4580 linker, which generates a PT_INTERP section with p_vaddr and
4581 p_memsz set to 0. */
4582 #define IS_SOLARIS_PT_INTERP(p, s) \
4583 (p->p_vaddr == 0 \
4584 && p->p_paddr == 0 \
4585 && p->p_memsz == 0 \
4586 && p->p_filesz > 0 \
4587 && (s->flags & SEC_HAS_CONTENTS) != 0 \
4588 && s->_raw_size > 0 \
4589 && (bfd_vma) s->filepos >= p->p_offset \
4590 && ((bfd_vma) s->filepos + s->_raw_size \
4591 <= p->p_offset + p->p_filesz))
4593 /* Decide if the given section should be included in the given segment.
4594 A section will be included if:
4595 1. It is within the address space of the segment -- we use the LMA
4596 if that is set for the segment and the VMA otherwise,
4597 2. It is an allocated segment,
4598 3. There is an output section associated with it,
4599 4. The section has not already been allocated to a previous segment. */
4600 #define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
4601 ((((segment->p_paddr \
4602 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4603 : IS_CONTAINED_BY_VMA (section, segment)) \
4604 && (section->flags & SEC_ALLOC) != 0) \
4605 || IS_COREFILE_NOTE (segment, section) \
4606 || (IS_CONTAINED_BY_FILEPOS (section, segment, bed) \
4607 && (section->flags & SEC_ALLOC) == 0)) \
4608 && section->output_section != NULL \
4609 && ! section->segment_mark)
4611 /* Returns true iff seg1 starts after the end of seg2. */
4612 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
4613 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
4615 /* Returns true iff seg1 and seg2 overlap. */
4616 #define SEGMENT_OVERLAPS(seg1, seg2) \
4617 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) \
4618 || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
4620 /* Initialise the segment mark field. */
4621 for (section = ibfd->sections; section != NULL; section = section->next)
4622 section->segment_mark = false;
4624 /* Scan through the segments specified in the program header
4625 of the input BFD. For this first scan we look for overlaps
4626 in the loadable segments. These can be created by weird
4627 parameters to objcopy. Also, fix some solaris weirdness. */
4628 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4629 i < num_segments;
4630 i++, segment++)
4632 unsigned int j;
4633 Elf_Internal_Phdr *segment2;
4635 if (segment->p_type == PT_INTERP)
4636 for (section = ibfd->sections; section; section = section->next)
4637 if (IS_SOLARIS_PT_INTERP (segment, section))
4639 /* Mininal change so that the normal section to segment
4640 assigment code will work. */
4641 segment->p_vaddr = section->vma;
4642 break;
4645 if (segment->p_type != PT_LOAD)
4646 continue;
4648 /* Determine if this segment overlaps any previous segments. */
4649 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
4651 bfd_signed_vma extra_length;
4653 if (segment2->p_type != PT_LOAD
4654 || ! SEGMENT_OVERLAPS (segment, segment2))
4655 continue;
4657 /* Merge the two segments together. */
4658 if (segment2->p_vaddr < segment->p_vaddr)
4660 /* Extend SEGMENT2 to include SEGMENT and then delete
4661 SEGMENT. */
4662 extra_length =
4663 SEGMENT_END (segment, segment->p_vaddr)
4664 - SEGMENT_END (segment2, segment2->p_vaddr);
4666 if (extra_length > 0)
4668 segment2->p_memsz += extra_length;
4669 segment2->p_filesz += extra_length;
4672 segment->p_type = PT_NULL;
4674 /* Since we have deleted P we must restart the outer loop. */
4675 i = 0;
4676 segment = elf_tdata (ibfd)->phdr;
4677 break;
4679 else
4681 /* Extend SEGMENT to include SEGMENT2 and then delete
4682 SEGMENT2. */
4683 extra_length =
4684 SEGMENT_END (segment2, segment2->p_vaddr)
4685 - SEGMENT_END (segment, segment->p_vaddr);
4687 if (extra_length > 0)
4689 segment->p_memsz += extra_length;
4690 segment->p_filesz += extra_length;
4693 segment2->p_type = PT_NULL;
4698 /* The second scan attempts to assign sections to segments. */
4699 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4700 i < num_segments;
4701 i ++, segment ++)
4703 unsigned int section_count;
4704 asection ** sections;
4705 asection * output_section;
4706 unsigned int isec;
4707 bfd_vma matching_lma;
4708 bfd_vma suggested_lma;
4709 unsigned int j;
4710 bfd_size_type amt;
4712 if (segment->p_type == PT_NULL)
4713 continue;
4715 /* Compute how many sections might be placed into this segment. */
4716 section_count = 0;
4717 for (section = ibfd->sections; section != NULL; section = section->next)
4718 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4719 ++section_count;
4721 /* Allocate a segment map big enough to contain all of the
4722 sections we have selected. */
4723 amt = sizeof (struct elf_segment_map);
4724 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
4725 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
4726 if (map == NULL)
4727 return false;
4729 /* Initialise the fields of the segment map. Default to
4730 using the physical address of the segment in the input BFD. */
4731 map->next = NULL;
4732 map->p_type = segment->p_type;
4733 map->p_flags = segment->p_flags;
4734 map->p_flags_valid = 1;
4735 map->p_paddr = segment->p_paddr;
4736 map->p_paddr_valid = 1;
4738 /* Determine if this segment contains the ELF file header
4739 and if it contains the program headers themselves. */
4740 map->includes_filehdr = (segment->p_offset == 0
4741 && segment->p_filesz >= iehdr->e_ehsize);
4743 map->includes_phdrs = 0;
4745 if (! phdr_included || segment->p_type != PT_LOAD)
4747 map->includes_phdrs =
4748 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
4749 && (segment->p_offset + segment->p_filesz
4750 >= ((bfd_vma) iehdr->e_phoff
4751 + iehdr->e_phnum * iehdr->e_phentsize)));
4753 if (segment->p_type == PT_LOAD && map->includes_phdrs)
4754 phdr_included = true;
4757 if (section_count == 0)
4759 /* Special segments, such as the PT_PHDR segment, may contain
4760 no sections, but ordinary, loadable segments should contain
4761 something. They are allowed by the ELF spec however, so only
4762 a warning is produced. */
4763 if (segment->p_type == PT_LOAD)
4764 (*_bfd_error_handler)
4765 (_("%s: warning: Empty loadable segment detected, is this intentional ?\n"),
4766 bfd_archive_filename (ibfd));
4768 map->count = 0;
4769 *pointer_to_map = map;
4770 pointer_to_map = &map->next;
4772 continue;
4775 /* Now scan the sections in the input BFD again and attempt
4776 to add their corresponding output sections to the segment map.
4777 The problem here is how to handle an output section which has
4778 been moved (ie had its LMA changed). There are four possibilities:
4780 1. None of the sections have been moved.
4781 In this case we can continue to use the segment LMA from the
4782 input BFD.
4784 2. All of the sections have been moved by the same amount.
4785 In this case we can change the segment's LMA to match the LMA
4786 of the first section.
4788 3. Some of the sections have been moved, others have not.
4789 In this case those sections which have not been moved can be
4790 placed in the current segment which will have to have its size,
4791 and possibly its LMA changed, and a new segment or segments will
4792 have to be created to contain the other sections.
4794 4. The sections have been moved, but not be the same amount.
4795 In this case we can change the segment's LMA to match the LMA
4796 of the first section and we will have to create a new segment
4797 or segments to contain the other sections.
4799 In order to save time, we allocate an array to hold the section
4800 pointers that we are interested in. As these sections get assigned
4801 to a segment, they are removed from this array. */
4803 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
4804 to work around this long long bug. */
4805 amt = section_count * sizeof (asection *);
4806 sections = (asection **) bfd_malloc (amt);
4807 if (sections == NULL)
4808 return false;
4810 /* Step One: Scan for segment vs section LMA conflicts.
4811 Also add the sections to the section array allocated above.
4812 Also add the sections to the current segment. In the common
4813 case, where the sections have not been moved, this means that
4814 we have completely filled the segment, and there is nothing
4815 more to do. */
4816 isec = 0;
4817 matching_lma = 0;
4818 suggested_lma = 0;
4820 for (j = 0, section = ibfd->sections;
4821 section != NULL;
4822 section = section->next)
4824 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
4826 output_section = section->output_section;
4828 sections[j ++] = section;
4830 /* The Solaris native linker always sets p_paddr to 0.
4831 We try to catch that case here, and set it to the
4832 correct value. Note - some backends require that
4833 p_paddr be left as zero. */
4834 if (segment->p_paddr == 0
4835 && segment->p_vaddr != 0
4836 && (! bed->want_p_paddr_set_to_zero)
4837 && isec == 0
4838 && output_section->lma != 0
4839 && (output_section->vma == (segment->p_vaddr
4840 + (map->includes_filehdr
4841 ? iehdr->e_ehsize
4842 : 0)
4843 + (map->includes_phdrs
4844 ? (iehdr->e_phnum
4845 * iehdr->e_phentsize)
4846 : 0))))
4847 map->p_paddr = segment->p_vaddr;
4849 /* Match up the physical address of the segment with the
4850 LMA address of the output section. */
4851 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4852 || IS_CONTAINED_BY_FILEPOS (section, segment, bed)
4853 || IS_COREFILE_NOTE (segment, section)
4854 || (bed->want_p_paddr_set_to_zero &&
4855 IS_CONTAINED_BY_VMA (output_section, segment))
4858 if (matching_lma == 0)
4859 matching_lma = output_section->lma;
4861 /* We assume that if the section fits within the segment
4862 then it does not overlap any other section within that
4863 segment. */
4864 map->sections[isec ++] = output_section;
4866 else if (suggested_lma == 0)
4867 suggested_lma = output_section->lma;
4871 BFD_ASSERT (j == section_count);
4873 /* Step Two: Adjust the physical address of the current segment,
4874 if necessary. */
4875 if (isec == section_count)
4877 /* All of the sections fitted within the segment as currently
4878 specified. This is the default case. Add the segment to
4879 the list of built segments and carry on to process the next
4880 program header in the input BFD. */
4881 map->count = section_count;
4882 *pointer_to_map = map;
4883 pointer_to_map = &map->next;
4885 free (sections);
4886 continue;
4888 else
4890 if (matching_lma != 0)
4892 /* At least one section fits inside the current segment.
4893 Keep it, but modify its physical address to match the
4894 LMA of the first section that fitted. */
4895 map->p_paddr = matching_lma;
4897 else
4899 /* None of the sections fitted inside the current segment.
4900 Change the current segment's physical address to match
4901 the LMA of the first section. */
4902 map->p_paddr = suggested_lma;
4905 /* Offset the segment physical address from the lma
4906 to allow for space taken up by elf headers. */
4907 if (map->includes_filehdr)
4908 map->p_paddr -= iehdr->e_ehsize;
4910 if (map->includes_phdrs)
4912 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
4914 /* iehdr->e_phnum is just an estimate of the number
4915 of program headers that we will need. Make a note
4916 here of the number we used and the segment we chose
4917 to hold these headers, so that we can adjust the
4918 offset when we know the correct value. */
4919 phdr_adjust_num = iehdr->e_phnum;
4920 phdr_adjust_seg = map;
4924 /* Step Three: Loop over the sections again, this time assigning
4925 those that fit to the current segment and removing them from the
4926 sections array; but making sure not to leave large gaps. Once all
4927 possible sections have been assigned to the current segment it is
4928 added to the list of built segments and if sections still remain
4929 to be assigned, a new segment is constructed before repeating
4930 the loop. */
4931 isec = 0;
4934 map->count = 0;
4935 suggested_lma = 0;
4937 /* Fill the current segment with sections that fit. */
4938 for (j = 0; j < section_count; j++)
4940 section = sections[j];
4942 if (section == NULL)
4943 continue;
4945 output_section = section->output_section;
4947 BFD_ASSERT (output_section != NULL);
4949 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4950 || IS_COREFILE_NOTE (segment, section))
4952 if (map->count == 0)
4954 /* If the first section in a segment does not start at
4955 the beginning of the segment, then something is
4956 wrong. */
4957 if (output_section->lma !=
4958 (map->p_paddr
4959 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4960 + (map->includes_phdrs
4961 ? iehdr->e_phnum * iehdr->e_phentsize
4962 : 0)))
4963 abort ();
4965 else
4967 asection * prev_sec;
4969 prev_sec = map->sections[map->count - 1];
4971 /* If the gap between the end of the previous section
4972 and the start of this section is more than
4973 maxpagesize then we need to start a new segment. */
4974 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size,
4975 maxpagesize)
4976 < BFD_ALIGN (output_section->lma, maxpagesize))
4977 || ((prev_sec->lma + prev_sec->_raw_size)
4978 > output_section->lma))
4980 if (suggested_lma == 0)
4981 suggested_lma = output_section->lma;
4983 continue;
4987 map->sections[map->count++] = output_section;
4988 ++isec;
4989 sections[j] = NULL;
4990 section->segment_mark = true;
4992 else if (suggested_lma == 0)
4993 suggested_lma = output_section->lma;
4996 BFD_ASSERT (map->count > 0);
4998 /* Add the current segment to the list of built segments. */
4999 *pointer_to_map = map;
5000 pointer_to_map = &map->next;
5002 if (isec < section_count)
5004 /* We still have not allocated all of the sections to
5005 segments. Create a new segment here, initialise it
5006 and carry on looping. */
5007 amt = sizeof (struct elf_segment_map);
5008 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5009 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
5010 if (map == NULL)
5011 return false;
5013 /* Initialise the fields of the segment map. Set the physical
5014 physical address to the LMA of the first section that has
5015 not yet been assigned. */
5016 map->next = NULL;
5017 map->p_type = segment->p_type;
5018 map->p_flags = segment->p_flags;
5019 map->p_flags_valid = 1;
5020 map->p_paddr = suggested_lma;
5021 map->p_paddr_valid = 1;
5022 map->includes_filehdr = 0;
5023 map->includes_phdrs = 0;
5026 while (isec < section_count);
5028 free (sections);
5031 /* The Solaris linker creates program headers in which all the
5032 p_paddr fields are zero. When we try to objcopy or strip such a
5033 file, we get confused. Check for this case, and if we find it
5034 reset the p_paddr_valid fields. */
5035 for (map = map_first; map != NULL; map = map->next)
5036 if (map->p_paddr != 0)
5037 break;
5038 if (map == NULL)
5040 for (map = map_first; map != NULL; map = map->next)
5041 map->p_paddr_valid = 0;
5044 elf_tdata (obfd)->segment_map = map_first;
5046 /* If we had to estimate the number of program headers that were
5047 going to be needed, then check our estimate now and adjust
5048 the offset if necessary. */
5049 if (phdr_adjust_seg != NULL)
5051 unsigned int count;
5053 for (count = 0, map = map_first; map != NULL; map = map->next)
5054 count++;
5056 if (count > phdr_adjust_num)
5057 phdr_adjust_seg->p_paddr
5058 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5061 #if 0
5062 /* Final Step: Sort the segments into ascending order of physical
5063 address. */
5064 if (map_first != NULL)
5066 struct elf_segment_map *prev;
5068 prev = map_first;
5069 for (map = map_first->next; map != NULL; prev = map, map = map->next)
5071 /* Yes I know - its a bubble sort.... */
5072 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
5074 /* Swap map and map->next. */
5075 prev->next = map->next;
5076 map->next = map->next->next;
5077 prev->next->next = map;
5079 /* Restart loop. */
5080 map = map_first;
5084 #endif
5086 #undef SEGMENT_END
5087 #undef IS_CONTAINED_BY_VMA
5088 #undef IS_CONTAINED_BY_LMA
5089 #undef IS_CONTAINED_BY_FILEPOS
5090 #undef IS_COREFILE_NOTE
5091 #undef IS_SOLARIS_PT_INTERP
5092 #undef INCLUDE_SECTION_IN_SEGMENT
5093 #undef SEGMENT_AFTER_SEGMENT
5094 #undef SEGMENT_OVERLAPS
5095 return true;
5098 /* Copy private section information. This copies over the entsize
5099 field, and sometimes the info field. */
5101 boolean
5102 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
5103 bfd *ibfd;
5104 asection *isec;
5105 bfd *obfd;
5106 asection *osec;
5108 Elf_Internal_Shdr *ihdr, *ohdr;
5109 const struct elf_backend_data *bed = get_elf_backend_data (ibfd);
5111 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5112 || obfd->xvec->flavour != bfd_target_elf_flavour)
5113 return true;
5115 /* Copy over private BFD data if it has not already been copied.
5116 This must be done here, rather than in the copy_private_bfd_data
5117 entry point, because the latter is called after the section
5118 contents have been set, which means that the program headers have
5119 already been worked out. The backend function provides a way to
5120 override the test conditions and code path for the call to
5121 copy_private_bfd_data. */
5122 if (bed->copy_private_bfd_data_p)
5124 if ((*bed->copy_private_bfd_data_p) (ibfd, isec, obfd, osec))
5125 if (! copy_private_bfd_data (ibfd, obfd))
5126 return false;
5128 else if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5130 asection *s;
5132 /* Only set up the segments if there are no more SEC_ALLOC
5133 sections. FIXME: This won't do the right thing if objcopy is
5134 used to remove the last SEC_ALLOC section, since objcopy
5135 won't call this routine in that case. */
5136 for (s = isec->next; s != NULL; s = s->next)
5137 if ((s->flags & SEC_ALLOC) != 0)
5138 break;
5139 if (s == NULL)
5141 if (! copy_private_bfd_data (ibfd, obfd))
5142 return false;
5146 ihdr = &elf_section_data (isec)->this_hdr;
5147 ohdr = &elf_section_data (osec)->this_hdr;
5149 ohdr->sh_entsize = ihdr->sh_entsize;
5151 if (ihdr->sh_type == SHT_SYMTAB
5152 || ihdr->sh_type == SHT_DYNSYM
5153 || ihdr->sh_type == SHT_GNU_verneed
5154 || ihdr->sh_type == SHT_GNU_verdef)
5155 ohdr->sh_info = ihdr->sh_info;
5157 /* Set things up for objcopy. The output SHT_GROUP section will
5158 have its elf_next_in_group pointing back to the input group
5159 members. */
5160 elf_next_in_group (osec) = elf_next_in_group (isec);
5161 elf_group_name (osec) = elf_group_name (isec);
5163 elf_section_data (osec)->use_rela_p
5164 = elf_section_data (isec)->use_rela_p;
5166 return true;
5169 /* Copy private symbol information. If this symbol is in a section
5170 which we did not map into a BFD section, try to map the section
5171 index correctly. We use special macro definitions for the mapped
5172 section indices; these definitions are interpreted by the
5173 swap_out_syms function. */
5175 #define MAP_ONESYMTAB (SHN_HIOS + 1)
5176 #define MAP_DYNSYMTAB (SHN_HIOS + 2)
5177 #define MAP_STRTAB (SHN_HIOS + 3)
5178 #define MAP_SHSTRTAB (SHN_HIOS + 4)
5179 #define MAP_SYM_SHNDX (SHN_HIOS + 5)
5181 boolean
5182 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
5183 bfd *ibfd;
5184 asymbol *isymarg;
5185 bfd *obfd;
5186 asymbol *osymarg;
5188 elf_symbol_type *isym, *osym;
5190 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5191 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5192 return true;
5194 isym = elf_symbol_from (ibfd, isymarg);
5195 osym = elf_symbol_from (obfd, osymarg);
5197 if (isym != NULL
5198 && osym != NULL
5199 && bfd_is_abs_section (isym->symbol.section))
5201 unsigned int shndx;
5203 shndx = isym->internal_elf_sym.st_shndx;
5204 if (shndx == elf_onesymtab (ibfd))
5205 shndx = MAP_ONESYMTAB;
5206 else if (shndx == elf_dynsymtab (ibfd))
5207 shndx = MAP_DYNSYMTAB;
5208 else if (shndx == elf_tdata (ibfd)->strtab_section)
5209 shndx = MAP_STRTAB;
5210 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5211 shndx = MAP_SHSTRTAB;
5212 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5213 shndx = MAP_SYM_SHNDX;
5214 osym->internal_elf_sym.st_shndx = shndx;
5217 return true;
5220 /* Swap out the symbols. */
5222 static boolean
5223 swap_out_syms (abfd, sttp, relocatable_p)
5224 bfd *abfd;
5225 struct bfd_strtab_hash **sttp;
5226 int relocatable_p;
5228 struct elf_backend_data *bed;
5229 int symcount;
5230 asymbol **syms;
5231 struct bfd_strtab_hash *stt;
5232 Elf_Internal_Shdr *symtab_hdr;
5233 Elf_Internal_Shdr *symtab_shndx_hdr;
5234 Elf_Internal_Shdr *symstrtab_hdr;
5235 char *outbound_syms;
5236 char *outbound_shndx;
5237 int idx;
5238 bfd_size_type amt;
5240 if (!elf_map_symbols (abfd))
5241 return false;
5243 /* Dump out the symtabs. */
5244 stt = _bfd_elf_stringtab_init ();
5245 if (stt == NULL)
5246 return false;
5248 bed = get_elf_backend_data (abfd);
5249 symcount = bfd_get_symcount (abfd);
5250 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5251 symtab_hdr->sh_type = SHT_SYMTAB;
5252 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5253 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5254 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
5255 symtab_hdr->sh_addralign = bed->s->file_align;
5257 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5258 symstrtab_hdr->sh_type = SHT_STRTAB;
5260 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5261 outbound_syms = bfd_alloc (abfd, amt);
5262 if (outbound_syms == NULL)
5263 return false;
5264 symtab_hdr->contents = (PTR) outbound_syms;
5266 outbound_shndx = NULL;
5267 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5268 if (symtab_shndx_hdr->sh_name != 0)
5270 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
5271 outbound_shndx = bfd_zalloc (abfd, amt);
5272 if (outbound_shndx == NULL)
5273 return false;
5274 symtab_shndx_hdr->contents = outbound_shndx;
5275 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5276 symtab_shndx_hdr->sh_size = amt;
5277 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5278 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5281 /* now generate the data (for "contents") */
5283 /* Fill in zeroth symbol and swap it out. */
5284 Elf_Internal_Sym sym;
5285 sym.st_name = 0;
5286 sym.st_value = 0;
5287 sym.st_size = 0;
5288 sym.st_info = 0;
5289 sym.st_other = 0;
5290 sym.st_shndx = SHN_UNDEF;
5291 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5292 outbound_syms += bed->s->sizeof_sym;
5293 if (outbound_shndx != NULL)
5294 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5297 syms = bfd_get_outsymbols (abfd);
5298 for (idx = 0; idx < symcount; idx++)
5300 Elf_Internal_Sym sym;
5301 bfd_vma value = syms[idx]->value;
5302 elf_symbol_type *type_ptr;
5303 flagword flags = syms[idx]->flags;
5304 int type;
5306 if ((flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
5308 /* Local section symbols have no name. */
5309 sym.st_name = 0;
5311 else
5313 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5314 syms[idx]->name,
5315 true, false);
5316 if (sym.st_name == (unsigned long) -1)
5317 return false;
5320 type_ptr = elf_symbol_from (abfd, syms[idx]);
5322 if ((flags & BSF_SECTION_SYM) == 0
5323 && bfd_is_com_section (syms[idx]->section))
5325 /* ELF common symbols put the alignment into the `value' field,
5326 and the size into the `size' field. This is backwards from
5327 how BFD handles it, so reverse it here. */
5328 sym.st_size = value;
5329 if (type_ptr == NULL
5330 || type_ptr->internal_elf_sym.st_value == 0)
5331 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5332 else
5333 sym.st_value = type_ptr->internal_elf_sym.st_value;
5334 sym.st_shndx = _bfd_elf_section_from_bfd_section
5335 (abfd, syms[idx]->section);
5337 else
5339 asection *sec = syms[idx]->section;
5340 int shndx;
5342 if (sec->output_section)
5344 value += sec->output_offset;
5345 sec = sec->output_section;
5347 /* Don't add in the section vma for relocatable output. */
5348 if (! relocatable_p)
5349 value += sec->vma;
5350 sym.st_value = value;
5351 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5353 if (bfd_is_abs_section (sec)
5354 && type_ptr != NULL
5355 && type_ptr->internal_elf_sym.st_shndx != 0)
5357 /* This symbol is in a real ELF section which we did
5358 not create as a BFD section. Undo the mapping done
5359 by copy_private_symbol_data. */
5360 shndx = type_ptr->internal_elf_sym.st_shndx;
5361 switch (shndx)
5363 case MAP_ONESYMTAB:
5364 shndx = elf_onesymtab (abfd);
5365 break;
5366 case MAP_DYNSYMTAB:
5367 shndx = elf_dynsymtab (abfd);
5368 break;
5369 case MAP_STRTAB:
5370 shndx = elf_tdata (abfd)->strtab_section;
5371 break;
5372 case MAP_SHSTRTAB:
5373 shndx = elf_tdata (abfd)->shstrtab_section;
5374 break;
5375 case MAP_SYM_SHNDX:
5376 shndx = elf_tdata (abfd)->symtab_shndx_section;
5377 break;
5378 default:
5379 break;
5382 else
5384 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
5386 if (shndx == -1)
5388 asection *sec2;
5390 /* Writing this would be a hell of a lot easier if
5391 we had some decent documentation on bfd, and
5392 knew what to expect of the library, and what to
5393 demand of applications. For example, it
5394 appears that `objcopy' might not set the
5395 section of a symbol to be a section that is
5396 actually in the output file. */
5397 sec2 = bfd_get_section_by_name (abfd, sec->name);
5398 BFD_ASSERT (sec2 != 0);
5399 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5400 BFD_ASSERT (shndx != -1);
5404 sym.st_shndx = shndx;
5407 if ((flags & BSF_THREAD_LOCAL) != 0)
5408 type = STT_TLS;
5409 else if ((flags & BSF_FUNCTION) != 0)
5410 type = STT_FUNC;
5411 else if ((flags & BSF_OBJECT) != 0)
5412 type = STT_OBJECT;
5413 else
5414 type = STT_NOTYPE;
5416 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5417 type = STT_TLS;
5419 /* Processor-specific types */
5420 if (type_ptr != NULL
5421 && bed->elf_backend_get_symbol_type)
5422 type = ((*bed->elf_backend_get_symbol_type)
5423 (&type_ptr->internal_elf_sym, type));
5425 if (flags & BSF_SECTION_SYM)
5427 if (flags & BSF_GLOBAL)
5428 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5429 else
5430 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5432 else if (bfd_is_com_section (syms[idx]->section))
5433 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5434 else if (bfd_is_und_section (syms[idx]->section))
5435 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5436 ? STB_WEAK
5437 : STB_GLOBAL),
5438 type);
5439 else if (flags & BSF_FILE)
5440 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5441 else
5443 int bind = STB_LOCAL;
5445 if (flags & BSF_LOCAL)
5446 bind = STB_LOCAL;
5447 else if (flags & BSF_WEAK)
5448 bind = STB_WEAK;
5449 else if (flags & BSF_GLOBAL)
5450 bind = STB_GLOBAL;
5452 sym.st_info = ELF_ST_INFO (bind, type);
5455 if (type_ptr != NULL)
5456 sym.st_other = type_ptr->internal_elf_sym.st_other;
5457 else
5458 sym.st_other = 0;
5460 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
5461 outbound_syms += bed->s->sizeof_sym;
5462 if (outbound_shndx != NULL)
5463 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
5466 *sttp = stt;
5467 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5468 symstrtab_hdr->sh_type = SHT_STRTAB;
5470 symstrtab_hdr->sh_flags = 0;
5471 symstrtab_hdr->sh_addr = 0;
5472 symstrtab_hdr->sh_entsize = 0;
5473 symstrtab_hdr->sh_link = 0;
5474 symstrtab_hdr->sh_info = 0;
5475 symstrtab_hdr->sh_addralign = 1;
5477 return true;
5480 /* Return the number of bytes required to hold the symtab vector.
5482 Note that we base it on the count plus 1, since we will null terminate
5483 the vector allocated based on this size. However, the ELF symbol table
5484 always has a dummy entry as symbol #0, so it ends up even. */
5486 long
5487 _bfd_elf_get_symtab_upper_bound (abfd)
5488 bfd *abfd;
5490 long symcount;
5491 long symtab_size;
5492 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5494 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5495 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5496 if (symcount > 0)
5497 symtab_size -= sizeof (asymbol *);
5499 return symtab_size;
5502 long
5503 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
5504 bfd *abfd;
5506 long symcount;
5507 long symtab_size;
5508 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5510 if (elf_dynsymtab (abfd) == 0)
5512 bfd_set_error (bfd_error_invalid_operation);
5513 return -1;
5516 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
5517 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5518 if (symcount > 0)
5519 symtab_size -= sizeof (asymbol *);
5521 return symtab_size;
5524 long
5525 _bfd_elf_get_reloc_upper_bound (abfd, asect)
5526 bfd *abfd ATTRIBUTE_UNUSED;
5527 sec_ptr asect;
5529 return (asect->reloc_count + 1) * sizeof (arelent *);
5532 /* Canonicalize the relocs. */
5534 long
5535 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
5536 bfd *abfd;
5537 sec_ptr section;
5538 arelent **relptr;
5539 asymbol **symbols;
5541 arelent *tblptr;
5542 unsigned int i;
5543 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5545 if (! bed->s->slurp_reloc_table (abfd, section, symbols, false))
5546 return -1;
5548 tblptr = section->relocation;
5549 for (i = 0; i < section->reloc_count; i++)
5550 *relptr++ = tblptr++;
5552 *relptr = NULL;
5554 return section->reloc_count;
5557 long
5558 _bfd_elf_get_symtab (abfd, alocation)
5559 bfd *abfd;
5560 asymbol **alocation;
5562 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5563 long symcount = bed->s->slurp_symbol_table (abfd, alocation, false);
5565 if (symcount >= 0)
5566 bfd_get_symcount (abfd) = symcount;
5567 return symcount;
5570 long
5571 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
5572 bfd *abfd;
5573 asymbol **alocation;
5575 struct elf_backend_data *bed = get_elf_backend_data (abfd);
5576 long symcount = bed->s->slurp_symbol_table (abfd, alocation, true);
5578 if (symcount >= 0)
5579 bfd_get_dynamic_symcount (abfd) = symcount;
5580 return symcount;
5583 /* Return the size required for the dynamic reloc entries. Any
5584 section that was actually installed in the BFD, and has type
5585 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5586 considered to be a dynamic reloc section. */
5588 long
5589 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
5590 bfd *abfd;
5592 long ret;
5593 asection *s;
5595 if (elf_dynsymtab (abfd) == 0)
5597 bfd_set_error (bfd_error_invalid_operation);
5598 return -1;
5601 ret = sizeof (arelent *);
5602 for (s = abfd->sections; s != NULL; s = s->next)
5603 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5604 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5605 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5606 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
5607 * sizeof (arelent *));
5609 return ret;
5612 /* Canonicalize the dynamic relocation entries. Note that we return
5613 the dynamic relocations as a single block, although they are
5614 actually associated with particular sections; the interface, which
5615 was designed for SunOS style shared libraries, expects that there
5616 is only one set of dynamic relocs. Any section that was actually
5617 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5618 the dynamic symbol table, is considered to be a dynamic reloc
5619 section. */
5621 long
5622 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
5623 bfd *abfd;
5624 arelent **storage;
5625 asymbol **syms;
5627 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
5628 asection *s;
5629 long ret;
5631 if (elf_dynsymtab (abfd) == 0)
5633 bfd_set_error (bfd_error_invalid_operation);
5634 return -1;
5637 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
5638 ret = 0;
5639 for (s = abfd->sections; s != NULL; s = s->next)
5641 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5642 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5643 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
5645 arelent *p;
5646 long count, i;
5648 if (! (*slurp_relocs) (abfd, s, syms, true))
5649 return -1;
5650 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
5651 p = s->relocation;
5652 for (i = 0; i < count; i++)
5653 *storage++ = p++;
5654 ret += count;
5658 *storage = NULL;
5660 return ret;
5663 /* Read in the version information. */
5665 boolean
5666 _bfd_elf_slurp_version_tables (abfd)
5667 bfd *abfd;
5669 bfd_byte *contents = NULL;
5670 bfd_size_type amt;
5672 if (elf_dynverdef (abfd) != 0)
5674 Elf_Internal_Shdr *hdr;
5675 Elf_External_Verdef *everdef;
5676 Elf_Internal_Verdef *iverdef;
5677 Elf_Internal_Verdef *iverdefarr;
5678 Elf_Internal_Verdef iverdefmem;
5679 unsigned int i;
5680 unsigned int maxidx;
5682 hdr = &elf_tdata (abfd)->dynverdef_hdr;
5684 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5685 if (contents == NULL)
5686 goto error_return;
5687 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5688 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5689 goto error_return;
5691 /* We know the number of entries in the section but not the maximum
5692 index. Therefore we have to run through all entries and find
5693 the maximum. */
5694 everdef = (Elf_External_Verdef *) contents;
5695 maxidx = 0;
5696 for (i = 0; i < hdr->sh_info; ++i)
5698 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5700 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
5701 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
5703 everdef = ((Elf_External_Verdef *)
5704 ((bfd_byte *) everdef + iverdefmem.vd_next));
5707 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
5708 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *) bfd_zalloc (abfd, amt);
5709 if (elf_tdata (abfd)->verdef == NULL)
5710 goto error_return;
5712 elf_tdata (abfd)->cverdefs = maxidx;
5714 everdef = (Elf_External_Verdef *) contents;
5715 iverdefarr = elf_tdata (abfd)->verdef;
5716 for (i = 0; i < hdr->sh_info; i++)
5718 Elf_External_Verdaux *everdaux;
5719 Elf_Internal_Verdaux *iverdaux;
5720 unsigned int j;
5722 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
5724 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
5725 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
5727 iverdef->vd_bfd = abfd;
5729 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
5730 iverdef->vd_auxptr = (Elf_Internal_Verdaux *) bfd_alloc (abfd, amt);
5731 if (iverdef->vd_auxptr == NULL)
5732 goto error_return;
5734 everdaux = ((Elf_External_Verdaux *)
5735 ((bfd_byte *) everdef + iverdef->vd_aux));
5736 iverdaux = iverdef->vd_auxptr;
5737 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
5739 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
5741 iverdaux->vda_nodename =
5742 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5743 iverdaux->vda_name);
5744 if (iverdaux->vda_nodename == NULL)
5745 goto error_return;
5747 if (j + 1 < iverdef->vd_cnt)
5748 iverdaux->vda_nextptr = iverdaux + 1;
5749 else
5750 iverdaux->vda_nextptr = NULL;
5752 everdaux = ((Elf_External_Verdaux *)
5753 ((bfd_byte *) everdaux + iverdaux->vda_next));
5756 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
5758 if (i + 1 < hdr->sh_info)
5759 iverdef->vd_nextdef = iverdef + 1;
5760 else
5761 iverdef->vd_nextdef = NULL;
5763 everdef = ((Elf_External_Verdef *)
5764 ((bfd_byte *) everdef + iverdef->vd_next));
5767 free (contents);
5768 contents = NULL;
5771 if (elf_dynverref (abfd) != 0)
5773 Elf_Internal_Shdr *hdr;
5774 Elf_External_Verneed *everneed;
5775 Elf_Internal_Verneed *iverneed;
5776 unsigned int i;
5778 hdr = &elf_tdata (abfd)->dynverref_hdr;
5780 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
5781 elf_tdata (abfd)->verref =
5782 (Elf_Internal_Verneed *) bfd_zalloc (abfd, amt);
5783 if (elf_tdata (abfd)->verref == NULL)
5784 goto error_return;
5786 elf_tdata (abfd)->cverrefs = hdr->sh_info;
5788 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
5789 if (contents == NULL)
5790 goto error_return;
5791 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
5792 || bfd_bread ((PTR) contents, hdr->sh_size, abfd) != hdr->sh_size)
5793 goto error_return;
5795 everneed = (Elf_External_Verneed *) contents;
5796 iverneed = elf_tdata (abfd)->verref;
5797 for (i = 0; i < hdr->sh_info; i++, iverneed++)
5799 Elf_External_Vernaux *evernaux;
5800 Elf_Internal_Vernaux *ivernaux;
5801 unsigned int j;
5803 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
5805 iverneed->vn_bfd = abfd;
5807 iverneed->vn_filename =
5808 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5809 iverneed->vn_file);
5810 if (iverneed->vn_filename == NULL)
5811 goto error_return;
5813 amt = iverneed->vn_cnt;
5814 amt *= sizeof (Elf_Internal_Vernaux);
5815 iverneed->vn_auxptr = (Elf_Internal_Vernaux *) bfd_alloc (abfd, amt);
5817 evernaux = ((Elf_External_Vernaux *)
5818 ((bfd_byte *) everneed + iverneed->vn_aux));
5819 ivernaux = iverneed->vn_auxptr;
5820 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
5822 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
5824 ivernaux->vna_nodename =
5825 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
5826 ivernaux->vna_name);
5827 if (ivernaux->vna_nodename == NULL)
5828 goto error_return;
5830 if (j + 1 < iverneed->vn_cnt)
5831 ivernaux->vna_nextptr = ivernaux + 1;
5832 else
5833 ivernaux->vna_nextptr = NULL;
5835 evernaux = ((Elf_External_Vernaux *)
5836 ((bfd_byte *) evernaux + ivernaux->vna_next));
5839 if (i + 1 < hdr->sh_info)
5840 iverneed->vn_nextref = iverneed + 1;
5841 else
5842 iverneed->vn_nextref = NULL;
5844 everneed = ((Elf_External_Verneed *)
5845 ((bfd_byte *) everneed + iverneed->vn_next));
5848 free (contents);
5849 contents = NULL;
5852 return true;
5854 error_return:
5855 if (contents == NULL)
5856 free (contents);
5857 return false;
5860 asymbol *
5861 _bfd_elf_make_empty_symbol (abfd)
5862 bfd *abfd;
5864 elf_symbol_type *newsym;
5865 bfd_size_type amt = sizeof (elf_symbol_type);
5867 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
5868 if (!newsym)
5869 return NULL;
5870 else
5872 newsym->symbol.the_bfd = abfd;
5873 return &newsym->symbol;
5877 void
5878 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
5879 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5880 asymbol *symbol;
5881 symbol_info *ret;
5883 bfd_symbol_info (symbol, ret);
5886 /* Return whether a symbol name implies a local symbol. Most targets
5887 use this function for the is_local_label_name entry point, but some
5888 override it. */
5890 boolean
5891 _bfd_elf_is_local_label_name (abfd, name)
5892 bfd *abfd ATTRIBUTE_UNUSED;
5893 const char *name;
5895 /* Normal local symbols start with ``.L''. */
5896 if (name[0] == '.' && name[1] == 'L')
5897 return true;
5899 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
5900 DWARF debugging symbols starting with ``..''. */
5901 if (name[0] == '.' && name[1] == '.')
5902 return true;
5904 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
5905 emitting DWARF debugging output. I suspect this is actually a
5906 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
5907 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
5908 underscore to be emitted on some ELF targets). For ease of use,
5909 we treat such symbols as local. */
5910 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
5911 return true;
5913 return false;
5916 alent *
5917 _bfd_elf_get_lineno (ignore_abfd, symbol)
5918 bfd *ignore_abfd ATTRIBUTE_UNUSED;
5919 asymbol *symbol ATTRIBUTE_UNUSED;
5921 abort ();
5922 return NULL;
5925 boolean
5926 _bfd_elf_set_arch_mach (abfd, arch, machine)
5927 bfd *abfd;
5928 enum bfd_architecture arch;
5929 unsigned long machine;
5931 /* If this isn't the right architecture for this backend, and this
5932 isn't the generic backend, fail. */
5933 if (arch != get_elf_backend_data (abfd)->arch
5934 && arch != bfd_arch_unknown
5935 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
5936 return false;
5938 return bfd_default_set_arch_mach (abfd, arch, machine);
5941 /* Find the function to a particular section and offset,
5942 for error reporting. */
5944 static boolean
5945 elf_find_function (abfd, section, symbols, offset,
5946 filename_ptr, functionname_ptr)
5947 bfd *abfd ATTRIBUTE_UNUSED;
5948 asection *section;
5949 asymbol **symbols;
5950 bfd_vma offset;
5951 const char **filename_ptr;
5952 const char **functionname_ptr;
5954 const char *filename;
5955 asymbol *func;
5956 bfd_vma low_func;
5957 asymbol **p;
5959 filename = NULL;
5960 func = NULL;
5961 low_func = 0;
5963 for (p = symbols; *p != NULL; p++)
5965 elf_symbol_type *q;
5967 q = (elf_symbol_type *) *p;
5969 if (bfd_get_section (&q->symbol) != section)
5970 continue;
5972 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5974 default:
5975 break;
5976 case STT_FILE:
5977 filename = bfd_asymbol_name (&q->symbol);
5978 break;
5979 case STT_NOTYPE:
5980 case STT_FUNC:
5981 if (q->symbol.section == section
5982 && q->symbol.value >= low_func
5983 && q->symbol.value <= offset)
5985 func = (asymbol *) q;
5986 low_func = q->symbol.value;
5988 break;
5992 if (func == NULL)
5993 return false;
5995 if (filename_ptr)
5996 *filename_ptr = filename;
5997 if (functionname_ptr)
5998 *functionname_ptr = bfd_asymbol_name (func);
6000 return true;
6003 /* Find the nearest line to a particular section and offset,
6004 for error reporting. */
6006 boolean
6007 _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
6008 filename_ptr, functionname_ptr, line_ptr)
6009 bfd *abfd;
6010 asection *section;
6011 asymbol **symbols;
6012 bfd_vma offset;
6013 const char **filename_ptr;
6014 const char **functionname_ptr;
6015 unsigned int *line_ptr;
6017 boolean found;
6019 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
6020 filename_ptr, functionname_ptr,
6021 line_ptr))
6023 if (!*functionname_ptr)
6024 elf_find_function (abfd, section, symbols, offset,
6025 *filename_ptr ? NULL : filename_ptr,
6026 functionname_ptr);
6028 return true;
6031 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
6032 filename_ptr, functionname_ptr,
6033 line_ptr, 0,
6034 &elf_tdata (abfd)->dwarf2_find_line_info))
6036 if (!*functionname_ptr)
6037 elf_find_function (abfd, section, symbols, offset,
6038 *filename_ptr ? NULL : filename_ptr,
6039 functionname_ptr);
6041 return true;
6044 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
6045 &found, filename_ptr,
6046 functionname_ptr, line_ptr,
6047 &elf_tdata (abfd)->line_info))
6048 return false;
6049 if (found && (*functionname_ptr || *line_ptr))
6050 return true;
6052 if (symbols == NULL)
6053 return false;
6055 if (! elf_find_function (abfd, section, symbols, offset,
6056 filename_ptr, functionname_ptr))
6057 return false;
6059 *line_ptr = 0;
6060 return true;
6064 _bfd_elf_sizeof_headers (abfd, reloc)
6065 bfd *abfd;
6066 boolean reloc;
6068 int ret;
6070 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6071 if (! reloc)
6072 ret += get_program_header_size (abfd);
6073 return ret;
6076 boolean
6077 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
6078 bfd *abfd;
6079 sec_ptr section;
6080 PTR location;
6081 file_ptr offset;
6082 bfd_size_type count;
6084 Elf_Internal_Shdr *hdr;
6085 bfd_signed_vma pos;
6087 if (! abfd->output_has_begun
6088 && ! (_bfd_elf_compute_section_file_positions
6089 (abfd, (struct bfd_link_info *) NULL)))
6090 return false;
6092 hdr = &elf_section_data (section)->this_hdr;
6093 pos = hdr->sh_offset + offset;
6094 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6095 || bfd_bwrite (location, count, abfd) != count)
6096 return false;
6098 return true;
6101 void
6102 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
6103 bfd *abfd ATTRIBUTE_UNUSED;
6104 arelent *cache_ptr ATTRIBUTE_UNUSED;
6105 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
6107 abort ();
6110 #if 0
6111 void
6112 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
6113 bfd *abfd;
6114 arelent *cache_ptr;
6115 Elf_Internal_Rel *dst;
6117 abort ();
6119 #endif
6121 /* Try to convert a non-ELF reloc into an ELF one. */
6123 boolean
6124 _bfd_elf_validate_reloc (abfd, areloc)
6125 bfd *abfd;
6126 arelent *areloc;
6128 /* Check whether we really have an ELF howto. */
6130 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6132 bfd_reloc_code_real_type code;
6133 reloc_howto_type *howto;
6135 /* Alien reloc: Try to determine its type to replace it with an
6136 equivalent ELF reloc. */
6138 if (areloc->howto->pc_relative)
6140 switch (areloc->howto->bitsize)
6142 case 8:
6143 code = BFD_RELOC_8_PCREL;
6144 break;
6145 case 12:
6146 code = BFD_RELOC_12_PCREL;
6147 break;
6148 case 16:
6149 code = BFD_RELOC_16_PCREL;
6150 break;
6151 case 24:
6152 code = BFD_RELOC_24_PCREL;
6153 break;
6154 case 32:
6155 code = BFD_RELOC_32_PCREL;
6156 break;
6157 case 64:
6158 code = BFD_RELOC_64_PCREL;
6159 break;
6160 default:
6161 goto fail;
6164 howto = bfd_reloc_type_lookup (abfd, code);
6166 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6168 if (howto->pcrel_offset)
6169 areloc->addend += areloc->address;
6170 else
6171 areloc->addend -= areloc->address; /* addend is unsigned!! */
6174 else
6176 switch (areloc->howto->bitsize)
6178 case 8:
6179 code = BFD_RELOC_8;
6180 break;
6181 case 14:
6182 code = BFD_RELOC_14;
6183 break;
6184 case 16:
6185 code = BFD_RELOC_16;
6186 break;
6187 case 26:
6188 code = BFD_RELOC_26;
6189 break;
6190 case 32:
6191 code = BFD_RELOC_32;
6192 break;
6193 case 64:
6194 code = BFD_RELOC_64;
6195 break;
6196 default:
6197 goto fail;
6200 howto = bfd_reloc_type_lookup (abfd, code);
6203 if (howto)
6204 areloc->howto = howto;
6205 else
6206 goto fail;
6209 return true;
6211 fail:
6212 (*_bfd_error_handler)
6213 (_("%s: unsupported relocation type %s"),
6214 bfd_archive_filename (abfd), areloc->howto->name);
6215 bfd_set_error (bfd_error_bad_value);
6216 return false;
6219 boolean
6220 _bfd_elf_close_and_cleanup (abfd)
6221 bfd *abfd;
6223 if (bfd_get_format (abfd) == bfd_object)
6225 if (elf_shstrtab (abfd) != NULL)
6226 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6229 return _bfd_generic_close_and_cleanup (abfd);
6232 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6233 in the relocation's offset. Thus we cannot allow any sort of sanity
6234 range-checking to interfere. There is nothing else to do in processing
6235 this reloc. */
6237 bfd_reloc_status_type
6238 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
6239 bfd *abfd ATTRIBUTE_UNUSED;
6240 arelent *re ATTRIBUTE_UNUSED;
6241 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
6242 PTR data ATTRIBUTE_UNUSED;
6243 asection *is ATTRIBUTE_UNUSED;
6244 bfd *obfd ATTRIBUTE_UNUSED;
6245 char **errmsg ATTRIBUTE_UNUSED;
6247 return bfd_reloc_ok;
6250 /* Elf core file support. Much of this only works on native
6251 toolchains, since we rely on knowing the
6252 machine-dependent procfs structure in order to pick
6253 out details about the corefile. */
6255 #ifdef HAVE_SYS_PROCFS_H
6256 # include <sys/procfs.h>
6257 #endif
6259 /* FIXME: this is kinda wrong, but it's what gdb wants. */
6261 static int
6262 elfcore_make_pid (abfd)
6263 bfd *abfd;
6265 return ((elf_tdata (abfd)->core_lwpid << 16)
6266 + (elf_tdata (abfd)->core_pid));
6269 /* If there isn't a section called NAME, make one, using
6270 data from SECT. Note, this function will generate a
6271 reference to NAME, so you shouldn't deallocate or
6272 overwrite it. */
6274 static boolean
6275 elfcore_maybe_make_sect (abfd, name, sect)
6276 bfd *abfd;
6277 char *name;
6278 asection *sect;
6280 asection *sect2;
6282 if (bfd_get_section_by_name (abfd, name) != NULL)
6283 return true;
6285 sect2 = bfd_make_section (abfd, name);
6286 if (sect2 == NULL)
6287 return false;
6289 sect2->_raw_size = sect->_raw_size;
6290 sect2->filepos = sect->filepos;
6291 sect2->flags = sect->flags;
6292 sect2->alignment_power = sect->alignment_power;
6293 return true;
6296 /* Create a pseudosection containing SIZE bytes at FILEPOS. This
6297 actually creates up to two pseudosections:
6298 - For the single-threaded case, a section named NAME, unless
6299 such a section already exists.
6300 - For the multi-threaded case, a section named "NAME/PID", where
6301 PID is elfcore_make_pid (abfd).
6302 Both pseudosections have identical contents. */
6303 boolean
6304 _bfd_elfcore_make_pseudosection (abfd, name, size, filepos)
6305 bfd *abfd;
6306 char *name;
6307 size_t size;
6308 ufile_ptr filepos;
6310 char buf[100];
6311 char *threaded_name;
6312 size_t len;
6313 asection *sect;
6315 /* Build the section name. */
6317 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
6318 len = strlen (buf) + 1;
6319 threaded_name = bfd_alloc (abfd, (bfd_size_type) len);
6320 if (threaded_name == NULL)
6321 return false;
6322 memcpy (threaded_name, buf, len);
6324 sect = bfd_make_section (abfd, threaded_name);
6325 if (sect == NULL)
6326 return false;
6327 sect->_raw_size = size;
6328 sect->filepos = filepos;
6329 sect->flags = SEC_HAS_CONTENTS;
6330 sect->alignment_power = 2;
6332 return elfcore_maybe_make_sect (abfd, name, sect);
6335 /* prstatus_t exists on:
6336 solaris 2.5+
6337 linux 2.[01] + glibc
6338 unixware 4.2
6341 #if defined (HAVE_PRSTATUS_T)
6342 static boolean elfcore_grok_prstatus PARAMS ((bfd *, Elf_Internal_Note *));
6344 static boolean
6345 elfcore_grok_prstatus (abfd, note)
6346 bfd *abfd;
6347 Elf_Internal_Note *note;
6349 size_t raw_size;
6350 int offset;
6352 if (note->descsz == sizeof (prstatus_t))
6354 prstatus_t prstat;
6356 raw_size = sizeof (prstat.pr_reg);
6357 offset = offsetof (prstatus_t, pr_reg);
6358 memcpy (&prstat, note->descdata, sizeof (prstat));
6360 /* Do not overwrite the core signal if it
6361 has already been set by another thread. */
6362 if (elf_tdata (abfd)->core_signal == 0)
6363 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6364 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6366 /* pr_who exists on:
6367 solaris 2.5+
6368 unixware 4.2
6369 pr_who doesn't exist on:
6370 linux 2.[01]
6372 #if defined (HAVE_PRSTATUS_T_PR_WHO)
6373 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6374 #endif
6376 #if defined (HAVE_PRSTATUS32_T)
6377 else if (note->descsz == sizeof (prstatus32_t))
6379 /* 64-bit host, 32-bit corefile */
6380 prstatus32_t prstat;
6382 raw_size = sizeof (prstat.pr_reg);
6383 offset = offsetof (prstatus32_t, pr_reg);
6384 memcpy (&prstat, note->descdata, sizeof (prstat));
6386 /* Do not overwrite the core signal if it
6387 has already been set by another thread. */
6388 if (elf_tdata (abfd)->core_signal == 0)
6389 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
6390 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6392 /* pr_who exists on:
6393 solaris 2.5+
6394 unixware 4.2
6395 pr_who doesn't exist on:
6396 linux 2.[01]
6398 #if defined (HAVE_PRSTATUS32_T_PR_WHO)
6399 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6400 #endif
6402 #endif /* HAVE_PRSTATUS32_T */
6403 else
6405 /* Fail - we don't know how to handle any other
6406 note size (ie. data object type). */
6407 return true;
6410 /* Make a ".reg/999" section and a ".reg" section. */
6411 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
6412 raw_size, note->descpos + offset);
6414 #endif /* defined (HAVE_PRSTATUS_T) */
6416 /* Create a pseudosection containing the exact contents of NOTE. */
6417 static boolean
6418 elfcore_make_note_pseudosection (abfd, name, note)
6419 bfd *abfd;
6420 char *name;
6421 Elf_Internal_Note *note;
6423 return _bfd_elfcore_make_pseudosection (abfd, name,
6424 note->descsz, note->descpos);
6427 /* There isn't a consistent prfpregset_t across platforms,
6428 but it doesn't matter, because we don't have to pick this
6429 data structure apart. */
6431 static boolean
6432 elfcore_grok_prfpreg (abfd, note)
6433 bfd *abfd;
6434 Elf_Internal_Note *note;
6436 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6439 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6440 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6441 literally. */
6443 static boolean
6444 elfcore_grok_prxfpreg (abfd, note)
6445 bfd *abfd;
6446 Elf_Internal_Note *note;
6448 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6451 #if defined (HAVE_PRPSINFO_T)
6452 typedef prpsinfo_t elfcore_psinfo_t;
6453 #if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
6454 typedef prpsinfo32_t elfcore_psinfo32_t;
6455 #endif
6456 #endif
6458 #if defined (HAVE_PSINFO_T)
6459 typedef psinfo_t elfcore_psinfo_t;
6460 #if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
6461 typedef psinfo32_t elfcore_psinfo32_t;
6462 #endif
6463 #endif
6465 /* return a malloc'ed copy of a string at START which is at
6466 most MAX bytes long, possibly without a terminating '\0'.
6467 the copy will always have a terminating '\0'. */
6469 char *
6470 _bfd_elfcore_strndup (abfd, start, max)
6471 bfd *abfd;
6472 char *start;
6473 size_t max;
6475 char *dups;
6476 char *end = memchr (start, '\0', max);
6477 size_t len;
6479 if (end == NULL)
6480 len = max;
6481 else
6482 len = end - start;
6484 dups = bfd_alloc (abfd, (bfd_size_type) len + 1);
6485 if (dups == NULL)
6486 return NULL;
6488 memcpy (dups, start, len);
6489 dups[len] = '\0';
6491 return dups;
6494 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6495 static boolean elfcore_grok_psinfo PARAMS ((bfd *, Elf_Internal_Note *));
6497 static boolean
6498 elfcore_grok_psinfo (abfd, note)
6499 bfd *abfd;
6500 Elf_Internal_Note *note;
6502 if (note->descsz == sizeof (elfcore_psinfo_t))
6504 elfcore_psinfo_t psinfo;
6506 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6508 elf_tdata (abfd)->core_program
6509 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6510 sizeof (psinfo.pr_fname));
6512 elf_tdata (abfd)->core_command
6513 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6514 sizeof (psinfo.pr_psargs));
6516 #if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
6517 else if (note->descsz == sizeof (elfcore_psinfo32_t))
6519 /* 64-bit host, 32-bit corefile */
6520 elfcore_psinfo32_t psinfo;
6522 memcpy (&psinfo, note->descdata, sizeof (psinfo));
6524 elf_tdata (abfd)->core_program
6525 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6526 sizeof (psinfo.pr_fname));
6528 elf_tdata (abfd)->core_command
6529 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6530 sizeof (psinfo.pr_psargs));
6532 #endif
6534 else
6536 /* Fail - we don't know how to handle any other
6537 note size (ie. data object type). */
6538 return true;
6541 /* Note that for some reason, a spurious space is tacked
6542 onto the end of the args in some (at least one anyway)
6543 implementations, so strip it off if it exists. */
6546 char *command = elf_tdata (abfd)->core_command;
6547 int n = strlen (command);
6549 if (0 < n && command[n - 1] == ' ')
6550 command[n - 1] = '\0';
6553 return true;
6555 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6557 #if defined (HAVE_PSTATUS_T)
6558 static boolean elfcore_grok_pstatus PARAMS ((bfd *, Elf_Internal_Note *));
6560 static boolean
6561 elfcore_grok_pstatus (abfd, note)
6562 bfd *abfd;
6563 Elf_Internal_Note *note;
6565 if (note->descsz == sizeof (pstatus_t)
6566 #if defined (HAVE_PXSTATUS_T)
6567 || note->descsz == sizeof (pxstatus_t)
6568 #endif
6571 pstatus_t pstat;
6573 memcpy (&pstat, note->descdata, sizeof (pstat));
6575 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6577 #if defined (HAVE_PSTATUS32_T)
6578 else if (note->descsz == sizeof (pstatus32_t))
6580 /* 64-bit host, 32-bit corefile */
6581 pstatus32_t pstat;
6583 memcpy (&pstat, note->descdata, sizeof (pstat));
6585 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6587 #endif
6588 /* Could grab some more details from the "representative"
6589 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
6590 NT_LWPSTATUS note, presumably. */
6592 return true;
6594 #endif /* defined (HAVE_PSTATUS_T) */
6596 #if defined (HAVE_LWPSTATUS_T)
6597 static boolean elfcore_grok_lwpstatus PARAMS ((bfd *, Elf_Internal_Note *));
6599 static boolean
6600 elfcore_grok_lwpstatus (abfd, note)
6601 bfd *abfd;
6602 Elf_Internal_Note *note;
6604 lwpstatus_t lwpstat;
6605 char buf[100];
6606 char *name;
6607 size_t len;
6608 asection *sect;
6610 if (note->descsz != sizeof (lwpstat)
6611 #if defined (HAVE_LWPXSTATUS_T)
6612 && note->descsz != sizeof (lwpxstatus_t)
6613 #endif
6615 return true;
6617 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6619 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6620 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6622 /* Make a ".reg/999" section. */
6624 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
6625 len = strlen (buf) + 1;
6626 name = bfd_alloc (abfd, (bfd_size_type) len);
6627 if (name == NULL)
6628 return false;
6629 memcpy (name, buf, len);
6631 sect = bfd_make_section (abfd, name);
6632 if (sect == NULL)
6633 return false;
6635 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6636 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
6637 sect->filepos = note->descpos
6638 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6639 #endif
6641 #if defined (HAVE_LWPSTATUS_T_PR_REG)
6642 sect->_raw_size = sizeof (lwpstat.pr_reg);
6643 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6644 #endif
6646 sect->flags = SEC_HAS_CONTENTS;
6647 sect->alignment_power = 2;
6649 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
6650 return false;
6652 /* Make a ".reg2/999" section */
6654 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
6655 len = strlen (buf) + 1;
6656 name = bfd_alloc (abfd, (bfd_size_type) len);
6657 if (name == NULL)
6658 return false;
6659 memcpy (name, buf, len);
6661 sect = bfd_make_section (abfd, name);
6662 if (sect == NULL)
6663 return false;
6665 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
6666 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
6667 sect->filepos = note->descpos
6668 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6669 #endif
6671 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
6672 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
6673 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6674 #endif
6676 sect->flags = SEC_HAS_CONTENTS;
6677 sect->alignment_power = 2;
6679 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
6681 #endif /* defined (HAVE_LWPSTATUS_T) */
6683 #if defined (HAVE_WIN32_PSTATUS_T)
6684 static boolean
6685 elfcore_grok_win32pstatus (abfd, note)
6686 bfd *abfd;
6687 Elf_Internal_Note *note;
6689 char buf[30];
6690 char *name;
6691 size_t len;
6692 asection *sect;
6693 win32_pstatus_t pstatus;
6695 if (note->descsz < sizeof (pstatus))
6696 return true;
6698 memcpy (&pstatus, note->descdata, sizeof (pstatus));
6700 switch (pstatus.data_type)
6702 case NOTE_INFO_PROCESS:
6703 /* FIXME: need to add ->core_command. */
6704 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
6705 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
6706 break;
6708 case NOTE_INFO_THREAD:
6709 /* Make a ".reg/999" section. */
6710 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
6712 len = strlen (buf) + 1;
6713 name = bfd_alloc (abfd, (bfd_size_type) len);
6714 if (name == NULL)
6715 return false;
6717 memcpy (name, buf, len);
6719 sect = bfd_make_section (abfd, name);
6720 if (sect == NULL)
6721 return false;
6723 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
6724 sect->filepos = (note->descpos
6725 + offsetof (struct win32_pstatus,
6726 data.thread_info.thread_context));
6727 sect->flags = SEC_HAS_CONTENTS;
6728 sect->alignment_power = 2;
6730 if (pstatus.data.thread_info.is_active_thread)
6731 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
6732 return false;
6733 break;
6735 case NOTE_INFO_MODULE:
6736 /* Make a ".module/xxxxxxxx" section. */
6737 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
6739 len = strlen (buf) + 1;
6740 name = bfd_alloc (abfd, (bfd_size_type) len);
6741 if (name == NULL)
6742 return false;
6744 memcpy (name, buf, len);
6746 sect = bfd_make_section (abfd, name);
6748 if (sect == NULL)
6749 return false;
6751 sect->_raw_size = note->descsz;
6752 sect->filepos = note->descpos;
6753 sect->flags = SEC_HAS_CONTENTS;
6754 sect->alignment_power = 2;
6755 break;
6757 default:
6758 return true;
6761 return true;
6763 #endif /* HAVE_WIN32_PSTATUS_T */
6765 static boolean
6766 elfcore_grok_note (abfd, note)
6767 bfd *abfd;
6768 Elf_Internal_Note *note;
6770 struct elf_backend_data *bed = get_elf_backend_data (abfd);
6772 switch (note->type)
6774 default:
6775 return true;
6777 case NT_PRSTATUS:
6778 if (bed->elf_backend_grok_prstatus)
6779 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
6780 return true;
6781 #if defined (HAVE_PRSTATUS_T)
6782 return elfcore_grok_prstatus (abfd, note);
6783 #else
6784 return true;
6785 #endif
6787 #if defined (HAVE_PSTATUS_T)
6788 case NT_PSTATUS:
6789 return elfcore_grok_pstatus (abfd, note);
6790 #endif
6792 #if defined (HAVE_LWPSTATUS_T)
6793 case NT_LWPSTATUS:
6794 return elfcore_grok_lwpstatus (abfd, note);
6795 #endif
6797 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
6798 return elfcore_grok_prfpreg (abfd, note);
6800 #if defined (HAVE_WIN32_PSTATUS_T)
6801 case NT_WIN32PSTATUS:
6802 return elfcore_grok_win32pstatus (abfd, note);
6803 #endif
6805 case NT_PRXFPREG: /* Linux SSE extension */
6806 if (note->namesz == 5
6807 && ! strcmp (note->namedata, "LINUX"))
6808 return elfcore_grok_prxfpreg (abfd, note);
6809 else
6810 return true;
6812 case NT_PRPSINFO:
6813 case NT_PSINFO:
6814 if (bed->elf_backend_grok_psinfo)
6815 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
6816 return true;
6817 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6818 return elfcore_grok_psinfo (abfd, note);
6819 #else
6820 return true;
6821 #endif
6825 static boolean
6826 elfcore_netbsd_get_lwpid (note, lwpidp)
6827 Elf_Internal_Note *note;
6828 int *lwpidp;
6830 char *cp;
6832 cp = strchr (note->namedata, '@');
6833 if (cp != NULL)
6835 *lwpidp = atoi(cp + 1);
6836 return true;
6838 return false;
6841 static boolean
6842 elfcore_grok_netbsd_procinfo (abfd, note)
6843 bfd *abfd;
6844 Elf_Internal_Note *note;
6847 /* Signal number at offset 0x08. */
6848 elf_tdata (abfd)->core_signal
6849 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
6851 /* Process ID at offset 0x50. */
6852 elf_tdata (abfd)->core_pid
6853 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
6855 /* Command name at 0x7c (max 32 bytes, including nul). */
6856 elf_tdata (abfd)->core_command
6857 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
6859 return true;
6862 static boolean
6863 elfcore_grok_netbsd_note (abfd, note)
6864 bfd *abfd;
6865 Elf_Internal_Note *note;
6867 int lwp;
6869 if (elfcore_netbsd_get_lwpid (note, &lwp))
6870 elf_tdata (abfd)->core_lwpid = lwp;
6872 if (note->type == NT_NETBSDCORE_PROCINFO)
6874 /* NetBSD-specific core "procinfo". Note that we expect to
6875 find this note before any of the others, which is fine,
6876 since the kernel writes this note out first when it
6877 creates a core file. */
6879 return elfcore_grok_netbsd_procinfo (abfd, note);
6882 /* As of Jan 2002 there are no other machine-independent notes
6883 defined for NetBSD core files. If the note type is less
6884 than the start of the machine-dependent note types, we don't
6885 understand it. */
6887 if (note->type < NT_NETBSDCORE_FIRSTMACH)
6888 return true;
6891 switch (bfd_get_arch (abfd))
6893 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
6894 PT_GETFPREGS == mach+2. */
6896 case bfd_arch_alpha:
6897 case bfd_arch_sparc:
6898 switch (note->type)
6900 case NT_NETBSDCORE_FIRSTMACH+0:
6901 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6903 case NT_NETBSDCORE_FIRSTMACH+2:
6904 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6906 default:
6907 return true;
6910 /* On all other arch's, PT_GETREGS == mach+1 and
6911 PT_GETFPREGS == mach+3. */
6913 default:
6914 switch (note->type)
6916 case NT_NETBSDCORE_FIRSTMACH+1:
6917 return elfcore_make_note_pseudosection (abfd, ".reg", note);
6919 case NT_NETBSDCORE_FIRSTMACH+3:
6920 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6922 default:
6923 return true;
6926 /* NOTREACHED */
6929 /* Function: elfcore_write_note
6931 Inputs:
6932 buffer to hold note
6933 name of note
6934 type of note
6935 data for note
6936 size of data for note
6938 Return:
6939 End of buffer containing note. */
6941 char *
6942 elfcore_write_note (abfd, buf, bufsiz, name, type, input, size)
6943 bfd *abfd;
6944 char *buf;
6945 int *bufsiz;
6946 const char *name;
6947 int type;
6948 const PTR input;
6949 int size;
6951 Elf_External_Note *xnp;
6952 size_t namesz;
6953 size_t pad;
6954 size_t newspace;
6955 char *p, *dest;
6957 namesz = 0;
6958 pad = 0;
6959 if (name != NULL)
6961 struct elf_backend_data *bed;
6963 namesz = strlen (name) + 1;
6964 bed = get_elf_backend_data (abfd);
6965 pad = -namesz & (bed->s->file_align - 1);
6968 newspace = sizeof (Elf_External_Note) - 1 + namesz + pad + size;
6970 p = realloc (buf, *bufsiz + newspace);
6971 dest = p + *bufsiz;
6972 *bufsiz += newspace;
6973 xnp = (Elf_External_Note *) dest;
6974 H_PUT_32 (abfd, namesz, xnp->namesz);
6975 H_PUT_32 (abfd, size, xnp->descsz);
6976 H_PUT_32 (abfd, type, xnp->type);
6977 dest = xnp->name;
6978 if (name != NULL)
6980 memcpy (dest, name, namesz);
6981 dest += namesz;
6982 while (pad != 0)
6984 *dest++ = '\0';
6985 --pad;
6988 memcpy (dest, input, size);
6989 return p;
6992 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
6993 char *
6994 elfcore_write_prpsinfo (abfd, buf, bufsiz, fname, psargs)
6995 bfd *abfd;
6996 char *buf;
6997 int *bufsiz;
6998 const char *fname;
6999 const char *psargs;
7001 int note_type;
7002 char *note_name = "CORE";
7004 #if defined (HAVE_PSINFO_T)
7005 psinfo_t data;
7006 note_type = NT_PSINFO;
7007 #else
7008 prpsinfo_t data;
7009 note_type = NT_PRPSINFO;
7010 #endif
7012 memset (&data, 0, sizeof (data));
7013 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7014 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
7015 return elfcore_write_note (abfd, buf, bufsiz,
7016 note_name, note_type, &data, sizeof (data));
7018 #endif /* PSINFO_T or PRPSINFO_T */
7020 #if defined (HAVE_PRSTATUS_T)
7021 char *
7022 elfcore_write_prstatus (abfd, buf, bufsiz, pid, cursig, gregs)
7023 bfd *abfd;
7024 char *buf;
7025 int *bufsiz;
7026 long pid;
7027 int cursig;
7028 const PTR gregs;
7030 prstatus_t prstat;
7031 char *note_name = "CORE";
7033 memset (&prstat, 0, sizeof (prstat));
7034 prstat.pr_pid = pid;
7035 prstat.pr_cursig = cursig;
7036 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
7037 return elfcore_write_note (abfd, buf, bufsiz,
7038 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7040 #endif /* HAVE_PRSTATUS_T */
7042 #if defined (HAVE_LWPSTATUS_T)
7043 char *
7044 elfcore_write_lwpstatus (abfd, buf, bufsiz, pid, cursig, gregs)
7045 bfd *abfd;
7046 char *buf;
7047 int *bufsiz;
7048 long pid;
7049 int cursig;
7050 const PTR gregs;
7052 lwpstatus_t lwpstat;
7053 char *note_name = "CORE";
7055 memset (&lwpstat, 0, sizeof (lwpstat));
7056 lwpstat.pr_lwpid = pid >> 16;
7057 lwpstat.pr_cursig = cursig;
7058 #if defined (HAVE_LWPSTATUS_T_PR_REG)
7059 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7060 #elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7061 #if !defined(gregs)
7062 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7063 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7064 #else
7065 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7066 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7067 #endif
7068 #endif
7069 return elfcore_write_note (abfd, buf, bufsiz, note_name,
7070 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7072 #endif /* HAVE_LWPSTATUS_T */
7074 #if defined (HAVE_PSTATUS_T)
7075 char *
7076 elfcore_write_pstatus (abfd, buf, bufsiz, pid, cursig, gregs)
7077 bfd *abfd;
7078 char *buf;
7079 int *bufsiz;
7080 long pid;
7081 int cursig;
7082 const PTR gregs;
7084 pstatus_t pstat;
7085 char *note_name = "CORE";
7087 memset (&pstat, 0, sizeof (pstat));
7088 pstat.pr_pid = pid & 0xffff;
7089 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
7090 NT_PSTATUS, &pstat, sizeof (pstat));
7091 return buf;
7093 #endif /* HAVE_PSTATUS_T */
7095 char *
7096 elfcore_write_prfpreg (abfd, buf, bufsiz, fpregs, size)
7097 bfd *abfd;
7098 char *buf;
7099 int *bufsiz;
7100 const PTR fpregs;
7101 int size;
7103 char *note_name = "CORE";
7104 return elfcore_write_note (abfd, buf, bufsiz,
7105 note_name, NT_FPREGSET, fpregs, size);
7108 char *
7109 elfcore_write_prxfpreg (abfd, buf, bufsiz, xfpregs, size)
7110 bfd *abfd;
7111 char *buf;
7112 int *bufsiz;
7113 const PTR xfpregs;
7114 int size;
7116 char *note_name = "LINUX";
7117 return elfcore_write_note (abfd, buf, bufsiz,
7118 note_name, NT_PRXFPREG, xfpregs, size);
7121 static boolean
7122 elfcore_read_notes (abfd, offset, size)
7123 bfd *abfd;
7124 file_ptr offset;
7125 bfd_size_type size;
7127 char *buf;
7128 char *p;
7130 if (size <= 0)
7131 return true;
7133 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
7134 return false;
7136 buf = bfd_malloc (size);
7137 if (buf == NULL)
7138 return false;
7140 if (bfd_bread (buf, size, abfd) != size)
7142 error:
7143 free (buf);
7144 return false;
7147 p = buf;
7148 while (p < buf + size)
7150 /* FIXME: bad alignment assumption. */
7151 Elf_External_Note *xnp = (Elf_External_Note *) p;
7152 Elf_Internal_Note in;
7154 in.type = H_GET_32 (abfd, xnp->type);
7156 in.namesz = H_GET_32 (abfd, xnp->namesz);
7157 in.namedata = xnp->name;
7159 in.descsz = H_GET_32 (abfd, xnp->descsz);
7160 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7161 in.descpos = offset + (in.descdata - buf);
7163 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7165 if (! elfcore_grok_netbsd_note (abfd, &in))
7166 goto error;
7168 else
7170 if (! elfcore_grok_note (abfd, &in))
7171 goto error;
7174 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7177 free (buf);
7178 return true;
7181 /* Providing external access to the ELF program header table. */
7183 /* Return an upper bound on the number of bytes required to store a
7184 copy of ABFD's program header table entries. Return -1 if an error
7185 occurs; bfd_get_error will return an appropriate code. */
7187 long
7188 bfd_get_elf_phdr_upper_bound (abfd)
7189 bfd *abfd;
7191 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7193 bfd_set_error (bfd_error_wrong_format);
7194 return -1;
7197 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
7200 /* Copy ABFD's program header table entries to *PHDRS. The entries
7201 will be stored as an array of Elf_Internal_Phdr structures, as
7202 defined in include/elf/internal.h. To find out how large the
7203 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7205 Return the number of program header table entries read, or -1 if an
7206 error occurs; bfd_get_error will return an appropriate code. */
7209 bfd_get_elf_phdrs (abfd, phdrs)
7210 bfd *abfd;
7211 void *phdrs;
7213 int num_phdrs;
7215 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7217 bfd_set_error (bfd_error_wrong_format);
7218 return -1;
7221 num_phdrs = elf_elfheader (abfd)->e_phnum;
7222 memcpy (phdrs, elf_tdata (abfd)->phdr,
7223 num_phdrs * sizeof (Elf_Internal_Phdr));
7225 return num_phdrs;
7228 void
7229 _bfd_elf_sprintf_vma (abfd, buf, value)
7230 bfd *abfd ATTRIBUTE_UNUSED;
7231 char *buf;
7232 bfd_vma value;
7234 #ifdef BFD64
7235 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7237 i_ehdrp = elf_elfheader (abfd);
7238 if (i_ehdrp == NULL)
7239 sprintf_vma (buf, value);
7240 else
7242 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7244 #if BFD_HOST_64BIT_LONG
7245 sprintf (buf, "%016lx", value);
7246 #else
7247 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7248 _bfd_int64_low (value));
7249 #endif
7251 else
7252 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7254 #else
7255 sprintf_vma (buf, value);
7256 #endif
7259 void
7260 _bfd_elf_fprintf_vma (abfd, stream, value)
7261 bfd *abfd ATTRIBUTE_UNUSED;
7262 PTR stream;
7263 bfd_vma value;
7265 #ifdef BFD64
7266 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7268 i_ehdrp = elf_elfheader (abfd);
7269 if (i_ehdrp == NULL)
7270 fprintf_vma ((FILE *) stream, value);
7271 else
7273 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
7275 #if BFD_HOST_64BIT_LONG
7276 fprintf ((FILE *) stream, "%016lx", value);
7277 #else
7278 fprintf ((FILE *) stream, "%08lx%08lx",
7279 _bfd_int64_high (value), _bfd_int64_low (value));
7280 #endif
7282 else
7283 fprintf ((FILE *) stream, "%08lx",
7284 (unsigned long) (value & 0xffffffff));
7286 #else
7287 fprintf_vma ((FILE *) stream, value);
7288 #endif
7291 enum elf_reloc_type_class
7292 _bfd_elf_reloc_type_class (rela)
7293 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED;
7295 return reloc_class_normal;
7298 /* For RELA architectures, return the relocation value for a
7299 relocation against a local symbol. */
7301 bfd_vma
7302 _bfd_elf_rela_local_sym (abfd, sym, sec, rel)
7303 bfd *abfd;
7304 Elf_Internal_Sym *sym;
7305 asection *sec;
7306 Elf_Internal_Rela *rel;
7308 bfd_vma relocation;
7310 relocation = (sec->output_section->vma
7311 + sec->output_offset
7312 + sym->st_value);
7313 if ((sec->flags & SEC_MERGE)
7314 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
7315 && elf_section_data (sec)->sec_info_type == ELF_INFO_TYPE_MERGE)
7317 asection *msec;
7319 msec = sec;
7320 rel->r_addend =
7321 _bfd_merged_section_offset (abfd, &msec,
7322 elf_section_data (sec)->sec_info,
7323 sym->st_value + rel->r_addend,
7324 (bfd_vma) 0)
7325 - relocation;
7326 rel->r_addend += msec->output_section->vma + msec->output_offset;
7328 return relocation;
7331 bfd_vma
7332 _bfd_elf_rel_local_sym (abfd, sym, psec, addend)
7333 bfd *abfd;
7334 Elf_Internal_Sym *sym;
7335 asection **psec;
7336 bfd_vma addend;
7338 asection *sec = *psec;
7340 if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_MERGE)
7341 return sym->st_value + addend;
7343 return _bfd_merged_section_offset (abfd, psec,
7344 elf_section_data (sec)->sec_info,
7345 sym->st_value + addend, (bfd_vma) 0);
7348 bfd_vma
7349 _bfd_elf_section_offset (abfd, info, sec, offset)
7350 bfd *abfd;
7351 struct bfd_link_info *info;
7352 asection *sec;
7353 bfd_vma offset;
7355 struct bfd_elf_section_data *sec_data;
7357 sec_data = elf_section_data (sec);
7358 switch (sec_data->sec_info_type)
7360 case ELF_INFO_TYPE_STABS:
7361 return _bfd_stab_section_offset
7362 (abfd, &elf_hash_table (info)->merge_info, sec, &sec_data->sec_info,
7363 offset);
7364 case ELF_INFO_TYPE_EH_FRAME:
7365 return _bfd_elf_eh_frame_section_offset (abfd, sec, offset);
7366 default:
7367 return offset;