1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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
35 #define _SYSCALL32 /* For Sparc64-cross-32 */
45 static INLINE struct elf_segment_map *make_mapping
46 PARAMS ((bfd *, asection **, unsigned int, unsigned int, boolean));
47 static boolean map_sections_to_segments PARAMS ((bfd *));
48 static int elf_sort_sections PARAMS ((const PTR, const PTR));
49 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
50 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
51 static boolean prep_headers PARAMS ((bfd *));
52 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **, int));
53 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
54 static char *elf_read PARAMS ((bfd *, long, unsigned int));
55 static void elf_fake_sections PARAMS ((bfd *, asection *, PTR));
56 static boolean assign_section_numbers PARAMS ((bfd *));
57 static INLINE int sym_is_global PARAMS ((bfd *, asymbol *));
58 static boolean elf_map_symbols PARAMS ((bfd *));
59 static bfd_size_type get_program_header_size PARAMS ((bfd *));
60 static boolean elfcore_read_notes PARAMS ((bfd *, bfd_vma, bfd_vma));
62 /* Swap version information in and out. The version information is
63 currently size independent. If that ever changes, this code will
64 need to move into elfcode.h. */
66 /* Swap in a Verdef structure. */
69 _bfd_elf_swap_verdef_in (abfd, src, dst)
71 const Elf_External_Verdef *src;
72 Elf_Internal_Verdef *dst;
74 dst->vd_version = bfd_h_get_16 (abfd, src->vd_version);
75 dst->vd_flags = bfd_h_get_16 (abfd, src->vd_flags);
76 dst->vd_ndx = bfd_h_get_16 (abfd, src->vd_ndx);
77 dst->vd_cnt = bfd_h_get_16 (abfd, src->vd_cnt);
78 dst->vd_hash = bfd_h_get_32 (abfd, src->vd_hash);
79 dst->vd_aux = bfd_h_get_32 (abfd, src->vd_aux);
80 dst->vd_next = bfd_h_get_32 (abfd, src->vd_next);
83 /* Swap out a Verdef structure. */
86 _bfd_elf_swap_verdef_out (abfd, src, dst)
88 const Elf_Internal_Verdef *src;
89 Elf_External_Verdef *dst;
91 bfd_h_put_16 (abfd, src->vd_version, dst->vd_version);
92 bfd_h_put_16 (abfd, src->vd_flags, dst->vd_flags);
93 bfd_h_put_16 (abfd, src->vd_ndx, dst->vd_ndx);
94 bfd_h_put_16 (abfd, src->vd_cnt, dst->vd_cnt);
95 bfd_h_put_32 (abfd, src->vd_hash, dst->vd_hash);
96 bfd_h_put_32 (abfd, src->vd_aux, dst->vd_aux);
97 bfd_h_put_32 (abfd, src->vd_next, dst->vd_next);
100 /* Swap in a Verdaux structure. */
103 _bfd_elf_swap_verdaux_in (abfd, src, dst)
105 const Elf_External_Verdaux *src;
106 Elf_Internal_Verdaux *dst;
108 dst->vda_name = bfd_h_get_32 (abfd, src->vda_name);
109 dst->vda_next = bfd_h_get_32 (abfd, src->vda_next);
112 /* Swap out a Verdaux structure. */
115 _bfd_elf_swap_verdaux_out (abfd, src, dst)
117 const Elf_Internal_Verdaux *src;
118 Elf_External_Verdaux *dst;
120 bfd_h_put_32 (abfd, src->vda_name, dst->vda_name);
121 bfd_h_put_32 (abfd, src->vda_next, dst->vda_next);
124 /* Swap in a Verneed structure. */
127 _bfd_elf_swap_verneed_in (abfd, src, dst)
129 const Elf_External_Verneed *src;
130 Elf_Internal_Verneed *dst;
132 dst->vn_version = bfd_h_get_16 (abfd, src->vn_version);
133 dst->vn_cnt = bfd_h_get_16 (abfd, src->vn_cnt);
134 dst->vn_file = bfd_h_get_32 (abfd, src->vn_file);
135 dst->vn_aux = bfd_h_get_32 (abfd, src->vn_aux);
136 dst->vn_next = bfd_h_get_32 (abfd, src->vn_next);
139 /* Swap out a Verneed structure. */
142 _bfd_elf_swap_verneed_out (abfd, src, dst)
144 const Elf_Internal_Verneed *src;
145 Elf_External_Verneed *dst;
147 bfd_h_put_16 (abfd, src->vn_version, dst->vn_version);
148 bfd_h_put_16 (abfd, src->vn_cnt, dst->vn_cnt);
149 bfd_h_put_32 (abfd, src->vn_file, dst->vn_file);
150 bfd_h_put_32 (abfd, src->vn_aux, dst->vn_aux);
151 bfd_h_put_32 (abfd, src->vn_next, dst->vn_next);
154 /* Swap in a Vernaux structure. */
157 _bfd_elf_swap_vernaux_in (abfd, src, dst)
159 const Elf_External_Vernaux *src;
160 Elf_Internal_Vernaux *dst;
162 dst->vna_hash = bfd_h_get_32 (abfd, src->vna_hash);
163 dst->vna_flags = bfd_h_get_16 (abfd, src->vna_flags);
164 dst->vna_other = bfd_h_get_16 (abfd, src->vna_other);
165 dst->vna_name = bfd_h_get_32 (abfd, src->vna_name);
166 dst->vna_next = bfd_h_get_32 (abfd, src->vna_next);
169 /* Swap out a Vernaux structure. */
172 _bfd_elf_swap_vernaux_out (abfd, src, dst)
174 const Elf_Internal_Vernaux *src;
175 Elf_External_Vernaux *dst;
177 bfd_h_put_32 (abfd, src->vna_hash, dst->vna_hash);
178 bfd_h_put_16 (abfd, src->vna_flags, dst->vna_flags);
179 bfd_h_put_16 (abfd, src->vna_other, dst->vna_other);
180 bfd_h_put_32 (abfd, src->vna_name, dst->vna_name);
181 bfd_h_put_32 (abfd, src->vna_next, dst->vna_next);
184 /* Swap in a Versym structure. */
187 _bfd_elf_swap_versym_in (abfd, src, dst)
189 const Elf_External_Versym *src;
190 Elf_Internal_Versym *dst;
192 dst->vs_vers = bfd_h_get_16 (abfd, src->vs_vers);
195 /* Swap out a Versym structure. */
198 _bfd_elf_swap_versym_out (abfd, src, dst)
200 const Elf_Internal_Versym *src;
201 Elf_External_Versym *dst;
203 bfd_h_put_16 (abfd, src->vs_vers, dst->vs_vers);
206 /* Standard ELF hash function. Do not change this function; you will
207 cause invalid hash tables to be generated. */
210 bfd_elf_hash (namearg)
213 const unsigned char *name = (const unsigned char *) namearg;
218 while ((ch = *name++) != '\0')
221 if ((g = (h & 0xf0000000)) != 0)
224 /* The ELF ABI says `h &= ~g', but this is equivalent in
225 this case and on some machines one insn instead of two. */
232 /* Read a specified number of bytes at a specified offset in an ELF
233 file, into a newly allocated buffer, and return a pointer to the
237 elf_read (abfd, offset, size)
244 if ((buf = bfd_alloc (abfd, size)) == NULL)
246 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
248 if (bfd_read ((PTR) buf, size, 1, abfd) != size)
250 if (bfd_get_error () != bfd_error_system_call)
251 bfd_set_error (bfd_error_file_truncated);
258 bfd_elf_mkobject (abfd)
261 /* this just does initialization */
262 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
263 elf_tdata (abfd) = (struct elf_obj_tdata *)
264 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
265 if (elf_tdata (abfd) == 0)
267 /* since everything is done at close time, do we need any
274 bfd_elf_mkcorefile (abfd)
277 /* I think this can be done just like an object file. */
278 return bfd_elf_mkobject (abfd);
282 bfd_elf_get_str_section (abfd, shindex)
284 unsigned int shindex;
286 Elf_Internal_Shdr **i_shdrp;
287 char *shstrtab = NULL;
289 unsigned int shstrtabsize;
291 i_shdrp = elf_elfsections (abfd);
292 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
295 shstrtab = (char *) i_shdrp[shindex]->contents;
296 if (shstrtab == NULL)
298 /* No cached one, attempt to read, and cache what we read. */
299 offset = i_shdrp[shindex]->sh_offset;
300 shstrtabsize = i_shdrp[shindex]->sh_size;
301 shstrtab = elf_read (abfd, offset, shstrtabsize);
302 i_shdrp[shindex]->contents = (PTR) shstrtab;
308 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
310 unsigned int shindex;
311 unsigned int strindex;
313 Elf_Internal_Shdr *hdr;
318 hdr = elf_elfsections (abfd)[shindex];
320 if (hdr->contents == NULL
321 && bfd_elf_get_str_section (abfd, shindex) == NULL)
324 if (strindex >= hdr->sh_size)
326 (*_bfd_error_handler)
327 (_("%s: invalid string offset %u >= %lu for section `%s'"),
328 bfd_get_filename (abfd), strindex, (unsigned long) hdr->sh_size,
329 ((shindex == elf_elfheader(abfd)->e_shstrndx
330 && strindex == hdr->sh_name)
332 : elf_string_from_elf_strtab (abfd, hdr->sh_name)));
336 return ((char *) hdr->contents) + strindex;
339 /* Make a BFD section from an ELF section. We store a pointer to the
340 BFD section in the bfd_section field of the header. */
343 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
345 Elf_Internal_Shdr *hdr;
351 if (hdr->bfd_section != NULL)
353 BFD_ASSERT (strcmp (name,
354 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
358 newsect = bfd_make_section_anyway (abfd, name);
362 newsect->filepos = hdr->sh_offset;
364 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
365 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
366 || ! bfd_set_section_alignment (abfd, newsect,
367 bfd_log2 (hdr->sh_addralign)))
370 flags = SEC_NO_FLAGS;
371 if (hdr->sh_type != SHT_NOBITS)
372 flags |= SEC_HAS_CONTENTS;
373 if ((hdr->sh_flags & SHF_ALLOC) != 0)
376 if (hdr->sh_type != SHT_NOBITS)
379 if ((hdr->sh_flags & SHF_WRITE) == 0)
380 flags |= SEC_READONLY;
381 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
383 else if ((flags & SEC_LOAD) != 0)
386 /* The debugging sections appear to be recognized only by name, not
388 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
389 || strncmp (name, ".line", sizeof ".line" - 1) == 0
390 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
391 flags |= SEC_DEBUGGING;
393 /* As a GNU extension, if the name begins with .gnu.linkonce, we
394 only link a single copy of the section. This is used to support
395 g++. g++ will emit each template expansion in its own section.
396 The symbols will be defined as weak, so that multiple definitions
397 are permitted. The GNU linker extension is to actually discard
398 all but one of the sections. */
399 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
400 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
402 if (! bfd_set_section_flags (abfd, newsect, flags))
405 if ((flags & SEC_ALLOC) != 0)
407 Elf_Internal_Phdr *phdr;
410 /* Look through the phdrs to see if we need to adjust the lma.
411 If all the p_paddr fields are zero, we ignore them, since
412 some ELF linkers produce such output. */
413 phdr = elf_tdata (abfd)->phdr;
414 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
416 if (phdr->p_paddr != 0)
419 if (i < elf_elfheader (abfd)->e_phnum)
421 phdr = elf_tdata (abfd)->phdr;
422 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
424 if (phdr->p_type == PT_LOAD
425 && phdr->p_vaddr != phdr->p_paddr
426 && phdr->p_vaddr <= hdr->sh_addr
427 && (phdr->p_vaddr + phdr->p_memsz
428 >= hdr->sh_addr + hdr->sh_size)
429 && ((flags & SEC_LOAD) == 0
430 || (phdr->p_offset <= (bfd_vma) hdr->sh_offset
431 && (phdr->p_offset + phdr->p_filesz
432 >= hdr->sh_offset + hdr->sh_size))))
434 newsect->lma += phdr->p_paddr - phdr->p_vaddr;
441 hdr->bfd_section = newsect;
442 elf_section_data (newsect)->this_hdr = *hdr;
452 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
455 Helper functions for GDB to locate the string tables.
456 Since BFD hides string tables from callers, GDB needs to use an
457 internal hook to find them. Sun's .stabstr, in particular,
458 isn't even pointed to by the .stab section, so ordinary
459 mechanisms wouldn't work to find it, even if we had some.
462 struct elf_internal_shdr *
463 bfd_elf_find_section (abfd, name)
467 Elf_Internal_Shdr **i_shdrp;
472 i_shdrp = elf_elfsections (abfd);
475 shstrtab = bfd_elf_get_str_section
476 (abfd, elf_elfheader (abfd)->e_shstrndx);
477 if (shstrtab != NULL)
479 max = elf_elfheader (abfd)->e_shnum;
480 for (i = 1; i < max; i++)
481 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
488 const char *const bfd_elf_section_type_names[] = {
489 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
490 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
491 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
494 /* ELF relocs are against symbols. If we are producing relocateable
495 output, and the reloc is against an external symbol, and nothing
496 has given us any additional addend, the resulting reloc will also
497 be against the same symbol. In such a case, we don't want to
498 change anything about the way the reloc is handled, since it will
499 all be done at final link time. Rather than put special case code
500 into bfd_perform_relocation, all the reloc types use this howto
501 function. It just short circuits the reloc if producing
502 relocateable output against an external symbol. */
505 bfd_reloc_status_type
506 bfd_elf_generic_reloc (abfd,
513 bfd *abfd ATTRIBUTE_UNUSED;
514 arelent *reloc_entry;
516 PTR data ATTRIBUTE_UNUSED;
517 asection *input_section;
519 char **error_message ATTRIBUTE_UNUSED;
521 if (output_bfd != (bfd *) NULL
522 && (symbol->flags & BSF_SECTION_SYM) == 0
523 && (! reloc_entry->howto->partial_inplace
524 || reloc_entry->addend == 0))
526 reloc_entry->address += input_section->output_offset;
530 return bfd_reloc_continue;
533 /* Print out the program headers. */
536 _bfd_elf_print_private_bfd_data (abfd, farg)
540 FILE *f = (FILE *) farg;
541 Elf_Internal_Phdr *p;
543 bfd_byte *dynbuf = NULL;
545 p = elf_tdata (abfd)->phdr;
550 fprintf (f, _("\nProgram Header:\n"));
551 c = elf_elfheader (abfd)->e_phnum;
552 for (i = 0; i < c; i++, p++)
559 case PT_NULL: s = "NULL"; break;
560 case PT_LOAD: s = "LOAD"; break;
561 case PT_DYNAMIC: s = "DYNAMIC"; break;
562 case PT_INTERP: s = "INTERP"; break;
563 case PT_NOTE: s = "NOTE"; break;
564 case PT_SHLIB: s = "SHLIB"; break;
565 case PT_PHDR: s = "PHDR"; break;
566 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
568 fprintf (f, "%8s off 0x", s);
569 fprintf_vma (f, p->p_offset);
570 fprintf (f, " vaddr 0x");
571 fprintf_vma (f, p->p_vaddr);
572 fprintf (f, " paddr 0x");
573 fprintf_vma (f, p->p_paddr);
574 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
575 fprintf (f, " filesz 0x");
576 fprintf_vma (f, p->p_filesz);
577 fprintf (f, " memsz 0x");
578 fprintf_vma (f, p->p_memsz);
579 fprintf (f, " flags %c%c%c",
580 (p->p_flags & PF_R) != 0 ? 'r' : '-',
581 (p->p_flags & PF_W) != 0 ? 'w' : '-',
582 (p->p_flags & PF_X) != 0 ? 'x' : '-');
583 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
584 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
589 s = bfd_get_section_by_name (abfd, ".dynamic");
594 bfd_byte *extdyn, *extdynend;
596 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
598 fprintf (f, _("\nDynamic Section:\n"));
600 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
603 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
607 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
610 link = elf_elfsections (abfd)[elfsec]->sh_link;
612 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
613 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
616 extdynend = extdyn + s->_raw_size;
617 for (; extdyn < extdynend; extdyn += extdynsize)
619 Elf_Internal_Dyn dyn;
624 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
626 if (dyn.d_tag == DT_NULL)
633 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
637 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
638 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
639 case DT_PLTGOT: name = "PLTGOT"; break;
640 case DT_HASH: name = "HASH"; break;
641 case DT_STRTAB: name = "STRTAB"; break;
642 case DT_SYMTAB: name = "SYMTAB"; break;
643 case DT_RELA: name = "RELA"; break;
644 case DT_RELASZ: name = "RELASZ"; break;
645 case DT_RELAENT: name = "RELAENT"; break;
646 case DT_STRSZ: name = "STRSZ"; break;
647 case DT_SYMENT: name = "SYMENT"; break;
648 case DT_INIT: name = "INIT"; break;
649 case DT_FINI: name = "FINI"; break;
650 case DT_SONAME: name = "SONAME"; stringp = true; break;
651 case DT_RPATH: name = "RPATH"; stringp = true; break;
652 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
653 case DT_REL: name = "REL"; break;
654 case DT_RELSZ: name = "RELSZ"; break;
655 case DT_RELENT: name = "RELENT"; break;
656 case DT_PLTREL: name = "PLTREL"; break;
657 case DT_DEBUG: name = "DEBUG"; break;
658 case DT_TEXTREL: name = "TEXTREL"; break;
659 case DT_JMPREL: name = "JMPREL"; break;
660 case DT_BIND_NOW: name = "BIND_NOW"; break;
661 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
662 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
663 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
664 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
665 case DT_RUNPATH: name = "RUNPATH"; stringp = true; break;
666 case DT_FLAGS: name = "FLAGS"; break;
667 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
668 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
669 case DT_CHECKSUM: name = "CHECKSUM"; break;
670 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
671 case DT_MOVEENT: name = "MOVEENT"; break;
672 case DT_MOVESZ: name = "MOVESZ"; break;
673 case DT_FEATURE: name = "FEATURE"; break;
674 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
675 case DT_SYMINSZ: name = "SYMINSZ"; break;
676 case DT_SYMINENT: name = "SYMINENT"; break;
677 case DT_CONFIG: name = "CONFIG"; stringp = true; break;
678 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = true; break;
679 case DT_AUDIT: name = "AUDIT"; stringp = true; break;
680 case DT_PLTPAD: name = "PLTPAD"; break;
681 case DT_MOVETAB: name = "MOVETAB"; break;
682 case DT_SYMINFO: name = "SYMINFO"; break;
683 case DT_RELACOUNT: name = "RELACOUNT"; break;
684 case DT_RELCOUNT: name = "RELCOUNT"; break;
685 case DT_FLAGS_1: name = "FLAGS_1"; break;
686 case DT_VERSYM: name = "VERSYM"; break;
687 case DT_VERDEF: name = "VERDEF"; break;
688 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
689 case DT_VERNEED: name = "VERNEED"; break;
690 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
691 case DT_AUXILIARY: name = "AUXILIARY"; stringp = true; break;
692 case DT_USED: name = "USED"; break;
693 case DT_FILTER: name = "FILTER"; stringp = true; break;
696 fprintf (f, " %-11s ", name);
698 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
703 string = bfd_elf_string_from_elf_section (abfd, link,
707 fprintf (f, "%s", string);
716 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
717 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
719 if (! _bfd_elf_slurp_version_tables (abfd))
723 if (elf_dynverdef (abfd) != 0)
725 Elf_Internal_Verdef *t;
727 fprintf (f, _("\nVersion definitions:\n"));
728 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
730 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
731 t->vd_flags, t->vd_hash, t->vd_nodename);
732 if (t->vd_auxptr->vda_nextptr != NULL)
734 Elf_Internal_Verdaux *a;
737 for (a = t->vd_auxptr->vda_nextptr;
740 fprintf (f, "%s ", a->vda_nodename);
746 if (elf_dynverref (abfd) != 0)
748 Elf_Internal_Verneed *t;
750 fprintf (f, _("\nVersion References:\n"));
751 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
753 Elf_Internal_Vernaux *a;
755 fprintf (f, _(" required from %s:\n"), t->vn_filename);
756 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
757 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
758 a->vna_flags, a->vna_other, a->vna_nodename);
770 /* Display ELF-specific fields of a symbol. */
773 bfd_elf_print_symbol (abfd, filep, symbol, how)
777 bfd_print_symbol_type how;
779 FILE *file = (FILE *) filep;
782 case bfd_print_symbol_name:
783 fprintf (file, "%s", symbol->name);
785 case bfd_print_symbol_more:
786 fprintf (file, "elf ");
787 fprintf_vma (file, symbol->value);
788 fprintf (file, " %lx", (long) symbol->flags);
790 case bfd_print_symbol_all:
792 CONST char *section_name;
793 CONST char *name = NULL;
794 struct elf_backend_data *bed;
795 unsigned char st_other;
797 section_name = symbol->section ? symbol->section->name : "(*none*)";
799 bed = get_elf_backend_data (abfd);
800 if (bed->elf_backend_print_symbol_all)
801 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
806 bfd_print_symbol_vandf ((PTR) file, symbol);
809 fprintf (file, " %s\t", section_name);
810 /* Print the "other" value for a symbol. For common symbols,
811 we've already printed the size; now print the alignment.
812 For other symbols, we have no specified alignment, and
813 we've printed the address; now print the size. */
815 (bfd_is_com_section (symbol->section)
816 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
817 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
819 /* If we have version information, print it. */
820 if (elf_tdata (abfd)->dynversym_section != 0
821 && (elf_tdata (abfd)->dynverdef_section != 0
822 || elf_tdata (abfd)->dynverref_section != 0))
825 const char *version_string;
827 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
831 else if (vernum == 1)
832 version_string = "Base";
833 else if (vernum <= elf_tdata (abfd)->cverdefs)
835 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
838 Elf_Internal_Verneed *t;
841 for (t = elf_tdata (abfd)->verref;
845 Elf_Internal_Vernaux *a;
847 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
849 if (a->vna_other == vernum)
851 version_string = a->vna_nodename;
858 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
859 fprintf (file, " %-11s", version_string);
864 fprintf (file, " (%s)", version_string);
865 for (i = 10 - strlen (version_string); i > 0; --i)
870 /* If the st_other field is not zero, print it. */
871 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
876 case STV_INTERNAL: fprintf (file, " .internal"); break;
877 case STV_HIDDEN: fprintf (file, " .hidden"); break;
878 case STV_PROTECTED: fprintf (file, " .protected"); break;
880 /* Some other non-defined flags are also present, so print
882 fprintf (file, " 0x%02x", (unsigned int) st_other);
885 fprintf (file, " %s", name);
891 /* Create an entry in an ELF linker hash table. */
893 struct bfd_hash_entry *
894 _bfd_elf_link_hash_newfunc (entry, table, string)
895 struct bfd_hash_entry *entry;
896 struct bfd_hash_table *table;
899 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
901 /* Allocate the structure if it has not already been allocated by a
903 if (ret == (struct elf_link_hash_entry *) NULL)
904 ret = ((struct elf_link_hash_entry *)
905 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
906 if (ret == (struct elf_link_hash_entry *) NULL)
907 return (struct bfd_hash_entry *) ret;
909 /* Call the allocation method of the superclass. */
910 ret = ((struct elf_link_hash_entry *)
911 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
913 if (ret != (struct elf_link_hash_entry *) NULL)
915 /* Set local fields. */
919 ret->dynstr_index = 0;
921 ret->got.offset = (bfd_vma) -1;
922 ret->plt.offset = (bfd_vma) -1;
923 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
924 ret->verinfo.verdef = NULL;
925 ret->vtable_entries_used = NULL;
926 ret->vtable_entries_size = 0;
927 ret->vtable_parent = NULL;
928 ret->type = STT_NOTYPE;
930 /* Assume that we have been called by a non-ELF symbol reader.
931 This flag is then reset by the code which reads an ELF input
932 file. This ensures that a symbol created by a non-ELF symbol
933 reader will have the flag set correctly. */
934 ret->elf_link_hash_flags = ELF_LINK_NON_ELF;
937 return (struct bfd_hash_entry *) ret;
940 /* Copy data from an indirect symbol to its direct symbol, hiding the
941 old indirect symbol. */
944 _bfd_elf_link_hash_copy_indirect (dir, ind)
945 struct elf_link_hash_entry *dir, *ind;
947 /* Copy down any references that we may have already seen to the
948 symbol which just became indirect. */
950 dir->elf_link_hash_flags |=
951 (ind->elf_link_hash_flags
952 & (ELF_LINK_HASH_REF_DYNAMIC
953 | ELF_LINK_HASH_REF_REGULAR
954 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
955 | ELF_LINK_NON_GOT_REF));
957 /* Copy over the global and procedure linkage table offset entries.
958 These may have been already set up by a check_relocs routine. */
959 if (dir->got.offset == (bfd_vma) -1)
961 dir->got.offset = ind->got.offset;
962 ind->got.offset = (bfd_vma) -1;
964 BFD_ASSERT (ind->got.offset == (bfd_vma) -1);
966 if (dir->plt.offset == (bfd_vma) -1)
968 dir->plt.offset = ind->plt.offset;
969 ind->plt.offset = (bfd_vma) -1;
971 BFD_ASSERT (ind->plt.offset == (bfd_vma) -1);
973 if (dir->dynindx == -1)
975 dir->dynindx = ind->dynindx;
976 dir->dynstr_index = ind->dynstr_index;
978 ind->dynstr_index = 0;
980 BFD_ASSERT (ind->dynindx == -1);
984 _bfd_elf_link_hash_hide_symbol(info, h)
985 struct bfd_link_info *info ATTRIBUTE_UNUSED;
986 struct elf_link_hash_entry *h;
988 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
990 h->plt.offset = (bfd_vma) -1;
993 /* Initialize an ELF linker hash table. */
996 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
997 struct elf_link_hash_table *table;
999 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
1000 struct bfd_hash_table *,
1003 table->dynamic_sections_created = false;
1004 table->dynobj = NULL;
1005 /* The first dynamic symbol is a dummy. */
1006 table->dynsymcount = 1;
1007 table->dynstr = NULL;
1008 table->bucketcount = 0;
1009 table->needed = NULL;
1010 table->runpath = NULL;
1012 table->stab_info = NULL;
1013 table->dynlocal = NULL;
1014 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
1017 /* Create an ELF linker hash table. */
1019 struct bfd_link_hash_table *
1020 _bfd_elf_link_hash_table_create (abfd)
1023 struct elf_link_hash_table *ret;
1025 ret = ((struct elf_link_hash_table *)
1026 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
1027 if (ret == (struct elf_link_hash_table *) NULL)
1030 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
1032 bfd_release (abfd, ret);
1039 /* This is a hook for the ELF emulation code in the generic linker to
1040 tell the backend linker what file name to use for the DT_NEEDED
1041 entry for a dynamic object. The generic linker passes name as an
1042 empty string to indicate that no DT_NEEDED entry should be made. */
1045 bfd_elf_set_dt_needed_name (abfd, name)
1049 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1050 && bfd_get_format (abfd) == bfd_object)
1051 elf_dt_name (abfd) = name;
1055 bfd_elf_set_dt_needed_soname (abfd, name)
1059 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1060 && bfd_get_format (abfd) == bfd_object)
1061 elf_dt_soname (abfd) = name;
1064 /* Get the list of DT_NEEDED entries for a link. This is a hook for
1065 the linker ELF emulation code. */
1067 struct bfd_link_needed_list *
1068 bfd_elf_get_needed_list (abfd, info)
1069 bfd *abfd ATTRIBUTE_UNUSED;
1070 struct bfd_link_info *info;
1072 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1074 return elf_hash_table (info)->needed;
1077 /* Get the list of DT_RPATH/DT_RUNPATH entries for a link. This is a
1078 hook for the linker ELF emulation code. */
1080 struct bfd_link_needed_list *
1081 bfd_elf_get_runpath_list (abfd, info)
1082 bfd *abfd ATTRIBUTE_UNUSED;
1083 struct bfd_link_info *info;
1085 if (info->hash->creator->flavour != bfd_target_elf_flavour)
1087 return elf_hash_table (info)->runpath;
1090 /* Get the name actually used for a dynamic object for a link. This
1091 is the SONAME entry if there is one. Otherwise, it is the string
1092 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
1095 bfd_elf_get_dt_soname (abfd)
1098 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1099 && bfd_get_format (abfd) == bfd_object)
1100 return elf_dt_name (abfd);
1104 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
1105 the ELF linker emulation code. */
1108 bfd_elf_get_bfd_needed_list (abfd, pneeded)
1110 struct bfd_link_needed_list **pneeded;
1113 bfd_byte *dynbuf = NULL;
1116 bfd_byte *extdyn, *extdynend;
1118 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
1122 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
1123 || bfd_get_format (abfd) != bfd_object)
1126 s = bfd_get_section_by_name (abfd, ".dynamic");
1127 if (s == NULL || s->_raw_size == 0)
1130 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
1134 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
1138 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
1142 link = elf_elfsections (abfd)[elfsec]->sh_link;
1144 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1145 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1148 extdynend = extdyn + s->_raw_size;
1149 for (; extdyn < extdynend; extdyn += extdynsize)
1151 Elf_Internal_Dyn dyn;
1153 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
1155 if (dyn.d_tag == DT_NULL)
1158 if (dyn.d_tag == DT_NEEDED)
1161 struct bfd_link_needed_list *l;
1163 string = bfd_elf_string_from_elf_section (abfd, link,
1168 l = (struct bfd_link_needed_list *) bfd_alloc (abfd, sizeof *l);
1189 /* Allocate an ELF string table--force the first byte to be zero. */
1191 struct bfd_strtab_hash *
1192 _bfd_elf_stringtab_init ()
1194 struct bfd_strtab_hash *ret;
1196 ret = _bfd_stringtab_init ();
1201 loc = _bfd_stringtab_add (ret, "", true, false);
1202 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1203 if (loc == (bfd_size_type) -1)
1205 _bfd_stringtab_free (ret);
1212 /* ELF .o/exec file reading */
1214 /* Create a new bfd section from an ELF section header. */
1217 bfd_section_from_shdr (abfd, shindex)
1219 unsigned int shindex;
1221 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
1222 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
1223 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1226 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
1228 switch (hdr->sh_type)
1231 /* Inactive section. Throw it away. */
1234 case SHT_PROGBITS: /* Normal section with contents. */
1235 case SHT_DYNAMIC: /* Dynamic linking information. */
1236 case SHT_NOBITS: /* .bss section. */
1237 case SHT_HASH: /* .hash section. */
1238 case SHT_NOTE: /* .note section. */
1239 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1241 case SHT_SYMTAB: /* A symbol table */
1242 if (elf_onesymtab (abfd) == shindex)
1245 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1246 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1247 elf_onesymtab (abfd) = shindex;
1248 elf_tdata (abfd)->symtab_hdr = *hdr;
1249 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1250 abfd->flags |= HAS_SYMS;
1252 /* Sometimes a shared object will map in the symbol table. If
1253 SHF_ALLOC is set, and this is a shared object, then we also
1254 treat this section as a BFD section. We can not base the
1255 decision purely on SHF_ALLOC, because that flag is sometimes
1256 set in a relocateable object file, which would confuse the
1258 if ((hdr->sh_flags & SHF_ALLOC) != 0
1259 && (abfd->flags & DYNAMIC) != 0
1260 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1265 case SHT_DYNSYM: /* A dynamic symbol table */
1266 if (elf_dynsymtab (abfd) == shindex)
1269 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
1270 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1271 elf_dynsymtab (abfd) = shindex;
1272 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1273 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1274 abfd->flags |= HAS_SYMS;
1276 /* Besides being a symbol table, we also treat this as a regular
1277 section, so that objcopy can handle it. */
1278 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1280 case SHT_STRTAB: /* A string table */
1281 if (hdr->bfd_section != NULL)
1283 if (ehdr->e_shstrndx == shindex)
1285 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1286 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
1292 for (i = 1; i < ehdr->e_shnum; i++)
1294 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1295 if (hdr2->sh_link == shindex)
1297 if (! bfd_section_from_shdr (abfd, i))
1299 if (elf_onesymtab (abfd) == i)
1301 elf_tdata (abfd)->strtab_hdr = *hdr;
1302 elf_elfsections (abfd)[shindex] =
1303 &elf_tdata (abfd)->strtab_hdr;
1306 if (elf_dynsymtab (abfd) == i)
1308 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1309 elf_elfsections (abfd)[shindex] = hdr =
1310 &elf_tdata (abfd)->dynstrtab_hdr;
1311 /* We also treat this as a regular section, so
1312 that objcopy can handle it. */
1315 #if 0 /* Not handling other string tables specially right now. */
1316 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
1317 /* We have a strtab for some random other section. */
1318 newsect = (asection *) hdr2->bfd_section;
1321 hdr->bfd_section = newsect;
1322 hdr2 = &elf_section_data (newsect)->str_hdr;
1324 elf_elfsections (abfd)[shindex] = hdr2;
1330 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1334 /* *These* do a lot of work -- but build no sections! */
1336 asection *target_sect;
1337 Elf_Internal_Shdr *hdr2;
1339 /* Check for a bogus link to avoid crashing. */
1340 if (hdr->sh_link >= ehdr->e_shnum)
1342 ((*_bfd_error_handler)
1343 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1344 bfd_get_filename (abfd), hdr->sh_link, name, shindex));
1345 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1348 /* For some incomprehensible reason Oracle distributes
1349 libraries for Solaris in which some of the objects have
1350 bogus sh_link fields. It would be nice if we could just
1351 reject them, but, unfortunately, some people need to use
1352 them. We scan through the section headers; if we find only
1353 one suitable symbol table, we clobber the sh_link to point
1354 to it. I hope this doesn't break anything. */
1355 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
1356 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1362 for (scan = 1; scan < ehdr->e_shnum; scan++)
1364 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1365 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1376 hdr->sh_link = found;
1379 /* Get the symbol table. */
1380 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1381 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
1384 /* If this reloc section does not use the main symbol table we
1385 don't treat it as a reloc section. BFD can't adequately
1386 represent such a section, so at least for now, we don't
1387 try. We just present it as a normal section. We also
1388 can't use it as a reloc section if it points to the null
1390 if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
1391 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1393 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
1395 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1396 if (target_sect == NULL)
1399 if ((target_sect->flags & SEC_RELOC) == 0
1400 || target_sect->reloc_count == 0)
1401 hdr2 = &elf_section_data (target_sect)->rel_hdr;
1404 BFD_ASSERT (elf_section_data (target_sect)->rel_hdr2 == NULL);
1405 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
1406 elf_section_data (target_sect)->rel_hdr2 = hdr2;
1409 elf_elfsections (abfd)[shindex] = hdr2;
1410 target_sect->reloc_count += hdr->sh_size / hdr->sh_entsize;
1411 target_sect->flags |= SEC_RELOC;
1412 target_sect->relocation = NULL;
1413 target_sect->rel_filepos = hdr->sh_offset;
1414 /* In the section to which the relocations apply, mark whether
1415 its relocations are of the REL or RELA variety. */
1416 if (hdr->sh_size != 0)
1417 elf_section_data (target_sect)->use_rela_p
1418 = (hdr->sh_type == SHT_RELA);
1419 abfd->flags |= HAS_RELOC;
1424 case SHT_GNU_verdef:
1425 elf_dynverdef (abfd) = shindex;
1426 elf_tdata (abfd)->dynverdef_hdr = *hdr;
1427 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1430 case SHT_GNU_versym:
1431 elf_dynversym (abfd) = shindex;
1432 elf_tdata (abfd)->dynversym_hdr = *hdr;
1433 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1436 case SHT_GNU_verneed:
1437 elf_dynverref (abfd) = shindex;
1438 elf_tdata (abfd)->dynverref_hdr = *hdr;
1439 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
1446 /* Check for any processor-specific section types. */
1448 if (bed->elf_backend_section_from_shdr)
1449 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
1457 /* Given an ELF section number, retrieve the corresponding BFD
1461 bfd_section_from_elf_index (abfd, index)
1465 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
1466 if (index >= elf_elfheader (abfd)->e_shnum)
1468 return elf_elfsections (abfd)[index]->bfd_section;
1472 _bfd_elf_new_section_hook (abfd, sec)
1476 struct bfd_elf_section_data *sdata;
1478 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd, sizeof (*sdata));
1481 sec->used_by_bfd = (PTR) sdata;
1483 /* Indicate whether or not this section should use RELA relocations. */
1485 = get_elf_backend_data (abfd)->default_use_rela_p;
1490 /* Create a new bfd section from an ELF program header.
1492 Since program segments have no names, we generate a synthetic name
1493 of the form segment<NUM>, where NUM is generally the index in the
1494 program header table. For segments that are split (see below) we
1495 generate the names segment<NUM>a and segment<NUM>b.
1497 Note that some program segments may have a file size that is different than
1498 (less than) the memory size. All this means is that at execution the
1499 system must allocate the amount of memory specified by the memory size,
1500 but only initialize it with the first "file size" bytes read from the
1501 file. This would occur for example, with program segments consisting
1502 of combined data+bss.
1504 To handle the above situation, this routine generates TWO bfd sections
1505 for the single program segment. The first has the length specified by
1506 the file size of the segment, and the second has the length specified
1507 by the difference between the two sizes. In effect, the segment is split
1508 into it's initialized and uninitialized parts.
1513 _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
1515 Elf_Internal_Phdr *hdr;
1517 const char *typename;
1524 split = ((hdr->p_memsz > 0)
1525 && (hdr->p_filesz > 0)
1526 && (hdr->p_memsz > hdr->p_filesz));
1527 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
1528 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1531 strcpy (name, namebuf);
1532 newsect = bfd_make_section (abfd, name);
1533 if (newsect == NULL)
1535 newsect->vma = hdr->p_vaddr;
1536 newsect->lma = hdr->p_paddr;
1537 newsect->_raw_size = hdr->p_filesz;
1538 newsect->filepos = hdr->p_offset;
1539 newsect->flags |= SEC_HAS_CONTENTS;
1540 if (hdr->p_type == PT_LOAD)
1542 newsect->flags |= SEC_ALLOC;
1543 newsect->flags |= SEC_LOAD;
1544 if (hdr->p_flags & PF_X)
1546 /* FIXME: all we known is that it has execute PERMISSION,
1548 newsect->flags |= SEC_CODE;
1551 if (!(hdr->p_flags & PF_W))
1553 newsect->flags |= SEC_READONLY;
1558 sprintf (namebuf, "%s%db", typename, index);
1559 name = bfd_alloc (abfd, strlen (namebuf) + 1);
1562 strcpy (name, namebuf);
1563 newsect = bfd_make_section (abfd, name);
1564 if (newsect == NULL)
1566 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
1567 newsect->lma = hdr->p_paddr + hdr->p_filesz;
1568 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
1569 if (hdr->p_type == PT_LOAD)
1571 newsect->flags |= SEC_ALLOC;
1572 if (hdr->p_flags & PF_X)
1573 newsect->flags |= SEC_CODE;
1575 if (!(hdr->p_flags & PF_W))
1576 newsect->flags |= SEC_READONLY;
1583 bfd_section_from_phdr (abfd, hdr, index)
1585 Elf_Internal_Phdr *hdr;
1588 struct elf_backend_data *bed;
1590 switch (hdr->p_type)
1593 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
1596 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
1599 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
1602 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
1605 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
1607 if (! elfcore_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
1612 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
1615 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
1618 /* Check for any processor-specific program segment types.
1619 If no handler for them, default to making "segment" sections. */
1620 bed = get_elf_backend_data (abfd);
1621 if (bed->elf_backend_section_from_phdr)
1622 return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
1624 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "segment");
1628 /* Initialize REL_HDR, the section-header for new section, containing
1629 relocations against ASECT. If USE_RELA_P is true, we use RELA
1630 relocations; otherwise, we use REL relocations. */
1633 _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
1635 Elf_Internal_Shdr *rel_hdr;
1640 struct elf_backend_data *bed;
1642 bed = get_elf_backend_data (abfd);
1643 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1646 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1648 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1650 if (rel_hdr->sh_name == (unsigned int) -1)
1652 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1653 rel_hdr->sh_entsize = (use_rela_p
1654 ? bed->s->sizeof_rela
1655 : bed->s->sizeof_rel);
1656 rel_hdr->sh_addralign = bed->s->file_align;
1657 rel_hdr->sh_flags = 0;
1658 rel_hdr->sh_addr = 0;
1659 rel_hdr->sh_size = 0;
1660 rel_hdr->sh_offset = 0;
1665 /* Set up an ELF internal section header for a section. */
1669 elf_fake_sections (abfd, asect, failedptrarg)
1674 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1675 boolean *failedptr = (boolean *) failedptrarg;
1676 Elf_Internal_Shdr *this_hdr;
1680 /* We already failed; just get out of the bfd_map_over_sections
1685 this_hdr = &elf_section_data (asect)->this_hdr;
1687 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1690 if (this_hdr->sh_name == (unsigned long) -1)
1696 this_hdr->sh_flags = 0;
1698 if ((asect->flags & SEC_ALLOC) != 0
1699 || asect->user_set_vma)
1700 this_hdr->sh_addr = asect->vma;
1702 this_hdr->sh_addr = 0;
1704 this_hdr->sh_offset = 0;
1705 this_hdr->sh_size = asect->_raw_size;
1706 this_hdr->sh_link = 0;
1707 this_hdr->sh_addralign = 1 << asect->alignment_power;
1708 /* The sh_entsize and sh_info fields may have been set already by
1709 copy_private_section_data. */
1711 this_hdr->bfd_section = asect;
1712 this_hdr->contents = NULL;
1714 /* FIXME: This should not be based on section names. */
1715 if (strcmp (asect->name, ".dynstr") == 0)
1716 this_hdr->sh_type = SHT_STRTAB;
1717 else if (strcmp (asect->name, ".hash") == 0)
1719 this_hdr->sh_type = SHT_HASH;
1720 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
1722 else if (strcmp (asect->name, ".dynsym") == 0)
1724 this_hdr->sh_type = SHT_DYNSYM;
1725 this_hdr->sh_entsize = bed->s->sizeof_sym;
1727 else if (strcmp (asect->name, ".dynamic") == 0)
1729 this_hdr->sh_type = SHT_DYNAMIC;
1730 this_hdr->sh_entsize = bed->s->sizeof_dyn;
1732 else if (strncmp (asect->name, ".rela", 5) == 0
1733 && get_elf_backend_data (abfd)->may_use_rela_p)
1735 this_hdr->sh_type = SHT_RELA;
1736 this_hdr->sh_entsize = bed->s->sizeof_rela;
1738 else if (strncmp (asect->name, ".rel", 4) == 0
1739 && get_elf_backend_data (abfd)->may_use_rel_p)
1741 this_hdr->sh_type = SHT_REL;
1742 this_hdr->sh_entsize = bed->s->sizeof_rel;
1744 else if (strncmp (asect->name, ".note", 5) == 0)
1745 this_hdr->sh_type = SHT_NOTE;
1746 else if (strncmp (asect->name, ".stab", 5) == 0
1747 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1748 this_hdr->sh_type = SHT_STRTAB;
1749 else if (strcmp (asect->name, ".gnu.version") == 0)
1751 this_hdr->sh_type = SHT_GNU_versym;
1752 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
1754 else if (strcmp (asect->name, ".gnu.version_d") == 0)
1756 this_hdr->sh_type = SHT_GNU_verdef;
1757 this_hdr->sh_entsize = 0;
1758 /* objcopy or strip will copy over sh_info, but may not set
1759 cverdefs. The linker will set cverdefs, but sh_info will be
1761 if (this_hdr->sh_info == 0)
1762 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
1764 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
1765 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
1767 else if (strcmp (asect->name, ".gnu.version_r") == 0)
1769 this_hdr->sh_type = SHT_GNU_verneed;
1770 this_hdr->sh_entsize = 0;
1771 /* objcopy or strip will copy over sh_info, but may not set
1772 cverrefs. The linker will set cverrefs, but sh_info will be
1774 if (this_hdr->sh_info == 0)
1775 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
1777 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
1778 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
1780 else if ((asect->flags & SEC_ALLOC) != 0
1781 && (asect->flags & SEC_LOAD) != 0)
1782 this_hdr->sh_type = SHT_PROGBITS;
1783 else if ((asect->flags & SEC_ALLOC) != 0
1784 && ((asect->flags & SEC_LOAD) == 0))
1785 this_hdr->sh_type = SHT_NOBITS;
1789 this_hdr->sh_type = SHT_PROGBITS;
1792 if ((asect->flags & SEC_ALLOC) != 0)
1793 this_hdr->sh_flags |= SHF_ALLOC;
1794 if ((asect->flags & SEC_READONLY) == 0)
1795 this_hdr->sh_flags |= SHF_WRITE;
1796 if ((asect->flags & SEC_CODE) != 0)
1797 this_hdr->sh_flags |= SHF_EXECINSTR;
1799 /* Check for processor-specific section types. */
1800 if (bed->elf_backend_fake_sections)
1801 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1803 /* If the section has relocs, set up a section header for the
1804 SHT_REL[A] section. If two relocation sections are required for
1805 this section, it is up to the processor-specific back-end to
1806 create the other. */
1807 if ((asect->flags & SEC_RELOC) != 0
1808 && !_bfd_elf_init_reloc_shdr (abfd,
1809 &elf_section_data (asect)->rel_hdr,
1811 elf_section_data (asect)->use_rela_p))
1815 /* Assign all ELF section numbers. The dummy first section is handled here
1816 too. The link/info pointers for the standard section types are filled
1817 in here too, while we're at it. */
1820 assign_section_numbers (abfd)
1823 struct elf_obj_tdata *t = elf_tdata (abfd);
1825 unsigned int section_number;
1826 Elf_Internal_Shdr **i_shdrp;
1830 for (sec = abfd->sections; sec; sec = sec->next)
1832 struct bfd_elf_section_data *d = elf_section_data (sec);
1834 d->this_idx = section_number++;
1835 if ((sec->flags & SEC_RELOC) == 0)
1838 d->rel_idx = section_number++;
1841 d->rel_idx2 = section_number++;
1846 t->shstrtab_section = section_number++;
1847 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1848 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1850 if (bfd_get_symcount (abfd) > 0)
1852 t->symtab_section = section_number++;
1853 t->strtab_section = section_number++;
1856 elf_elfheader (abfd)->e_shnum = section_number;
1858 /* Set up the list of section header pointers, in agreement with the
1860 i_shdrp = ((Elf_Internal_Shdr **)
1861 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1862 if (i_shdrp == NULL)
1865 i_shdrp[0] = ((Elf_Internal_Shdr *)
1866 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1867 if (i_shdrp[0] == NULL)
1869 bfd_release (abfd, i_shdrp);
1872 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1874 elf_elfsections (abfd) = i_shdrp;
1876 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1877 if (bfd_get_symcount (abfd) > 0)
1879 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1880 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1881 t->symtab_hdr.sh_link = t->strtab_section;
1883 for (sec = abfd->sections; sec; sec = sec->next)
1885 struct bfd_elf_section_data *d = elf_section_data (sec);
1889 i_shdrp[d->this_idx] = &d->this_hdr;
1890 if (d->rel_idx != 0)
1891 i_shdrp[d->rel_idx] = &d->rel_hdr;
1892 if (d->rel_idx2 != 0)
1893 i_shdrp[d->rel_idx2] = d->rel_hdr2;
1895 /* Fill in the sh_link and sh_info fields while we're at it. */
1897 /* sh_link of a reloc section is the section index of the symbol
1898 table. sh_info is the section index of the section to which
1899 the relocation entries apply. */
1900 if (d->rel_idx != 0)
1902 d->rel_hdr.sh_link = t->symtab_section;
1903 d->rel_hdr.sh_info = d->this_idx;
1905 if (d->rel_idx2 != 0)
1907 d->rel_hdr2->sh_link = t->symtab_section;
1908 d->rel_hdr2->sh_info = d->this_idx;
1911 switch (d->this_hdr.sh_type)
1915 /* A reloc section which we are treating as a normal BFD
1916 section. sh_link is the section index of the symbol
1917 table. sh_info is the section index of the section to
1918 which the relocation entries apply. We assume that an
1919 allocated reloc section uses the dynamic symbol table.
1920 FIXME: How can we be sure? */
1921 s = bfd_get_section_by_name (abfd, ".dynsym");
1923 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1925 /* We look up the section the relocs apply to by name. */
1927 if (d->this_hdr.sh_type == SHT_REL)
1931 s = bfd_get_section_by_name (abfd, name);
1933 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1937 /* We assume that a section named .stab*str is a stabs
1938 string section. We look for a section with the same name
1939 but without the trailing ``str'', and set its sh_link
1940 field to point to this section. */
1941 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1942 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1947 len = strlen (sec->name);
1948 alc = (char *) bfd_malloc (len - 2);
1951 strncpy (alc, sec->name, len - 3);
1952 alc[len - 3] = '\0';
1953 s = bfd_get_section_by_name (abfd, alc);
1957 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1959 /* This is a .stab section. */
1960 elf_section_data (s)->this_hdr.sh_entsize =
1961 4 + 2 * bfd_get_arch_size (abfd) / 8;
1968 case SHT_GNU_verneed:
1969 case SHT_GNU_verdef:
1970 /* sh_link is the section header index of the string table
1971 used for the dynamic entries, or the symbol table, or the
1973 s = bfd_get_section_by_name (abfd, ".dynstr");
1975 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1979 case SHT_GNU_versym:
1980 /* sh_link is the section header index of the symbol table
1981 this hash table or version table is for. */
1982 s = bfd_get_section_by_name (abfd, ".dynsym");
1984 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1992 /* Map symbol from it's internal number to the external number, moving
1993 all local symbols to be at the head of the list. */
1996 sym_is_global (abfd, sym)
2000 /* If the backend has a special mapping, use it. */
2001 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2002 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
2005 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
2006 || bfd_is_und_section (bfd_get_section (sym))
2007 || bfd_is_com_section (bfd_get_section (sym)));
2011 elf_map_symbols (abfd)
2014 int symcount = bfd_get_symcount (abfd);
2015 asymbol **syms = bfd_get_outsymbols (abfd);
2016 asymbol **sect_syms;
2018 int num_globals = 0;
2019 int num_locals2 = 0;
2020 int num_globals2 = 0;
2022 int num_sections = 0;
2029 fprintf (stderr, "elf_map_symbols\n");
2033 /* Add a section symbol for each BFD section. FIXME: Is this really
2035 for (asect = abfd->sections; asect; asect = asect->next)
2037 if (max_index < asect->index)
2038 max_index = asect->index;
2042 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
2043 if (sect_syms == NULL)
2045 elf_section_syms (abfd) = sect_syms;
2047 for (idx = 0; idx < symcount; idx++)
2051 if ((sym->flags & BSF_SECTION_SYM) != 0
2058 if (sec->owner != NULL)
2060 if (sec->owner != abfd)
2062 if (sec->output_offset != 0)
2065 sec = sec->output_section;
2067 /* Empty sections in the input files may have had a section
2068 symbol created for them. (See the comment near the end of
2069 _bfd_generic_link_output_symbols in linker.c). If the linker
2070 script discards such sections then we will reach this point.
2071 Since we know that we cannot avoid this case, we detect it
2072 and skip the abort and the assignment to the sect_syms array.
2073 To reproduce this particular case try running the linker
2074 testsuite test ld-scripts/weak.exp for an ELF port that uses
2075 the generic linker. */
2076 if (sec->owner == NULL)
2079 BFD_ASSERT (sec->owner == abfd);
2081 sect_syms[sec->index] = syms[idx];
2086 for (asect = abfd->sections; asect; asect = asect->next)
2088 if (sect_syms[asect->index] != NULL)
2091 sym = bfd_make_empty_symbol (abfd);
2094 sym->the_bfd = abfd;
2095 sym->name = asect->name;
2097 /* Set the flags to 0 to indicate that this one was newly added. */
2099 sym->section = asect;
2100 sect_syms[asect->index] = sym;
2104 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
2105 asect->name, (long) asect->vma, asect->index, (long) asect);
2109 /* Classify all of the symbols. */
2110 for (idx = 0; idx < symcount; idx++)
2112 if (!sym_is_global (abfd, syms[idx]))
2117 for (asect = abfd->sections; asect; asect = asect->next)
2119 if (sect_syms[asect->index] != NULL
2120 && sect_syms[asect->index]->flags == 0)
2122 sect_syms[asect->index]->flags = BSF_SECTION_SYM;
2123 if (!sym_is_global (abfd, sect_syms[asect->index]))
2127 sect_syms[asect->index]->flags = 0;
2131 /* Now sort the symbols so the local symbols are first. */
2132 new_syms = ((asymbol **)
2134 (num_locals + num_globals) * sizeof (asymbol *)));
2135 if (new_syms == NULL)
2138 for (idx = 0; idx < symcount; idx++)
2140 asymbol *sym = syms[idx];
2143 if (!sym_is_global (abfd, sym))
2146 i = num_locals + num_globals2++;
2148 sym->udata.i = i + 1;
2150 for (asect = abfd->sections; asect; asect = asect->next)
2152 if (sect_syms[asect->index] != NULL
2153 && sect_syms[asect->index]->flags == 0)
2155 asymbol *sym = sect_syms[asect->index];
2158 sym->flags = BSF_SECTION_SYM;
2159 if (!sym_is_global (abfd, sym))
2162 i = num_locals + num_globals2++;
2164 sym->udata.i = i + 1;
2168 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
2170 elf_num_locals (abfd) = num_locals;
2171 elf_num_globals (abfd) = num_globals;
2175 /* Align to the maximum file alignment that could be required for any
2176 ELF data structure. */
2178 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
2179 static INLINE file_ptr
2180 align_file_position (off, align)
2184 return (off + align - 1) & ~(align - 1);
2187 /* Assign a file position to a section, optionally aligning to the
2188 required section alignment. */
2191 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
2192 Elf_Internal_Shdr *i_shdrp;
2200 al = i_shdrp->sh_addralign;
2202 offset = BFD_ALIGN (offset, al);
2204 i_shdrp->sh_offset = offset;
2205 if (i_shdrp->bfd_section != NULL)
2206 i_shdrp->bfd_section->filepos = offset;
2207 if (i_shdrp->sh_type != SHT_NOBITS)
2208 offset += i_shdrp->sh_size;
2212 /* Compute the file positions we are going to put the sections at, and
2213 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2214 is not NULL, this is being called by the ELF backend linker. */
2217 _bfd_elf_compute_section_file_positions (abfd, link_info)
2219 struct bfd_link_info *link_info;
2221 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2223 struct bfd_strtab_hash *strtab;
2224 Elf_Internal_Shdr *shstrtab_hdr;
2226 if (abfd->output_has_begun)
2229 /* Do any elf backend specific processing first. */
2230 if (bed->elf_backend_begin_write_processing)
2231 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
2233 if (! prep_headers (abfd))
2236 /* Post process the headers if necessary. */
2237 if (bed->elf_backend_post_process_headers)
2238 (*bed->elf_backend_post_process_headers) (abfd, link_info);
2241 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
2245 if (!assign_section_numbers (abfd))
2248 /* The backend linker builds symbol table information itself. */
2249 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2251 /* Non-zero if doing a relocatable link. */
2252 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
2254 if (! swap_out_syms (abfd, &strtab, relocatable_p))
2258 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
2259 /* sh_name was set in prep_headers. */
2260 shstrtab_hdr->sh_type = SHT_STRTAB;
2261 shstrtab_hdr->sh_flags = 0;
2262 shstrtab_hdr->sh_addr = 0;
2263 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
2264 shstrtab_hdr->sh_entsize = 0;
2265 shstrtab_hdr->sh_link = 0;
2266 shstrtab_hdr->sh_info = 0;
2267 /* sh_offset is set in assign_file_positions_except_relocs. */
2268 shstrtab_hdr->sh_addralign = 1;
2270 if (!assign_file_positions_except_relocs (abfd))
2273 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
2276 Elf_Internal_Shdr *hdr;
2278 off = elf_tdata (abfd)->next_file_pos;
2280 hdr = &elf_tdata (abfd)->symtab_hdr;
2281 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2283 hdr = &elf_tdata (abfd)->strtab_hdr;
2284 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2286 elf_tdata (abfd)->next_file_pos = off;
2288 /* Now that we know where the .strtab section goes, write it
2290 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
2291 || ! _bfd_stringtab_emit (abfd, strtab))
2293 _bfd_stringtab_free (strtab);
2296 abfd->output_has_begun = true;
2301 /* Create a mapping from a set of sections to a program segment. */
2303 static INLINE struct elf_segment_map *
2304 make_mapping (abfd, sections, from, to, phdr)
2306 asection **sections;
2311 struct elf_segment_map *m;
2315 m = ((struct elf_segment_map *)
2317 (sizeof (struct elf_segment_map)
2318 + (to - from - 1) * sizeof (asection *))));
2322 m->p_type = PT_LOAD;
2323 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
2324 m->sections[i - from] = *hdrpp;
2325 m->count = to - from;
2327 if (from == 0 && phdr)
2329 /* Include the headers in the first PT_LOAD segment. */
2330 m->includes_filehdr = 1;
2331 m->includes_phdrs = 1;
2337 /* Set up a mapping from BFD sections to program segments. */
2340 map_sections_to_segments (abfd)
2343 asection **sections = NULL;
2347 struct elf_segment_map *mfirst;
2348 struct elf_segment_map **pm;
2349 struct elf_segment_map *m;
2351 unsigned int phdr_index;
2352 bfd_vma maxpagesize;
2354 boolean phdr_in_segment = true;
2358 if (elf_tdata (abfd)->segment_map != NULL)
2361 if (bfd_count_sections (abfd) == 0)
2364 /* Select the allocated sections, and sort them. */
2366 sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
2367 * sizeof (asection *));
2368 if (sections == NULL)
2372 for (s = abfd->sections; s != NULL; s = s->next)
2374 if ((s->flags & SEC_ALLOC) != 0)
2380 BFD_ASSERT (i <= bfd_count_sections (abfd));
2383 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
2385 /* Build the mapping. */
2390 /* If we have a .interp section, then create a PT_PHDR segment for
2391 the program headers and a PT_INTERP segment for the .interp
2393 s = bfd_get_section_by_name (abfd, ".interp");
2394 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2396 m = ((struct elf_segment_map *)
2397 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2401 m->p_type = PT_PHDR;
2402 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2403 m->p_flags = PF_R | PF_X;
2404 m->p_flags_valid = 1;
2405 m->includes_phdrs = 1;
2410 m = ((struct elf_segment_map *)
2411 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2415 m->p_type = PT_INTERP;
2423 /* Look through the sections. We put sections in the same program
2424 segment when the start of the second section can be placed within
2425 a few bytes of the end of the first section. */
2428 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
2430 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
2432 && (dynsec->flags & SEC_LOAD) == 0)
2435 /* Deal with -Ttext or something similar such that the first section
2436 is not adjacent to the program headers. This is an
2437 approximation, since at this point we don't know exactly how many
2438 program headers we will need. */
2441 bfd_size_type phdr_size;
2443 phdr_size = elf_tdata (abfd)->program_header_size;
2445 phdr_size = get_elf_backend_data (abfd)->s->sizeof_phdr;
2446 if ((abfd->flags & D_PAGED) == 0
2447 || sections[0]->lma < phdr_size
2448 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
2449 phdr_in_segment = false;
2452 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
2455 boolean new_segment;
2459 /* See if this section and the last one will fit in the same
2462 if (last_hdr == NULL)
2464 /* If we don't have a segment yet, then we don't need a new
2465 one (we build the last one after this loop). */
2466 new_segment = false;
2468 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
2470 /* If this section has a different relation between the
2471 virtual address and the load address, then we need a new
2475 else if (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2476 < BFD_ALIGN (hdr->lma, maxpagesize))
2478 /* If putting this section in this segment would force us to
2479 skip a page in the segment, then we need a new segment. */
2482 else if ((last_hdr->flags & SEC_LOAD) == 0
2483 && (hdr->flags & SEC_LOAD) != 0)
2485 /* We don't want to put a loadable section after a
2486 nonloadable section in the same segment. */
2489 else if ((abfd->flags & D_PAGED) == 0)
2491 /* If the file is not demand paged, which means that we
2492 don't require the sections to be correctly aligned in the
2493 file, then there is no other reason for a new segment. */
2494 new_segment = false;
2497 && (hdr->flags & SEC_READONLY) == 0
2498 && (BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
2501 /* We don't want to put a writable section in a read only
2502 segment, unless they are on the same page in memory
2503 anyhow. We already know that the last section does not
2504 bring us past the current section on the page, so the
2505 only case in which the new section is not on the same
2506 page as the previous section is when the previous section
2507 ends precisely on a page boundary. */
2512 /* Otherwise, we can use the same segment. */
2513 new_segment = false;
2518 if ((hdr->flags & SEC_READONLY) == 0)
2524 /* We need a new program segment. We must create a new program
2525 header holding all the sections from phdr_index until hdr. */
2527 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2534 if ((hdr->flags & SEC_READONLY) == 0)
2541 phdr_in_segment = false;
2544 /* Create a final PT_LOAD program segment. */
2545 if (last_hdr != NULL)
2547 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
2555 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2558 m = ((struct elf_segment_map *)
2559 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2563 m->p_type = PT_DYNAMIC;
2565 m->sections[0] = dynsec;
2571 /* For each loadable .note section, add a PT_NOTE segment. We don't
2572 use bfd_get_section_by_name, because if we link together
2573 nonloadable .note sections and loadable .note sections, we will
2574 generate two .note sections in the output file. FIXME: Using
2575 names for section types is bogus anyhow. */
2576 for (s = abfd->sections; s != NULL; s = s->next)
2578 if ((s->flags & SEC_LOAD) != 0
2579 && strncmp (s->name, ".note", 5) == 0)
2581 m = ((struct elf_segment_map *)
2582 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
2586 m->p_type = PT_NOTE;
2598 elf_tdata (abfd)->segment_map = mfirst;
2602 if (sections != NULL)
2607 /* Sort sections by address. */
2610 elf_sort_sections (arg1, arg2)
2614 const asection *sec1 = *(const asection **) arg1;
2615 const asection *sec2 = *(const asection **) arg2;
2617 /* Sort by LMA first, since this is the address used to
2618 place the section into a segment. */
2619 if (sec1->lma < sec2->lma)
2621 else if (sec1->lma > sec2->lma)
2624 /* Then sort by VMA. Normally the LMA and the VMA will be
2625 the same, and this will do nothing. */
2626 if (sec1->vma < sec2->vma)
2628 else if (sec1->vma > sec2->vma)
2631 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2633 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2638 return sec1->target_index - sec2->target_index;
2648 /* Sort by size, to put zero sized sections before others at the
2651 if (sec1->_raw_size < sec2->_raw_size)
2653 if (sec1->_raw_size > sec2->_raw_size)
2656 return sec1->target_index - sec2->target_index;
2659 /* Assign file positions to the sections based on the mapping from
2660 sections to segments. This function also sets up some fields in
2661 the file header, and writes out the program headers. */
2664 assign_file_positions_for_segments (abfd)
2667 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2669 struct elf_segment_map *m;
2671 Elf_Internal_Phdr *phdrs;
2673 bfd_vma filehdr_vaddr, filehdr_paddr;
2674 bfd_vma phdrs_vaddr, phdrs_paddr;
2675 Elf_Internal_Phdr *p;
2677 if (elf_tdata (abfd)->segment_map == NULL)
2679 if (! map_sections_to_segments (abfd))
2683 if (bed->elf_backend_modify_segment_map)
2685 if (! (*bed->elf_backend_modify_segment_map) (abfd))
2690 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2693 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
2694 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
2695 elf_elfheader (abfd)->e_phnum = count;
2700 /* If we already counted the number of program segments, make sure
2701 that we allocated enough space. This happens when SIZEOF_HEADERS
2702 is used in a linker script. */
2703 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
2704 if (alloc != 0 && count > alloc)
2706 ((*_bfd_error_handler)
2707 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2708 bfd_get_filename (abfd), alloc, count));
2709 bfd_set_error (bfd_error_bad_value);
2716 phdrs = ((Elf_Internal_Phdr *)
2717 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
2721 off = bed->s->sizeof_ehdr;
2722 off += alloc * bed->s->sizeof_phdr;
2729 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2736 /* If elf_segment_map is not from map_sections_to_segments, the
2737 sections may not be correctly ordered. */
2739 qsort (m->sections, (size_t) m->count, sizeof (asection *),
2742 p->p_type = m->p_type;
2743 p->p_flags = m->p_flags;
2745 if (p->p_type == PT_LOAD
2747 && (m->sections[0]->flags & SEC_ALLOC) != 0)
2749 if ((abfd->flags & D_PAGED) != 0)
2750 off += (m->sections[0]->vma - off) % bed->maxpagesize;
2753 bfd_size_type align;
2756 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2758 bfd_size_type secalign;
2760 secalign = bfd_get_section_alignment (abfd, *secpp);
2761 if (secalign > align)
2765 off += (m->sections[0]->vma - off) % (1 << align);
2772 p->p_vaddr = m->sections[0]->vma;
2774 if (m->p_paddr_valid)
2775 p->p_paddr = m->p_paddr;
2776 else if (m->count == 0)
2779 p->p_paddr = m->sections[0]->lma;
2781 if (p->p_type == PT_LOAD
2782 && (abfd->flags & D_PAGED) != 0)
2783 p->p_align = bed->maxpagesize;
2784 else if (m->count == 0)
2785 p->p_align = bed->s->file_align;
2793 if (m->includes_filehdr)
2795 if (! m->p_flags_valid)
2798 p->p_filesz = bed->s->sizeof_ehdr;
2799 p->p_memsz = bed->s->sizeof_ehdr;
2802 BFD_ASSERT (p->p_type == PT_LOAD);
2804 if (p->p_vaddr < (bfd_vma) off)
2806 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2807 bfd_get_filename (abfd));
2808 bfd_set_error (bfd_error_bad_value);
2813 if (! m->p_paddr_valid)
2816 if (p->p_type == PT_LOAD)
2818 filehdr_vaddr = p->p_vaddr;
2819 filehdr_paddr = p->p_paddr;
2823 if (m->includes_phdrs)
2825 if (! m->p_flags_valid)
2828 if (m->includes_filehdr)
2830 if (p->p_type == PT_LOAD)
2832 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
2833 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
2838 p->p_offset = bed->s->sizeof_ehdr;
2842 BFD_ASSERT (p->p_type == PT_LOAD);
2843 p->p_vaddr -= off - p->p_offset;
2844 if (! m->p_paddr_valid)
2845 p->p_paddr -= off - p->p_offset;
2848 if (p->p_type == PT_LOAD)
2850 phdrs_vaddr = p->p_vaddr;
2851 phdrs_paddr = p->p_paddr;
2854 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
2857 p->p_filesz += alloc * bed->s->sizeof_phdr;
2858 p->p_memsz += alloc * bed->s->sizeof_phdr;
2861 if (p->p_type == PT_LOAD
2862 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
2864 if (! m->includes_filehdr && ! m->includes_phdrs)
2870 adjust = off - (p->p_offset + p->p_filesz);
2871 p->p_filesz += adjust;
2872 p->p_memsz += adjust;
2878 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2882 bfd_size_type align;
2886 align = 1 << bfd_get_section_alignment (abfd, sec);
2888 /* The section may have artificial alignment forced by a
2889 link script. Notice this case by the gap between the
2890 cumulative phdr vma and the section's vma. */
2891 if (p->p_vaddr + p->p_memsz < sec->vma)
2893 bfd_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
2895 p->p_memsz += adjust;
2898 if ((flags & SEC_LOAD) != 0)
2899 p->p_filesz += adjust;
2902 if (p->p_type == PT_LOAD)
2904 bfd_signed_vma adjust;
2906 if ((flags & SEC_LOAD) != 0)
2908 adjust = sec->lma - (p->p_paddr + p->p_memsz);
2912 else if ((flags & SEC_ALLOC) != 0)
2914 /* The section VMA must equal the file position
2915 modulo the page size. FIXME: I'm not sure if
2916 this adjustment is really necessary. We used to
2917 not have the SEC_LOAD case just above, and then
2918 this was necessary, but now I'm not sure. */
2919 if ((abfd->flags & D_PAGED) != 0)
2920 adjust = (sec->vma - voff) % bed->maxpagesize;
2922 adjust = (sec->vma - voff) % align;
2931 (* _bfd_error_handler)
2932 (_("Error: First section in segment (%s) starts at 0x%x"),
2933 bfd_section_name (abfd, sec), sec->lma);
2934 (* _bfd_error_handler)
2935 (_(" whereas segment starts at 0x%x"),
2940 p->p_memsz += adjust;
2943 if ((flags & SEC_LOAD) != 0)
2944 p->p_filesz += adjust;
2949 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2950 used in a linker script we may have a section with
2951 SEC_LOAD clear but which is supposed to have
2953 if ((flags & SEC_LOAD) != 0
2954 || (flags & SEC_HAS_CONTENTS) != 0)
2955 off += sec->_raw_size;
2957 if ((flags & SEC_ALLOC) != 0)
2958 voff += sec->_raw_size;
2961 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
2963 /* The actual "note" segment has i == 0.
2964 This is the one that actually contains everything. */
2968 p->p_filesz = sec->_raw_size;
2969 off += sec->_raw_size;
2974 /* Fake sections -- don't need to be written. */
2977 flags = sec->flags = 0;
2984 p->p_memsz += sec->_raw_size;
2986 if ((flags & SEC_LOAD) != 0)
2987 p->p_filesz += sec->_raw_size;
2989 if (align > p->p_align
2990 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
2994 if (! m->p_flags_valid)
2997 if ((flags & SEC_CODE) != 0)
2999 if ((flags & SEC_READONLY) == 0)
3005 /* Now that we have set the section file positions, we can set up
3006 the file positions for the non PT_LOAD segments. */
3007 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3011 if (p->p_type != PT_LOAD && m->count > 0)
3013 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
3014 p->p_offset = m->sections[0]->filepos;
3018 if (m->includes_filehdr)
3020 p->p_vaddr = filehdr_vaddr;
3021 if (! m->p_paddr_valid)
3022 p->p_paddr = filehdr_paddr;
3024 else if (m->includes_phdrs)
3026 p->p_vaddr = phdrs_vaddr;
3027 if (! m->p_paddr_valid)
3028 p->p_paddr = phdrs_paddr;
3033 /* Clear out any program headers we allocated but did not use. */
3034 for (; count < alloc; count++, p++)
3036 memset (p, 0, sizeof *p);
3037 p->p_type = PT_NULL;
3040 elf_tdata (abfd)->phdr = phdrs;
3042 elf_tdata (abfd)->next_file_pos = off;
3044 /* Write out the program headers. */
3045 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
3046 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
3052 /* Get the size of the program header.
3054 If this is called by the linker before any of the section VMA's are set, it
3055 can't calculate the correct value for a strange memory layout. This only
3056 happens when SIZEOF_HEADERS is used in a linker script. In this case,
3057 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
3058 data segment (exclusive of .interp and .dynamic).
3060 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
3061 will be two segments. */
3063 static bfd_size_type
3064 get_program_header_size (abfd)
3069 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3071 /* We can't return a different result each time we're called. */
3072 if (elf_tdata (abfd)->program_header_size != 0)
3073 return elf_tdata (abfd)->program_header_size;
3075 if (elf_tdata (abfd)->segment_map != NULL)
3077 struct elf_segment_map *m;
3080 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3082 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3083 return elf_tdata (abfd)->program_header_size;
3086 /* Assume we will need exactly two PT_LOAD segments: one for text
3087 and one for data. */
3090 s = bfd_get_section_by_name (abfd, ".interp");
3091 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3093 /* If we have a loadable interpreter section, we need a
3094 PT_INTERP segment. In this case, assume we also need a
3095 PT_PHDR segment, although that may not be true for all
3100 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3102 /* We need a PT_DYNAMIC segment. */
3106 for (s = abfd->sections; s != NULL; s = s->next)
3108 if ((s->flags & SEC_LOAD) != 0
3109 && strncmp (s->name, ".note", 5) == 0)
3111 /* We need a PT_NOTE segment. */
3116 /* Let the backend count up any program headers it might need. */
3117 if (bed->elf_backend_additional_program_headers)
3121 a = (*bed->elf_backend_additional_program_headers) (abfd);
3127 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
3128 return elf_tdata (abfd)->program_header_size;
3131 /* Work out the file positions of all the sections. This is called by
3132 _bfd_elf_compute_section_file_positions. All the section sizes and
3133 VMAs must be known before this is called.
3135 We do not consider reloc sections at this point, unless they form
3136 part of the loadable image. Reloc sections are assigned file
3137 positions in assign_file_positions_for_relocs, which is called by
3138 write_object_contents and final_link.
3140 We also don't set the positions of the .symtab and .strtab here. */
3143 assign_file_positions_except_relocs (abfd)
3146 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
3147 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
3148 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
3150 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3152 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
3153 && bfd_get_format (abfd) != bfd_core)
3155 Elf_Internal_Shdr **hdrpp;
3158 /* Start after the ELF header. */
3159 off = i_ehdrp->e_ehsize;
3161 /* We are not creating an executable, which means that we are
3162 not creating a program header, and that the actual order of
3163 the sections in the file is unimportant. */
3164 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3166 Elf_Internal_Shdr *hdr;
3169 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
3171 hdr->sh_offset = -1;
3174 if (i == tdata->symtab_section
3175 || i == tdata->strtab_section)
3177 hdr->sh_offset = -1;
3181 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3187 Elf_Internal_Shdr **hdrpp;
3189 /* Assign file positions for the loaded sections based on the
3190 assignment of sections to segments. */
3191 if (! assign_file_positions_for_segments (abfd))
3194 /* Assign file positions for the other sections. */
3196 off = elf_tdata (abfd)->next_file_pos;
3197 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
3199 Elf_Internal_Shdr *hdr;
3202 if (hdr->bfd_section != NULL
3203 && hdr->bfd_section->filepos != 0)
3204 hdr->sh_offset = hdr->bfd_section->filepos;
3205 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
3207 ((*_bfd_error_handler)
3208 (_("%s: warning: allocated section `%s' not in segment"),
3209 bfd_get_filename (abfd),
3210 (hdr->bfd_section == NULL
3212 : hdr->bfd_section->name)));
3213 if ((abfd->flags & D_PAGED) != 0)
3214 off += (hdr->sh_addr - off) % bed->maxpagesize;
3216 off += (hdr->sh_addr - off) % hdr->sh_addralign;
3217 off = _bfd_elf_assign_file_position_for_section (hdr, off,
3220 else if (hdr->sh_type == SHT_REL
3221 || hdr->sh_type == SHT_RELA
3222 || hdr == i_shdrpp[tdata->symtab_section]
3223 || hdr == i_shdrpp[tdata->strtab_section])
3224 hdr->sh_offset = -1;
3226 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
3230 /* Place the section headers. */
3231 off = align_file_position (off, bed->s->file_align);
3232 i_ehdrp->e_shoff = off;
3233 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
3235 elf_tdata (abfd)->next_file_pos = off;
3244 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
3245 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
3246 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
3248 struct bfd_strtab_hash *shstrtab;
3249 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3251 i_ehdrp = elf_elfheader (abfd);
3252 i_shdrp = elf_elfsections (abfd);
3254 shstrtab = _bfd_elf_stringtab_init ();
3255 if (shstrtab == NULL)
3258 elf_shstrtab (abfd) = shstrtab;
3260 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
3261 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
3262 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
3263 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
3265 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
3266 i_ehdrp->e_ident[EI_DATA] =
3267 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
3268 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
3270 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NONE;
3271 i_ehdrp->e_ident[EI_ABIVERSION] = 0;
3273 for (count = EI_PAD; count < EI_NIDENT; count++)
3274 i_ehdrp->e_ident[count] = 0;
3276 if ((abfd->flags & DYNAMIC) != 0)
3277 i_ehdrp->e_type = ET_DYN;
3278 else if ((abfd->flags & EXEC_P) != 0)
3279 i_ehdrp->e_type = ET_EXEC;
3280 else if (bfd_get_format (abfd) == bfd_core)
3281 i_ehdrp->e_type = ET_CORE;
3283 i_ehdrp->e_type = ET_REL;
3285 switch (bfd_get_arch (abfd))
3287 case bfd_arch_unknown:
3288 i_ehdrp->e_machine = EM_NONE;
3290 case bfd_arch_sparc:
3291 if (bfd_get_arch_size (abfd) == 64)
3292 i_ehdrp->e_machine = EM_SPARCV9;
3294 i_ehdrp->e_machine = EM_SPARC;
3297 i_ehdrp->e_machine = EM_S370;
3300 i_ehdrp->e_machine = EM_386;
3303 i_ehdrp->e_machine = EM_IA_64;
3305 case bfd_arch_m68hc11:
3306 i_ehdrp->e_machine = EM_68HC11;
3308 case bfd_arch_m68hc12:
3309 i_ehdrp->e_machine = EM_68HC12;
3312 i_ehdrp->e_machine = EM_68K;
3315 i_ehdrp->e_machine = EM_88K;
3318 i_ehdrp->e_machine = EM_860;
3321 i_ehdrp->e_machine = EM_960;
3323 case bfd_arch_mips: /* MIPS Rxxxx */
3324 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
3327 i_ehdrp->e_machine = EM_PARISC;
3329 case bfd_arch_powerpc:
3330 i_ehdrp->e_machine = EM_PPC;
3332 case bfd_arch_alpha:
3333 i_ehdrp->e_machine = EM_ALPHA;
3336 i_ehdrp->e_machine = EM_SH;
3339 i_ehdrp->e_machine = EM_CYGNUS_D10V;
3342 i_ehdrp->e_machine = EM_CYGNUS_D30V;
3345 i_ehdrp->e_machine = EM_CYGNUS_FR30;
3347 case bfd_arch_mcore:
3348 i_ehdrp->e_machine = EM_MCORE;
3351 i_ehdrp->e_machine = EM_AVR;
3354 switch (bfd_get_mach (abfd))
3357 case 0: i_ehdrp->e_machine = EM_CYGNUS_V850; break;
3361 i_ehdrp->e_machine = EM_CYGNUS_ARC;
3364 i_ehdrp->e_machine = EM_ARM;
3367 i_ehdrp->e_machine = EM_CYGNUS_M32R;
3369 case bfd_arch_mn10200:
3370 i_ehdrp->e_machine = EM_CYGNUS_MN10200;
3372 case bfd_arch_mn10300:
3373 i_ehdrp->e_machine = EM_CYGNUS_MN10300;
3376 i_ehdrp->e_machine = EM_PJ;
3379 i_ehdrp->e_machine = EM_CRIS;
3381 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3383 i_ehdrp->e_machine = EM_NONE;
3385 i_ehdrp->e_version = bed->s->ev_current;
3386 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
3388 /* no program header, for now. */
3389 i_ehdrp->e_phoff = 0;
3390 i_ehdrp->e_phentsize = 0;
3391 i_ehdrp->e_phnum = 0;
3393 /* each bfd section is section header entry */
3394 i_ehdrp->e_entry = bfd_get_start_address (abfd);
3395 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
3397 /* if we're building an executable, we'll need a program header table */
3398 if (abfd->flags & EXEC_P)
3400 /* it all happens later */
3402 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
3404 /* elf_build_phdrs() returns a (NULL-terminated) array of
3405 Elf_Internal_Phdrs */
3406 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
3407 i_ehdrp->e_phoff = outbase;
3408 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
3413 i_ehdrp->e_phentsize = 0;
3415 i_ehdrp->e_phoff = 0;
3418 elf_tdata (abfd)->symtab_hdr.sh_name =
3419 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
3420 elf_tdata (abfd)->strtab_hdr.sh_name =
3421 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
3422 elf_tdata (abfd)->shstrtab_hdr.sh_name =
3423 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
3424 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3425 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
3426 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
3432 /* Assign file positions for all the reloc sections which are not part
3433 of the loadable file image. */
3436 _bfd_elf_assign_file_positions_for_relocs (abfd)
3441 Elf_Internal_Shdr **shdrpp;
3443 off = elf_tdata (abfd)->next_file_pos;
3445 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
3446 i < elf_elfheader (abfd)->e_shnum;
3449 Elf_Internal_Shdr *shdrp;
3452 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
3453 && shdrp->sh_offset == -1)
3454 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
3457 elf_tdata (abfd)->next_file_pos = off;
3461 _bfd_elf_write_object_contents (abfd)
3464 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3465 Elf_Internal_Ehdr *i_ehdrp;
3466 Elf_Internal_Shdr **i_shdrp;
3470 if (! abfd->output_has_begun
3471 && ! _bfd_elf_compute_section_file_positions
3472 (abfd, (struct bfd_link_info *) NULL))
3475 i_shdrp = elf_elfsections (abfd);
3476 i_ehdrp = elf_elfheader (abfd);
3479 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
3483 _bfd_elf_assign_file_positions_for_relocs (abfd);
3485 /* After writing the headers, we need to write the sections too... */
3486 for (count = 1; count < i_ehdrp->e_shnum; count++)
3488 if (bed->elf_backend_section_processing)
3489 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
3490 if (i_shdrp[count]->contents)
3492 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
3493 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
3495 != i_shdrp[count]->sh_size))
3500 /* Write out the section header names. */
3501 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
3502 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
3505 if (bed->elf_backend_final_write_processing)
3506 (*bed->elf_backend_final_write_processing) (abfd,
3507 elf_tdata (abfd)->linker);
3509 return bed->s->write_shdrs_and_ehdr (abfd);
3513 _bfd_elf_write_corefile_contents (abfd)
3516 /* Hopefully this can be done just like an object file. */
3517 return _bfd_elf_write_object_contents (abfd);
3519 /* given a section, search the header to find them... */
3521 _bfd_elf_section_from_bfd_section (abfd, asect)
3525 struct elf_backend_data *bed = get_elf_backend_data (abfd);
3526 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
3528 Elf_Internal_Shdr *hdr;
3529 int maxindex = elf_elfheader (abfd)->e_shnum;
3531 for (index = 0; index < maxindex; index++)
3533 hdr = i_shdrp[index];
3534 if (hdr->bfd_section == asect)
3538 if (bed->elf_backend_section_from_bfd_section)
3540 for (index = 0; index < maxindex; index++)
3544 hdr = i_shdrp[index];
3546 if ((*bed->elf_backend_section_from_bfd_section)
3547 (abfd, hdr, asect, &retval))
3552 if (bfd_is_abs_section (asect))
3554 if (bfd_is_com_section (asect))
3556 if (bfd_is_und_section (asect))
3559 bfd_set_error (bfd_error_nonrepresentable_section);
3564 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3568 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
3570 asymbol **asym_ptr_ptr;
3572 asymbol *asym_ptr = *asym_ptr_ptr;
3574 flagword flags = asym_ptr->flags;
3576 /* When gas creates relocations against local labels, it creates its
3577 own symbol for the section, but does put the symbol into the
3578 symbol chain, so udata is 0. When the linker is generating
3579 relocatable output, this section symbol may be for one of the
3580 input sections rather than the output section. */
3581 if (asym_ptr->udata.i == 0
3582 && (flags & BSF_SECTION_SYM)
3583 && asym_ptr->section)
3587 if (asym_ptr->section->output_section != NULL)
3588 indx = asym_ptr->section->output_section->index;
3590 indx = asym_ptr->section->index;
3591 if (elf_section_syms (abfd)[indx])
3592 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
3595 idx = asym_ptr->udata.i;
3599 /* This case can occur when using --strip-symbol on a symbol
3600 which is used in a relocation entry. */
3601 (*_bfd_error_handler)
3602 (_("%s: symbol `%s' required but not present"),
3603 bfd_get_filename (abfd), bfd_asymbol_name (asym_ptr));
3604 bfd_set_error (bfd_error_no_symbols);
3611 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3612 (long) asym_ptr, asym_ptr->name, idx, flags,
3613 elf_symbol_flags (flags));
3621 /* Copy private BFD data. This copies any program header information. */
3624 copy_private_bfd_data (ibfd, obfd)
3628 Elf_Internal_Ehdr * iehdr;
3629 struct elf_segment_map * map;
3630 struct elf_segment_map * map_first;
3631 struct elf_segment_map ** pointer_to_map;
3632 Elf_Internal_Phdr * segment;
3635 unsigned int num_segments;
3636 boolean phdr_included = false;
3637 bfd_vma maxpagesize;
3638 struct elf_segment_map * phdr_adjust_seg = NULL;
3639 unsigned int phdr_adjust_num = 0;
3641 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3642 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3645 if (elf_tdata (ibfd)->phdr == NULL)
3648 iehdr = elf_elfheader (ibfd);
3651 pointer_to_map = & map_first;
3653 num_segments = elf_elfheader (ibfd)->e_phnum;
3654 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
3656 /* Returns the end address of the segment + 1. */
3657 #define SEGMENT_END(segment, start) \
3658 (start + (segment->p_memsz > segment->p_filesz \
3659 ? segment->p_memsz : segment->p_filesz))
3661 /* Returns true if the given section is contained within
3662 the given segment. VMA addresses are compared. */
3663 #define IS_CONTAINED_BY_VMA(section, segment) \
3664 (section->vma >= segment->p_vaddr \
3665 && (section->vma + section->_raw_size) \
3666 <= (SEGMENT_END (segment, segment->p_vaddr)))
3668 /* Returns true if the given section is contained within
3669 the given segment. LMA addresses are compared. */
3670 #define IS_CONTAINED_BY_LMA(section, segment, base) \
3671 (section->lma >= base \
3672 && (section->lma + section->_raw_size) \
3673 <= SEGMENT_END (segment, base))
3675 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3676 #define IS_COREFILE_NOTE(p, s) \
3677 (p->p_type == PT_NOTE \
3678 && bfd_get_format (ibfd) == bfd_core \
3679 && s->vma == 0 && s->lma == 0 \
3680 && (bfd_vma) s->filepos >= p->p_offset \
3681 && (bfd_vma) s->filepos + s->_raw_size \
3682 <= p->p_offset + p->p_filesz)
3684 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3685 linker, which generates a PT_INTERP section with p_vaddr and
3686 p_memsz set to 0. */
3687 #define IS_SOLARIS_PT_INTERP(p, s) \
3689 && p->p_filesz > 0 \
3690 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3691 && s->_raw_size > 0 \
3692 && (bfd_vma) s->filepos >= p->p_offset \
3693 && ((bfd_vma) s->filepos + s->_raw_size \
3694 <= p->p_offset + p->p_filesz))
3696 /* Decide if the given section should be included in the given segment.
3697 A section will be included if:
3698 1. It is within the address space of the segment,
3699 2. It is an allocated segment,
3700 3. There is an output section associated with it,
3701 4. The section has not already been allocated to a previous segment. */
3702 #define INCLUDE_SECTION_IN_SEGMENT(section, segment) \
3703 ((((IS_CONTAINED_BY_VMA (section, segment) \
3704 || IS_SOLARIS_PT_INTERP (segment, section)) \
3705 && (section->flags & SEC_ALLOC) != 0) \
3706 || IS_COREFILE_NOTE (segment, section)) \
3707 && section->output_section != NULL \
3708 && section->segment_mark == false)
3710 /* Returns true iff seg1 starts after the end of seg2. */
3711 #define SEGMENT_AFTER_SEGMENT(seg1, seg2) \
3712 (seg1->p_vaddr >= SEGMENT_END (seg2, seg2->p_vaddr))
3714 /* Returns true iff seg1 and seg2 overlap. */
3715 #define SEGMENT_OVERLAPS(seg1, seg2) \
3716 (!(SEGMENT_AFTER_SEGMENT (seg1, seg2) || SEGMENT_AFTER_SEGMENT (seg2, seg1)))
3718 /* Initialise the segment mark field. */
3719 for (section = ibfd->sections; section != NULL; section = section->next)
3720 section->segment_mark = false;
3722 /* Scan through the segments specified in the program header
3723 of the input BFD. For this first scan we look for overlaps
3724 in the loadable segments. These can be created by wierd
3725 parameters to objcopy. */
3726 for (i = 0, segment = elf_tdata (ibfd)->phdr;
3731 Elf_Internal_Phdr * segment2;
3733 if (segment->p_type != PT_LOAD)
3736 /* Determine if this segment overlaps any previous segments. */
3737 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j ++, segment2 ++)
3739 bfd_signed_vma extra_length;
3741 if (segment2->p_type != PT_LOAD
3742 || ! SEGMENT_OVERLAPS (segment, segment2))
3745 /* Merge the two segments together. */
3746 if (segment2->p_vaddr < segment->p_vaddr)
3748 /* Extend SEGMENT2 to include SEGMENT and then delete SEGMENT. */
3750 SEGMENT_END (segment, segment->p_vaddr)
3751 - SEGMENT_END (segment2, segment2->p_vaddr);
3753 if (extra_length > 0)
3755 segment2->p_memsz += extra_length;
3756 segment2->p_filesz += extra_length;
3759 segment->p_type = PT_NULL;
3761 /* Since we have deleted P we must restart the outer loop. */
3763 segment = elf_tdata (ibfd)->phdr;
3768 /* Extend SEGMENT to include SEGMENT2 and then delete SEGMENT2. */
3770 SEGMENT_END (segment2, segment2->p_vaddr)
3771 - SEGMENT_END (segment, segment->p_vaddr);
3773 if (extra_length > 0)
3775 segment->p_memsz += extra_length;
3776 segment->p_filesz += extra_length;
3779 segment2->p_type = PT_NULL;
3784 /* The second scan attempts to assign sections to segments. */
3785 for (i = 0, segment = elf_tdata (ibfd)->phdr;
3789 unsigned int section_count;
3790 asection ** sections;
3791 asection * output_section;
3793 bfd_vma matching_lma;
3794 bfd_vma suggested_lma;
3797 if (segment->p_type == PT_NULL)
3800 /* Compute how many sections might be placed into this segment. */
3802 for (section = ibfd->sections; section != NULL; section = section->next)
3803 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
3806 /* Allocate a segment map big enough to contain all of the
3807 sections we have selected. */
3808 map = ((struct elf_segment_map *)
3810 (sizeof (struct elf_segment_map)
3811 + ((size_t) section_count - 1) * sizeof (asection *))));
3815 /* Initialise the fields of the segment map. Default to
3816 using the physical address of the segment in the input BFD. */
3818 map->p_type = segment->p_type;
3819 map->p_flags = segment->p_flags;
3820 map->p_flags_valid = 1;
3821 map->p_paddr = segment->p_paddr;
3822 map->p_paddr_valid = 1;
3824 /* Determine if this segment contains the ELF file header
3825 and if it contains the program headers themselves. */
3826 map->includes_filehdr = (segment->p_offset == 0
3827 && segment->p_filesz >= iehdr->e_ehsize);
3829 map->includes_phdrs = 0;
3831 if (! phdr_included || segment->p_type != PT_LOAD)
3833 map->includes_phdrs =
3834 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
3835 && (segment->p_offset + segment->p_filesz
3836 >= ((bfd_vma) iehdr->e_phoff
3837 + iehdr->e_phnum * iehdr->e_phentsize)));
3839 if (segment->p_type == PT_LOAD && map->includes_phdrs)
3840 phdr_included = true;
3843 if (section_count == 0)
3845 /* Special segments, such as the PT_PHDR segment, may contain
3846 no sections, but ordinary, loadable segments should contain
3848 if (segment->p_type == PT_LOAD)
3850 (_("%s: warning: Empty loadable segment detected\n"),
3851 bfd_get_filename (ibfd));
3854 * pointer_to_map = map;
3855 pointer_to_map = & map->next;
3860 /* Now scan the sections in the input BFD again and attempt
3861 to add their corresponding output sections to the segment map.
3862 The problem here is how to handle an output section which has
3863 been moved (ie had its LMA changed). There are four possibilities:
3865 1. None of the sections have been moved.
3866 In this case we can continue to use the segment LMA from the
3869 2. All of the sections have been moved by the same amount.
3870 In this case we can change the segment's LMA to match the LMA
3871 of the first section.
3873 3. Some of the sections have been moved, others have not.
3874 In this case those sections which have not been moved can be
3875 placed in the current segment which will have to have its size,
3876 and possibly its LMA changed, and a new segment or segments will
3877 have to be created to contain the other sections.
3879 4. The sections have been moved, but not be the same amount.
3880 In this case we can change the segment's LMA to match the LMA
3881 of the first section and we will have to create a new segment
3882 or segments to contain the other sections.
3884 In order to save time, we allocate an array to hold the section
3885 pointers that we are interested in. As these sections get assigned
3886 to a segment, they are removed from this array. */
3888 sections = (asection **) bfd_malloc
3889 (sizeof (asection *) * section_count);
3890 if (sections == NULL)
3893 /* Step One: Scan for segment vs section LMA conflicts.
3894 Also add the sections to the section array allocated above.
3895 Also add the sections to the current segment. In the common
3896 case, where the sections have not been moved, this means that
3897 we have completely filled the segment, and there is nothing
3903 for (j = 0, section = ibfd->sections;
3905 section = section->next)
3907 if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
3909 output_section = section->output_section;
3911 sections[j ++] = section;
3913 /* The Solaris native linker always sets p_paddr to 0.
3914 We try to catch that case here, and set it to the
3916 if (segment->p_paddr == 0
3917 && segment->p_vaddr != 0
3919 && output_section->lma != 0
3920 && (output_section->vma == (segment->p_vaddr
3921 + (map->includes_filehdr
3924 + (map->includes_phdrs
3925 ? iehdr->e_phnum * iehdr->e_phentsize
3927 map->p_paddr = segment->p_vaddr;
3929 /* Match up the physical address of the segment with the
3930 LMA address of the output section. */
3931 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
3932 || IS_COREFILE_NOTE (segment, section))
3934 if (matching_lma == 0)
3935 matching_lma = output_section->lma;
3937 /* We assume that if the section fits within the segment
3938 then it does not overlap any other section within that
3940 map->sections[isec ++] = output_section;
3942 else if (suggested_lma == 0)
3943 suggested_lma = output_section->lma;
3947 BFD_ASSERT (j == section_count);
3949 /* Step Two: Adjust the physical address of the current segment,
3951 if (isec == section_count)
3953 /* All of the sections fitted within the segment as currently
3954 specified. This is the default case. Add the segment to
3955 the list of built segments and carry on to process the next
3956 program header in the input BFD. */
3957 map->count = section_count;
3958 * pointer_to_map = map;
3959 pointer_to_map = & map->next;
3966 if (matching_lma != 0)
3968 /* At least one section fits inside the current segment.
3969 Keep it, but modify its physical address to match the
3970 LMA of the first section that fitted. */
3971 map->p_paddr = matching_lma;
3975 /* None of the sections fitted inside the current segment.
3976 Change the current segment's physical address to match
3977 the LMA of the first section. */
3978 map->p_paddr = suggested_lma;
3981 /* Offset the segment physical address from the lma
3982 to allow for space taken up by elf headers. */
3983 if (map->includes_filehdr)
3984 map->p_paddr -= iehdr->e_ehsize;
3986 if (map->includes_phdrs)
3988 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
3990 /* iehdr->e_phnum is just an estimate of the number
3991 of program headers that we will need. Make a note
3992 here of the number we used and the segment we chose
3993 to hold these headers, so that we can adjust the
3994 offset when we know the correct value. */
3995 phdr_adjust_num = iehdr->e_phnum;
3996 phdr_adjust_seg = map;
4000 /* Step Three: Loop over the sections again, this time assigning
4001 those that fit to the current segment and remvoing them from the
4002 sections array; but making sure not to leave large gaps. Once all
4003 possible sections have been assigned to the current segment it is
4004 added to the list of built segments and if sections still remain
4005 to be assigned, a new segment is constructed before repeating
4013 /* Fill the current segment with sections that fit. */
4014 for (j = 0; j < section_count; j++)
4016 section = sections[j];
4018 if (section == NULL)
4021 output_section = section->output_section;
4023 BFD_ASSERT (output_section != NULL);
4025 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
4026 || IS_COREFILE_NOTE (segment, section))
4028 if (map->count == 0)
4030 /* If the first section in a segment does not start at
4031 the beginning of the segment, then something is
4033 if (output_section->lma !=
4035 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
4036 + (map->includes_phdrs
4037 ? iehdr->e_phnum * iehdr->e_phentsize
4043 asection * prev_sec;
4045 prev_sec = map->sections[map->count - 1];
4047 /* If the gap between the end of the previous section
4048 and the start of this section is more than
4049 maxpagesize then we need to start a new segment. */
4050 if ((BFD_ALIGN (prev_sec->lma + prev_sec->_raw_size, maxpagesize)
4051 < BFD_ALIGN (output_section->lma, maxpagesize))
4052 || ((prev_sec->lma + prev_sec->_raw_size) > output_section->lma))
4054 if (suggested_lma == 0)
4055 suggested_lma = output_section->lma;
4061 map->sections[map->count++] = output_section;
4064 section->segment_mark = true;
4066 else if (suggested_lma == 0)
4067 suggested_lma = output_section->lma;
4070 BFD_ASSERT (map->count > 0);
4072 /* Add the current segment to the list of built segments. */
4073 * pointer_to_map = map;
4074 pointer_to_map = & map->next;
4076 if (isec < section_count)
4078 /* We still have not allocated all of the sections to
4079 segments. Create a new segment here, initialise it
4080 and carry on looping. */
4081 map = ((struct elf_segment_map *)
4083 (sizeof (struct elf_segment_map)
4084 + ((size_t) section_count - 1)
4085 * sizeof (asection *))));
4089 /* Initialise the fields of the segment map. Set the physical
4090 physical address to the LMA of the first section that has
4091 not yet been assigned. */
4093 map->p_type = segment->p_type;
4094 map->p_flags = segment->p_flags;
4095 map->p_flags_valid = 1;
4096 map->p_paddr = suggested_lma;
4097 map->p_paddr_valid = 1;
4098 map->includes_filehdr = 0;
4099 map->includes_phdrs = 0;
4102 while (isec < section_count);
4107 /* The Solaris linker creates program headers in which all the
4108 p_paddr fields are zero. When we try to objcopy or strip such a
4109 file, we get confused. Check for this case, and if we find it
4110 reset the p_paddr_valid fields. */
4111 for (map = map_first; map != NULL; map = map->next)
4112 if (map->p_paddr != 0)
4116 for (map = map_first; map != NULL; map = map->next)
4117 map->p_paddr_valid = 0;
4120 elf_tdata (obfd)->segment_map = map_first;
4122 /* If we had to estimate the number of program headers that were
4123 going to be needed, then check our estimate know and adjust
4124 the offset if necessary. */
4125 if (phdr_adjust_seg != NULL)
4129 for (count = 0, map = map_first; map != NULL; map = map->next)
4132 if (count > phdr_adjust_num)
4133 phdr_adjust_seg->p_paddr
4134 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
4138 /* Final Step: Sort the segments into ascending order of physical address. */
4139 if (map_first != NULL)
4141 struct elf_segment_map * prev;
4144 for (map = map_first->next; map != NULL; prev = map, map = map->next)
4146 /* Yes I know - its a bubble sort.... */
4147 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
4149 /* Swap map and map->next. */
4150 prev->next = map->next;
4151 map->next = map->next->next;
4152 prev->next->next = map;
4162 #undef IS_CONTAINED_BY_VMA
4163 #undef IS_CONTAINED_BY_LMA
4164 #undef IS_COREFILE_NOTE
4165 #undef IS_SOLARIS_PT_INTERP
4166 #undef INCLUDE_SECTION_IN_SEGMENT
4167 #undef SEGMENT_AFTER_SEGMENT
4168 #undef SEGMENT_OVERLAPS
4172 /* Copy private section information. This copies over the entsize
4173 field, and sometimes the info field. */
4176 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
4182 Elf_Internal_Shdr *ihdr, *ohdr;
4184 if (ibfd->xvec->flavour != bfd_target_elf_flavour
4185 || obfd->xvec->flavour != bfd_target_elf_flavour)
4188 /* Copy over private BFD data if it has not already been copied.
4189 This must be done here, rather than in the copy_private_bfd_data
4190 entry point, because the latter is called after the section
4191 contents have been set, which means that the program headers have
4192 already been worked out. */
4193 if (elf_tdata (obfd)->segment_map == NULL
4194 && elf_tdata (ibfd)->phdr != NULL)
4198 /* Only set up the segments if there are no more SEC_ALLOC
4199 sections. FIXME: This won't do the right thing if objcopy is
4200 used to remove the last SEC_ALLOC section, since objcopy
4201 won't call this routine in that case. */
4202 for (s = isec->next; s != NULL; s = s->next)
4203 if ((s->flags & SEC_ALLOC) != 0)
4207 if (! copy_private_bfd_data (ibfd, obfd))
4212 ihdr = &elf_section_data (isec)->this_hdr;
4213 ohdr = &elf_section_data (osec)->this_hdr;
4215 ohdr->sh_entsize = ihdr->sh_entsize;
4217 if (ihdr->sh_type == SHT_SYMTAB
4218 || ihdr->sh_type == SHT_DYNSYM
4219 || ihdr->sh_type == SHT_GNU_verneed
4220 || ihdr->sh_type == SHT_GNU_verdef)
4221 ohdr->sh_info = ihdr->sh_info;
4223 elf_section_data (osec)->use_rela_p
4224 = elf_section_data (isec)->use_rela_p;
4229 /* Copy private symbol information. If this symbol is in a section
4230 which we did not map into a BFD section, try to map the section
4231 index correctly. We use special macro definitions for the mapped
4232 section indices; these definitions are interpreted by the
4233 swap_out_syms function. */
4235 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
4236 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
4237 #define MAP_STRTAB (SHN_LORESERVE - 3)
4238 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
4241 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
4247 elf_symbol_type *isym, *osym;
4249 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4250 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4253 isym = elf_symbol_from (ibfd, isymarg);
4254 osym = elf_symbol_from (obfd, osymarg);
4258 && bfd_is_abs_section (isym->symbol.section))
4262 shndx = isym->internal_elf_sym.st_shndx;
4263 if (shndx == elf_onesymtab (ibfd))
4264 shndx = MAP_ONESYMTAB;
4265 else if (shndx == elf_dynsymtab (ibfd))
4266 shndx = MAP_DYNSYMTAB;
4267 else if (shndx == elf_tdata (ibfd)->strtab_section)
4269 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
4270 shndx = MAP_SHSTRTAB;
4271 osym->internal_elf_sym.st_shndx = shndx;
4277 /* Swap out the symbols. */
4280 swap_out_syms (abfd, sttp, relocatable_p)
4282 struct bfd_strtab_hash **sttp;
4285 struct elf_backend_data *bed = get_elf_backend_data (abfd);
4287 if (!elf_map_symbols (abfd))
4290 /* Dump out the symtabs. */
4292 int symcount = bfd_get_symcount (abfd);
4293 asymbol **syms = bfd_get_outsymbols (abfd);
4294 struct bfd_strtab_hash *stt;
4295 Elf_Internal_Shdr *symtab_hdr;
4296 Elf_Internal_Shdr *symstrtab_hdr;
4297 char *outbound_syms;
4300 stt = _bfd_elf_stringtab_init ();
4304 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4305 symtab_hdr->sh_type = SHT_SYMTAB;
4306 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
4307 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
4308 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
4309 symtab_hdr->sh_addralign = bed->s->file_align;
4311 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
4312 symstrtab_hdr->sh_type = SHT_STRTAB;
4314 outbound_syms = bfd_alloc (abfd,
4315 (1 + symcount) * bed->s->sizeof_sym);
4316 if (outbound_syms == NULL)
4318 symtab_hdr->contents = (PTR) outbound_syms;
4320 /* now generate the data (for "contents") */
4322 /* Fill in zeroth symbol and swap it out. */
4323 Elf_Internal_Sym sym;
4329 sym.st_shndx = SHN_UNDEF;
4330 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4331 outbound_syms += bed->s->sizeof_sym;
4333 for (idx = 0; idx < symcount; idx++)
4335 Elf_Internal_Sym sym;
4336 bfd_vma value = syms[idx]->value;
4337 elf_symbol_type *type_ptr;
4338 flagword flags = syms[idx]->flags;
4341 if (flags & BSF_SECTION_SYM)
4342 /* Section symbols have no names. */
4346 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
4349 if (sym.st_name == (unsigned long) -1)
4353 type_ptr = elf_symbol_from (abfd, syms[idx]);
4355 if ((flags & BSF_SECTION_SYM) == 0
4356 && bfd_is_com_section (syms[idx]->section))
4358 /* ELF common symbols put the alignment into the `value' field,
4359 and the size into the `size' field. This is backwards from
4360 how BFD handles it, so reverse it here. */
4361 sym.st_size = value;
4362 if (type_ptr == NULL
4363 || type_ptr->internal_elf_sym.st_value == 0)
4364 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
4366 sym.st_value = type_ptr->internal_elf_sym.st_value;
4367 sym.st_shndx = _bfd_elf_section_from_bfd_section
4368 (abfd, syms[idx]->section);
4372 asection *sec = syms[idx]->section;
4375 if (sec->output_section)
4377 value += sec->output_offset;
4378 sec = sec->output_section;
4380 /* Don't add in the section vma for relocatable output. */
4381 if (! relocatable_p)
4383 sym.st_value = value;
4384 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
4386 if (bfd_is_abs_section (sec)
4388 && type_ptr->internal_elf_sym.st_shndx != 0)
4390 /* This symbol is in a real ELF section which we did
4391 not create as a BFD section. Undo the mapping done
4392 by copy_private_symbol_data. */
4393 shndx = type_ptr->internal_elf_sym.st_shndx;
4397 shndx = elf_onesymtab (abfd);
4400 shndx = elf_dynsymtab (abfd);
4403 shndx = elf_tdata (abfd)->strtab_section;
4406 shndx = elf_tdata (abfd)->shstrtab_section;
4414 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
4420 /* Writing this would be a hell of a lot easier if
4421 we had some decent documentation on bfd, and
4422 knew what to expect of the library, and what to
4423 demand of applications. For example, it
4424 appears that `objcopy' might not set the
4425 section of a symbol to be a section that is
4426 actually in the output file. */
4427 sec2 = bfd_get_section_by_name (abfd, sec->name);
4428 BFD_ASSERT (sec2 != 0);
4429 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
4430 BFD_ASSERT (shndx != -1);
4434 sym.st_shndx = shndx;
4437 if ((flags & BSF_FUNCTION) != 0)
4439 else if ((flags & BSF_OBJECT) != 0)
4444 /* Processor-specific types */
4445 if (type_ptr != NULL
4446 && bed->elf_backend_get_symbol_type)
4447 type = (*bed->elf_backend_get_symbol_type) (&type_ptr->internal_elf_sym, type);
4449 if (flags & BSF_SECTION_SYM)
4450 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
4451 else if (bfd_is_com_section (syms[idx]->section))
4452 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
4453 else if (bfd_is_und_section (syms[idx]->section))
4454 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
4458 else if (flags & BSF_FILE)
4459 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
4462 int bind = STB_LOCAL;
4464 if (flags & BSF_LOCAL)
4466 else if (flags & BSF_WEAK)
4468 else if (flags & BSF_GLOBAL)
4471 sym.st_info = ELF_ST_INFO (bind, type);
4474 if (type_ptr != NULL)
4475 sym.st_other = type_ptr->internal_elf_sym.st_other;
4479 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
4480 outbound_syms += bed->s->sizeof_sym;
4484 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
4485 symstrtab_hdr->sh_type = SHT_STRTAB;
4487 symstrtab_hdr->sh_flags = 0;
4488 symstrtab_hdr->sh_addr = 0;
4489 symstrtab_hdr->sh_entsize = 0;
4490 symstrtab_hdr->sh_link = 0;
4491 symstrtab_hdr->sh_info = 0;
4492 symstrtab_hdr->sh_addralign = 1;
4498 /* Return the number of bytes required to hold the symtab vector.
4500 Note that we base it on the count plus 1, since we will null terminate
4501 the vector allocated based on this size. However, the ELF symbol table
4502 always has a dummy entry as symbol #0, so it ends up even. */
4505 _bfd_elf_get_symtab_upper_bound (abfd)
4510 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
4512 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4513 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4519 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
4524 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
4526 if (elf_dynsymtab (abfd) == 0)
4528 bfd_set_error (bfd_error_invalid_operation);
4532 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
4533 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
4539 _bfd_elf_get_reloc_upper_bound (abfd, asect)
4540 bfd *abfd ATTRIBUTE_UNUSED;
4543 return (asect->reloc_count + 1) * sizeof (arelent *);
4546 /* Canonicalize the relocs. */
4549 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
4558 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd,
4564 tblptr = section->relocation;
4565 for (i = 0; i < section->reloc_count; i++)
4566 *relptr++ = tblptr++;
4570 return section->reloc_count;
4574 _bfd_elf_get_symtab (abfd, alocation)
4576 asymbol **alocation;
4578 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table
4579 (abfd, alocation, false);
4582 bfd_get_symcount (abfd) = symcount;
4587 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
4589 asymbol **alocation;
4591 return get_elf_backend_data (abfd)->s->slurp_symbol_table
4592 (abfd, alocation, true);
4595 /* Return the size required for the dynamic reloc entries. Any
4596 section that was actually installed in the BFD, and has type
4597 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4598 considered to be a dynamic reloc section. */
4601 _bfd_elf_get_dynamic_reloc_upper_bound (abfd)
4607 if (elf_dynsymtab (abfd) == 0)
4609 bfd_set_error (bfd_error_invalid_operation);
4613 ret = sizeof (arelent *);
4614 for (s = abfd->sections; s != NULL; s = s->next)
4615 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4616 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4617 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4618 ret += ((s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize)
4619 * sizeof (arelent *));
4624 /* Canonicalize the dynamic relocation entries. Note that we return
4625 the dynamic relocations as a single block, although they are
4626 actually associated with particular sections; the interface, which
4627 was designed for SunOS style shared libraries, expects that there
4628 is only one set of dynamic relocs. Any section that was actually
4629 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4630 the dynamic symbol table, is considered to be a dynamic reloc
4634 _bfd_elf_canonicalize_dynamic_reloc (abfd, storage, syms)
4639 boolean (*slurp_relocs) PARAMS ((bfd *, asection *, asymbol **, boolean));
4643 if (elf_dynsymtab (abfd) == 0)
4645 bfd_set_error (bfd_error_invalid_operation);
4649 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
4651 for (s = abfd->sections; s != NULL; s = s->next)
4653 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
4654 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
4655 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
4660 if (! (*slurp_relocs) (abfd, s, syms, true))
4662 count = s->_raw_size / elf_section_data (s)->this_hdr.sh_entsize;
4664 for (i = 0; i < count; i++)
4675 /* Read in the version information. */
4678 _bfd_elf_slurp_version_tables (abfd)
4681 bfd_byte *contents = NULL;
4683 if (elf_dynverdef (abfd) != 0)
4685 Elf_Internal_Shdr *hdr;
4686 Elf_External_Verdef *everdef;
4687 Elf_Internal_Verdef *iverdef;
4688 Elf_Internal_Verdef *iverdefarr;
4689 Elf_Internal_Verdef iverdefmem;
4691 unsigned int maxidx;
4693 hdr = &elf_tdata (abfd)->dynverdef_hdr;
4695 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4696 if (contents == NULL)
4698 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4699 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4702 /* We know the number of entries in the section but not the maximum
4703 index. Therefore we have to run through all entries and find
4705 everdef = (Elf_External_Verdef *) contents;
4707 for (i = 0; i < hdr->sh_info; ++i)
4709 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
4711 if ((iverdefmem.vd_ndx & VERSYM_VERSION) > maxidx)
4712 maxidx = iverdefmem.vd_ndx & VERSYM_VERSION;
4714 everdef = ((Elf_External_Verdef *)
4715 ((bfd_byte *) everdef + iverdefmem.vd_next));
4718 elf_tdata (abfd)->verdef =
4719 ((Elf_Internal_Verdef *)
4720 bfd_zalloc (abfd, maxidx * sizeof (Elf_Internal_Verdef)));
4721 if (elf_tdata (abfd)->verdef == NULL)
4724 elf_tdata (abfd)->cverdefs = maxidx;
4726 everdef = (Elf_External_Verdef *) contents;
4727 iverdefarr = elf_tdata (abfd)->verdef;
4728 for (i = 0; i < hdr->sh_info; i++)
4730 Elf_External_Verdaux *everdaux;
4731 Elf_Internal_Verdaux *iverdaux;
4734 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
4736 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
4737 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
4739 iverdef->vd_bfd = abfd;
4741 iverdef->vd_auxptr = ((Elf_Internal_Verdaux *)
4744 * sizeof (Elf_Internal_Verdaux))));
4745 if (iverdef->vd_auxptr == NULL)
4748 everdaux = ((Elf_External_Verdaux *)
4749 ((bfd_byte *) everdef + iverdef->vd_aux));
4750 iverdaux = iverdef->vd_auxptr;
4751 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
4753 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
4755 iverdaux->vda_nodename =
4756 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4757 iverdaux->vda_name);
4758 if (iverdaux->vda_nodename == NULL)
4761 if (j + 1 < iverdef->vd_cnt)
4762 iverdaux->vda_nextptr = iverdaux + 1;
4764 iverdaux->vda_nextptr = NULL;
4766 everdaux = ((Elf_External_Verdaux *)
4767 ((bfd_byte *) everdaux + iverdaux->vda_next));
4770 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
4772 if (i + 1 < hdr->sh_info)
4773 iverdef->vd_nextdef = iverdef + 1;
4775 iverdef->vd_nextdef = NULL;
4777 everdef = ((Elf_External_Verdef *)
4778 ((bfd_byte *) everdef + iverdef->vd_next));
4785 if (elf_dynverref (abfd) != 0)
4787 Elf_Internal_Shdr *hdr;
4788 Elf_External_Verneed *everneed;
4789 Elf_Internal_Verneed *iverneed;
4792 hdr = &elf_tdata (abfd)->dynverref_hdr;
4794 elf_tdata (abfd)->verref =
4795 ((Elf_Internal_Verneed *)
4796 bfd_zalloc (abfd, hdr->sh_info * sizeof (Elf_Internal_Verneed)));
4797 if (elf_tdata (abfd)->verref == NULL)
4800 elf_tdata (abfd)->cverrefs = hdr->sh_info;
4802 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
4803 if (contents == NULL)
4805 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
4806 || bfd_read ((PTR) contents, 1, hdr->sh_size, abfd) != hdr->sh_size)
4809 everneed = (Elf_External_Verneed *) contents;
4810 iverneed = elf_tdata (abfd)->verref;
4811 for (i = 0; i < hdr->sh_info; i++, iverneed++)
4813 Elf_External_Vernaux *evernaux;
4814 Elf_Internal_Vernaux *ivernaux;
4817 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
4819 iverneed->vn_bfd = abfd;
4821 iverneed->vn_filename =
4822 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4824 if (iverneed->vn_filename == NULL)
4827 iverneed->vn_auxptr =
4828 ((Elf_Internal_Vernaux *)
4830 iverneed->vn_cnt * sizeof (Elf_Internal_Vernaux)));
4832 evernaux = ((Elf_External_Vernaux *)
4833 ((bfd_byte *) everneed + iverneed->vn_aux));
4834 ivernaux = iverneed->vn_auxptr;
4835 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
4837 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
4839 ivernaux->vna_nodename =
4840 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4841 ivernaux->vna_name);
4842 if (ivernaux->vna_nodename == NULL)
4845 if (j + 1 < iverneed->vn_cnt)
4846 ivernaux->vna_nextptr = ivernaux + 1;
4848 ivernaux->vna_nextptr = NULL;
4850 evernaux = ((Elf_External_Vernaux *)
4851 ((bfd_byte *) evernaux + ivernaux->vna_next));
4854 if (i + 1 < hdr->sh_info)
4855 iverneed->vn_nextref = iverneed + 1;
4857 iverneed->vn_nextref = NULL;
4859 everneed = ((Elf_External_Verneed *)
4860 ((bfd_byte *) everneed + iverneed->vn_next));
4870 if (contents == NULL)
4876 _bfd_elf_make_empty_symbol (abfd)
4879 elf_symbol_type *newsym;
4881 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
4886 newsym->symbol.the_bfd = abfd;
4887 return &newsym->symbol;
4892 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
4893 bfd *ignore_abfd ATTRIBUTE_UNUSED;
4897 bfd_symbol_info (symbol, ret);
4900 /* Return whether a symbol name implies a local symbol. Most targets
4901 use this function for the is_local_label_name entry point, but some
4905 _bfd_elf_is_local_label_name (abfd, name)
4906 bfd *abfd ATTRIBUTE_UNUSED;
4909 /* Normal local symbols start with ``.L''. */
4910 if (name[0] == '.' && name[1] == 'L')
4913 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4914 DWARF debugging symbols starting with ``..''. */
4915 if (name[0] == '.' && name[1] == '.')
4918 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4919 emitting DWARF debugging output. I suspect this is actually a
4920 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4921 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4922 underscore to be emitted on some ELF targets). For ease of use,
4923 we treat such symbols as local. */
4924 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
4931 _bfd_elf_get_lineno (ignore_abfd, symbol)
4932 bfd *ignore_abfd ATTRIBUTE_UNUSED;
4933 asymbol *symbol ATTRIBUTE_UNUSED;
4940 _bfd_elf_set_arch_mach (abfd, arch, machine)
4942 enum bfd_architecture arch;
4943 unsigned long machine;
4945 /* If this isn't the right architecture for this backend, and this
4946 isn't the generic backend, fail. */
4947 if (arch != get_elf_backend_data (abfd)->arch
4948 && arch != bfd_arch_unknown
4949 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
4952 return bfd_default_set_arch_mach (abfd, arch, machine);
4955 /* Find the nearest line to a particular section and offset, for error
4959 _bfd_elf_find_nearest_line (abfd,
4970 CONST char **filename_ptr;
4971 CONST char **functionname_ptr;
4972 unsigned int *line_ptr;
4975 const char *filename;
4980 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4981 filename_ptr, functionname_ptr,
4985 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4986 filename_ptr, functionname_ptr,
4990 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4991 &found, filename_ptr,
4992 functionname_ptr, line_ptr,
4993 &elf_tdata (abfd)->line_info))
4998 if (symbols == NULL)
5005 for (p = symbols; *p != NULL; p++)
5009 q = (elf_symbol_type *) *p;
5011 if (bfd_get_section (&q->symbol) != section)
5014 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5019 filename = bfd_asymbol_name (&q->symbol);
5023 if (q->symbol.section == section
5024 && q->symbol.value >= low_func
5025 && q->symbol.value <= offset)
5027 func = (asymbol *) q;
5028 low_func = q->symbol.value;
5037 *filename_ptr = filename;
5038 *functionname_ptr = bfd_asymbol_name (func);
5044 _bfd_elf_sizeof_headers (abfd, reloc)
5050 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
5052 ret += get_program_header_size (abfd);
5057 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
5062 bfd_size_type count;
5064 Elf_Internal_Shdr *hdr;
5066 if (! abfd->output_has_begun
5067 && ! _bfd_elf_compute_section_file_positions
5068 (abfd, (struct bfd_link_info *) NULL))
5071 hdr = &elf_section_data (section)->this_hdr;
5073 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
5075 if (bfd_write (location, 1, count, abfd) != count)
5082 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
5083 bfd *abfd ATTRIBUTE_UNUSED;
5084 arelent *cache_ptr ATTRIBUTE_UNUSED;
5085 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED;
5092 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
5095 Elf_Internal_Rel *dst;
5101 /* Try to convert a non-ELF reloc into an ELF one. */
5104 _bfd_elf_validate_reloc (abfd, areloc)
5108 /* Check whether we really have an ELF howto. */
5110 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
5112 bfd_reloc_code_real_type code;
5113 reloc_howto_type *howto;
5115 /* Alien reloc: Try to determine its type to replace it with an
5116 equivalent ELF reloc. */
5118 if (areloc->howto->pc_relative)
5120 switch (areloc->howto->bitsize)
5123 code = BFD_RELOC_8_PCREL;
5126 code = BFD_RELOC_12_PCREL;
5129 code = BFD_RELOC_16_PCREL;
5132 code = BFD_RELOC_24_PCREL;
5135 code = BFD_RELOC_32_PCREL;
5138 code = BFD_RELOC_64_PCREL;
5144 howto = bfd_reloc_type_lookup (abfd, code);
5146 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
5148 if (howto->pcrel_offset)
5149 areloc->addend += areloc->address;
5151 areloc->addend -= areloc->address; /* addend is unsigned!! */
5156 switch (areloc->howto->bitsize)
5162 code = BFD_RELOC_14;
5165 code = BFD_RELOC_16;
5168 code = BFD_RELOC_26;
5171 code = BFD_RELOC_32;
5174 code = BFD_RELOC_64;
5180 howto = bfd_reloc_type_lookup (abfd, code);
5184 areloc->howto = howto;
5192 (*_bfd_error_handler)
5193 (_("%s: unsupported relocation type %s"),
5194 bfd_get_filename (abfd), areloc->howto->name);
5195 bfd_set_error (bfd_error_bad_value);
5200 _bfd_elf_close_and_cleanup (abfd)
5203 if (bfd_get_format (abfd) == bfd_object)
5205 if (elf_shstrtab (abfd) != NULL)
5206 _bfd_stringtab_free (elf_shstrtab (abfd));
5209 return _bfd_generic_close_and_cleanup (abfd);
5212 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
5213 in the relocation's offset. Thus we cannot allow any sort of sanity
5214 range-checking to interfere. There is nothing else to do in processing
5217 bfd_reloc_status_type
5218 _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
5219 bfd *abfd ATTRIBUTE_UNUSED;
5220 arelent *re ATTRIBUTE_UNUSED;
5221 struct symbol_cache_entry *symbol ATTRIBUTE_UNUSED;
5222 PTR data ATTRIBUTE_UNUSED;
5223 asection *is ATTRIBUTE_UNUSED;
5224 bfd *obfd ATTRIBUTE_UNUSED;
5225 char **errmsg ATTRIBUTE_UNUSED;
5227 return bfd_reloc_ok;
5231 /* Elf core file support. Much of this only works on native
5232 toolchains, since we rely on knowing the
5233 machine-dependent procfs structure in order to pick
5234 out details about the corefile. */
5236 #ifdef HAVE_SYS_PROCFS_H
5237 # include <sys/procfs.h>
5241 /* Define offsetof for those systems which lack it. */
5244 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
5248 /* FIXME: this is kinda wrong, but it's what gdb wants. */
5251 elfcore_make_pid (abfd)
5254 return ((elf_tdata (abfd)->core_lwpid << 16)
5255 + (elf_tdata (abfd)->core_pid));
5259 /* If there isn't a section called NAME, make one, using
5260 data from SECT. Note, this function will generate a
5261 reference to NAME, so you shouldn't deallocate or
5265 elfcore_maybe_make_sect (abfd, name, sect)
5272 if (bfd_get_section_by_name (abfd, name) != NULL)
5275 sect2 = bfd_make_section (abfd, name);
5279 sect2->_raw_size = sect->_raw_size;
5280 sect2->filepos = sect->filepos;
5281 sect2->flags = sect->flags;
5282 sect2->alignment_power = sect->alignment_power;
5287 /* prstatus_t exists on:
5289 linux 2.[01] + glibc
5293 #if defined (HAVE_PRSTATUS_T)
5295 elfcore_grok_prstatus (abfd, note)
5297 Elf_Internal_Note* note;
5304 if (note->descsz == sizeof (prstatus_t))
5308 raw_size = sizeof (prstat.pr_reg);
5309 memcpy (&prstat, note->descdata, sizeof (prstat));
5311 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5312 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5314 /* pr_who exists on:
5317 pr_who doesn't exist on:
5320 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5321 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5324 #if defined (__sparcv9)
5325 else if (note->descsz == sizeof (prstatus32_t))
5327 /* 64-bit host, 32-bit corefile */
5328 prstatus32_t prstat;
5330 raw_size = sizeof (prstat.pr_reg);
5331 memcpy (&prstat, note->descdata, sizeof (prstat));
5333 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
5334 elf_tdata (abfd)->core_pid = prstat.pr_pid;
5336 /* pr_who exists on:
5339 pr_who doesn't exist on:
5342 #if defined (HAVE_PRSTATUS_T_PR_WHO)
5343 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
5346 #endif /* __sparcv9 */
5349 /* Fail - we don't know how to handle any other
5350 note size (ie. data object type). */
5354 /* Make a ".reg/999" section. */
5356 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5357 name = bfd_alloc (abfd, strlen (buf) + 1);
5362 sect = bfd_make_section (abfd, name);
5366 if (note->descsz == sizeof (prstatus_t))
5368 sect->_raw_size = raw_size;
5369 sect->filepos = note->descpos + offsetof (prstatus_t, pr_reg);
5371 #if defined (__sparcv9)
5372 else if (note->descsz == sizeof (prstatus32_t))
5374 sect->_raw_size = raw_size;
5375 sect->filepos = note->descpos + offsetof (prstatus32_t, pr_reg);
5379 sect->flags = SEC_HAS_CONTENTS;
5380 sect->alignment_power = 2;
5382 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5387 #endif /* defined (HAVE_PRSTATUS_T) */
5390 /* Create a pseudosection containing the exact contents of NOTE. This
5391 actually creates up to two pseudosections:
5392 - For the single-threaded case, a section named NAME, unless
5393 such a section already exists.
5394 - For the multi-threaded case, a section named "NAME/PID", where
5395 PID is elfcore_make_pid (abfd).
5396 Both pseudosections have identical contents: the contents of NOTE. */
5399 elfcore_make_note_pseudosection (abfd, name, note)
5402 Elf_Internal_Note* note;
5405 char *threaded_name;
5408 /* Build the section name. */
5410 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
5411 threaded_name = bfd_alloc (abfd, strlen (buf) + 1);
5412 if (threaded_name == NULL)
5414 strcpy (threaded_name, buf);
5416 sect = bfd_make_section (abfd, threaded_name);
5419 sect->_raw_size = note->descsz;
5420 sect->filepos = note->descpos;
5421 sect->flags = SEC_HAS_CONTENTS;
5422 sect->alignment_power = 2;
5424 if (! elfcore_maybe_make_sect (abfd, name, sect))
5431 /* There isn't a consistent prfpregset_t across platforms,
5432 but it doesn't matter, because we don't have to pick this
5433 data structure apart. */
5435 elfcore_grok_prfpreg (abfd, note)
5437 Elf_Internal_Note* note;
5439 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
5443 /* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
5444 type of 5 (NT_PRXFPREG). Just include the whole note's contents
5447 elfcore_grok_prxfpreg (abfd, note)
5449 Elf_Internal_Note* note;
5451 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
5455 #if defined (HAVE_PRPSINFO_T)
5456 typedef prpsinfo_t elfcore_psinfo_t;
5457 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5458 typedef prpsinfo32_t elfcore_psinfo32_t;
5462 #if defined (HAVE_PSINFO_T)
5463 typedef psinfo_t elfcore_psinfo_t;
5464 #if defined (__sparcv9) /* Sparc64 cross Sparc32 */
5465 typedef psinfo32_t elfcore_psinfo32_t;
5470 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5472 /* return a malloc'ed copy of a string at START which is at
5473 most MAX bytes long, possibly without a terminating '\0'.
5474 the copy will always have a terminating '\0'. */
5477 elfcore_strndup (abfd, start, max)
5483 char* end = memchr (start, '\0', max);
5491 dup = bfd_alloc (abfd, len + 1);
5495 memcpy (dup, start, len);
5502 elfcore_grok_psinfo (abfd, note)
5504 Elf_Internal_Note* note;
5506 if (note->descsz == sizeof (elfcore_psinfo_t))
5508 elfcore_psinfo_t psinfo;
5510 memcpy (&psinfo, note->descdata, note->descsz);
5512 elf_tdata (abfd)->core_program
5513 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5515 elf_tdata (abfd)->core_command
5516 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5518 #if defined (__sparcv9)
5519 else if (note->descsz == sizeof (elfcore_psinfo32_t))
5521 /* 64-bit host, 32-bit corefile */
5522 elfcore_psinfo32_t psinfo;
5524 memcpy (&psinfo, note->descdata, note->descsz);
5526 elf_tdata (abfd)->core_program
5527 = elfcore_strndup (abfd, psinfo.pr_fname, sizeof (psinfo.pr_fname));
5529 elf_tdata (abfd)->core_command
5530 = elfcore_strndup (abfd, psinfo.pr_psargs, sizeof (psinfo.pr_psargs));
5536 /* Fail - we don't know how to handle any other
5537 note size (ie. data object type). */
5541 /* Note that for some reason, a spurious space is tacked
5542 onto the end of the args in some (at least one anyway)
5543 implementations, so strip it off if it exists. */
5546 char* command = elf_tdata (abfd)->core_command;
5547 int n = strlen (command);
5549 if (0 < n && command[n - 1] == ' ')
5550 command[n - 1] = '\0';
5555 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5558 #if defined (HAVE_PSTATUS_T)
5560 elfcore_grok_pstatus (abfd, note)
5562 Elf_Internal_Note* note;
5564 if (note->descsz == sizeof (pstatus_t))
5568 memcpy (&pstat, note->descdata, sizeof (pstat));
5570 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5572 #if defined (__sparcv9)
5573 else if (note->descsz == sizeof (pstatus32_t))
5575 /* 64-bit host, 32-bit corefile */
5578 memcpy (&pstat, note->descdata, sizeof (pstat));
5580 elf_tdata (abfd)->core_pid = pstat.pr_pid;
5583 /* Could grab some more details from the "representative"
5584 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5585 NT_LWPSTATUS note, presumably. */
5589 #endif /* defined (HAVE_PSTATUS_T) */
5592 #if defined (HAVE_LWPSTATUS_T)
5594 elfcore_grok_lwpstatus (abfd, note)
5596 Elf_Internal_Note* note;
5598 lwpstatus_t lwpstat;
5603 if (note->descsz != sizeof (lwpstat))
5606 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
5608 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
5609 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
5611 /* Make a ".reg/999" section. */
5613 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
5614 name = bfd_alloc (abfd, strlen (buf) + 1);
5619 sect = bfd_make_section (abfd, name);
5623 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5624 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
5625 sect->filepos = note->descpos
5626 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
5629 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5630 sect->_raw_size = sizeof (lwpstat.pr_reg);
5631 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
5634 sect->flags = SEC_HAS_CONTENTS;
5635 sect->alignment_power = 2;
5637 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
5640 /* Make a ".reg2/999" section */
5642 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
5643 name = bfd_alloc (abfd, strlen (buf) + 1);
5648 sect = bfd_make_section (abfd, name);
5652 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5653 sect->_raw_size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
5654 sect->filepos = note->descpos
5655 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
5658 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5659 sect->_raw_size = sizeof (lwpstat.pr_fpreg);
5660 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
5663 sect->flags = SEC_HAS_CONTENTS;
5664 sect->alignment_power = 2;
5666 if (!elfcore_maybe_make_sect (abfd, ".reg2", sect))
5671 #endif /* defined (HAVE_LWPSTATUS_T) */
5673 #if defined (HAVE_WIN32_PSTATUS_T)
5675 elfcore_grok_win32pstatus (abfd, note)
5677 Elf_Internal_Note * note;
5682 win32_pstatus_t pstatus;
5684 if (note->descsz < sizeof (pstatus))
5687 memcpy (& pstatus, note->descdata, note->descsz);
5689 switch (pstatus.data_type)
5691 case NOTE_INFO_PROCESS:
5692 /* FIXME: need to add ->core_command. */
5693 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
5694 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
5697 case NOTE_INFO_THREAD:
5698 /* Make a ".reg/999" section. */
5699 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
5701 name = bfd_alloc (abfd, strlen (buf) + 1);
5707 sect = bfd_make_section (abfd, name);
5711 sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
5712 sect->filepos = note->descpos + offsetof (struct win32_pstatus,
5713 data.thread_info.thread_context);
5714 sect->flags = SEC_HAS_CONTENTS;
5715 sect->alignment_power = 2;
5717 if (pstatus.data.thread_info.is_active_thread)
5718 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
5722 case NOTE_INFO_MODULE:
5723 /* Make a ".module/xxxxxxxx" section. */
5724 sprintf (buf, ".module/%08x" , pstatus.data.module_info.base_address);
5726 name = bfd_alloc (abfd, strlen (buf) + 1);
5732 sect = bfd_make_section (abfd, name);
5737 sect->_raw_size = note->descsz;
5738 sect->filepos = note->descpos;
5739 sect->flags = SEC_HAS_CONTENTS;
5740 sect->alignment_power = 2;
5749 #endif /* HAVE_WIN32_PSTATUS_T */
5752 elfcore_grok_note (abfd, note)
5754 Elf_Internal_Note* note;
5761 #if defined (HAVE_PRSTATUS_T)
5763 return elfcore_grok_prstatus (abfd, note);
5766 #if defined (HAVE_PSTATUS_T)
5768 return elfcore_grok_pstatus (abfd, note);
5771 #if defined (HAVE_LWPSTATUS_T)
5773 return elfcore_grok_lwpstatus (abfd, note);
5776 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
5777 return elfcore_grok_prfpreg (abfd, note);
5779 #if defined (HAVE_WIN32_PSTATUS_T)
5780 case NT_WIN32PSTATUS:
5781 return elfcore_grok_win32pstatus (abfd, note);
5784 case NT_PRXFPREG: /* Linux SSE extension */
5785 if (note->namesz == 5
5786 && ! strcmp (note->namedata, "LINUX"))
5787 return elfcore_grok_prxfpreg (abfd, note);
5791 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5794 return elfcore_grok_psinfo (abfd, note);
5801 elfcore_read_notes (abfd, offset, size)
5812 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
5815 buf = bfd_malloc ((size_t) size);
5819 if (bfd_read (buf, size, 1, abfd) != size)
5827 while (p < buf + size)
5829 /* FIXME: bad alignment assumption. */
5830 Elf_External_Note* xnp = (Elf_External_Note*) p;
5831 Elf_Internal_Note in;
5833 in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
5835 in.namesz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->namesz);
5836 in.namedata = xnp->name;
5838 in.descsz = bfd_h_get_32 (abfd, (bfd_byte *) xnp->descsz);
5839 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
5840 in.descpos = offset + (in.descdata - buf);
5842 if (! elfcore_grok_note (abfd, &in))
5845 p = in.descdata + BFD_ALIGN (in.descsz, 4);
5853 /* FIXME: This function is now unnecessary. Callers can just call
5854 bfd_section_from_phdr directly. */
5857 _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
5859 Elf_Internal_Phdr* phdr;
5862 if (! bfd_section_from_phdr (abfd, phdr, sec_num))
5870 /* Providing external access to the ELF program header table. */
5872 /* Return an upper bound on the number of bytes required to store a
5873 copy of ABFD's program header table entries. Return -1 if an error
5874 occurs; bfd_get_error will return an appropriate code. */
5876 bfd_get_elf_phdr_upper_bound (abfd)
5879 if (abfd->xvec->flavour != bfd_target_elf_flavour)
5881 bfd_set_error (bfd_error_wrong_format);
5885 return (elf_elfheader (abfd)->e_phnum
5886 * sizeof (Elf_Internal_Phdr));
5890 /* Copy ABFD's program header table entries to *PHDRS. The entries
5891 will be stored as an array of Elf_Internal_Phdr structures, as
5892 defined in include/elf/internal.h. To find out how large the
5893 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
5895 Return the number of program header table entries read, or -1 if an
5896 error occurs; bfd_get_error will return an appropriate code. */
5898 bfd_get_elf_phdrs (abfd, phdrs)
5904 if (abfd->xvec->flavour != bfd_target_elf_flavour)
5906 bfd_set_error (bfd_error_wrong_format);
5910 num_phdrs = elf_elfheader (abfd)->e_phnum;
5911 memcpy (phdrs, elf_tdata (abfd)->phdr,
5912 num_phdrs * sizeof (Elf_Internal_Phdr));