1 /* ELF executable support for BFD.
2 Copyright 1993, 1994, 1995, 1996 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
41 static INLINE struct elf_segment_map *make_mapping
42 PARAMS ((bfd *, asection **, unsigned int, unsigned int));
43 static int elf_sort_sections PARAMS ((const PTR, const PTR));
44 static boolean assign_file_positions_for_segments PARAMS ((bfd *));
45 static boolean assign_file_positions_except_relocs PARAMS ((bfd *));
46 static boolean prep_headers PARAMS ((bfd *));
47 static boolean swap_out_syms PARAMS ((bfd *, struct bfd_strtab_hash **));
48 static boolean copy_private_bfd_data PARAMS ((bfd *, bfd *));
50 /* Standard ELF hash function. Do not change this function; you will
51 cause invalid hash tables to be generated. (Well, you would if this
52 were being used yet.) */
55 CONST unsigned char *name;
61 while ((ch = *name++) != '\0')
64 if ((g = (h & 0xf0000000)) != 0)
73 /* Read a specified number of bytes at a specified offset in an ELF
74 file, into a newly allocated buffer, and return a pointer to the
78 elf_read (abfd, offset, size)
85 if ((buf = bfd_alloc (abfd, size)) == NULL)
87 if (bfd_seek (abfd, offset, SEEK_SET) == -1)
89 if (bfd_read ((PTR) buf, size, 1, abfd) != size)
91 if (bfd_get_error () != bfd_error_system_call)
92 bfd_set_error (bfd_error_file_truncated);
102 /* this just does initialization */
103 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
104 elf_tdata (abfd) = (struct elf_obj_tdata *)
105 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
106 if (elf_tdata (abfd) == 0)
108 /* since everything is done at close time, do we need any
115 bfd_elf_get_str_section (abfd, shindex)
117 unsigned int shindex;
119 Elf_Internal_Shdr **i_shdrp;
120 char *shstrtab = NULL;
122 unsigned int shstrtabsize;
124 i_shdrp = elf_elfsections (abfd);
125 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
128 shstrtab = (char *) i_shdrp[shindex]->contents;
129 if (shstrtab == NULL)
131 /* No cached one, attempt to read, and cache what we read. */
132 offset = i_shdrp[shindex]->sh_offset;
133 shstrtabsize = i_shdrp[shindex]->sh_size;
134 shstrtab = elf_read (abfd, offset, shstrtabsize);
135 i_shdrp[shindex]->contents = (PTR) shstrtab;
141 bfd_elf_string_from_elf_section (abfd, shindex, strindex)
143 unsigned int shindex;
144 unsigned int strindex;
146 Elf_Internal_Shdr *hdr;
151 hdr = elf_elfsections (abfd)[shindex];
153 if (hdr->contents == NULL
154 && bfd_elf_get_str_section (abfd, shindex) == NULL)
157 return ((char *) hdr->contents) + strindex;
160 /* Make a BFD section from an ELF section. We store a pointer to the
161 BFD section in the bfd_section field of the header. */
164 _bfd_elf_make_section_from_shdr (abfd, hdr, name)
166 Elf_Internal_Shdr *hdr;
172 if (hdr->bfd_section != NULL)
174 BFD_ASSERT (strcmp (name,
175 bfd_get_section_name (abfd, hdr->bfd_section)) == 0);
179 newsect = bfd_make_section_anyway (abfd, name);
183 newsect->filepos = hdr->sh_offset;
185 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
186 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
187 || ! bfd_set_section_alignment (abfd, newsect,
188 bfd_log2 (hdr->sh_addralign)))
191 flags = SEC_NO_FLAGS;
192 if (hdr->sh_type != SHT_NOBITS)
193 flags |= SEC_HAS_CONTENTS;
194 if ((hdr->sh_flags & SHF_ALLOC) != 0)
197 if (hdr->sh_type != SHT_NOBITS)
200 if ((hdr->sh_flags & SHF_WRITE) == 0)
201 flags |= SEC_READONLY;
202 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
204 else if ((flags & SEC_LOAD) != 0)
207 /* The debugging sections appear to be recognized only by name, not
209 if (strncmp (name, ".debug", sizeof ".debug" - 1) == 0
210 || strncmp (name, ".line", sizeof ".line" - 1) == 0
211 || strncmp (name, ".stab", sizeof ".stab" - 1) == 0)
212 flags |= SEC_DEBUGGING;
214 if (! bfd_set_section_flags (abfd, newsect, flags))
217 if ((flags & SEC_ALLOC) != 0)
219 Elf_Internal_Phdr *phdr;
222 /* Look through the phdrs to see if we need to adjust the lma. */
223 phdr = elf_tdata (abfd)->phdr;
224 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
226 if (phdr->p_type == PT_LOAD
227 && phdr->p_paddr != 0
228 && phdr->p_vaddr != phdr->p_paddr
229 && phdr->p_vaddr <= hdr->sh_addr
230 && phdr->p_vaddr + phdr->p_memsz >= hdr->sh_addr + hdr->sh_size)
232 newsect->lma += phdr->p_paddr - phdr->p_vaddr;
238 hdr->bfd_section = newsect;
239 elf_section_data (newsect)->this_hdr = *hdr;
249 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
252 Helper functions for GDB to locate the string tables.
253 Since BFD hides string tables from callers, GDB needs to use an
254 internal hook to find them. Sun's .stabstr, in particular,
255 isn't even pointed to by the .stab section, so ordinary
256 mechanisms wouldn't work to find it, even if we had some.
259 struct elf_internal_shdr *
260 bfd_elf_find_section (abfd, name)
264 Elf_Internal_Shdr **i_shdrp;
269 i_shdrp = elf_elfsections (abfd);
272 shstrtab = bfd_elf_get_str_section (abfd, elf_elfheader (abfd)->e_shstrndx);
273 if (shstrtab != NULL)
275 max = elf_elfheader (abfd)->e_shnum;
276 for (i = 1; i < max; i++)
277 if (!strcmp (&shstrtab[i_shdrp[i]->sh_name], name))
284 const char *const bfd_elf_section_type_names[] = {
285 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
286 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
287 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
290 /* ELF relocs are against symbols. If we are producing relocateable
291 output, and the reloc is against an external symbol, and nothing
292 has given us any additional addend, the resulting reloc will also
293 be against the same symbol. In such a case, we don't want to
294 change anything about the way the reloc is handled, since it will
295 all be done at final link time. Rather than put special case code
296 into bfd_perform_relocation, all the reloc types use this howto
297 function. It just short circuits the reloc if producing
298 relocateable output against an external symbol. */
301 bfd_reloc_status_type
302 bfd_elf_generic_reloc (abfd,
310 arelent *reloc_entry;
313 asection *input_section;
315 char **error_message;
317 if (output_bfd != (bfd *) NULL
318 && (symbol->flags & BSF_SECTION_SYM) == 0
319 && (! reloc_entry->howto->partial_inplace
320 || reloc_entry->addend == 0))
322 reloc_entry->address += input_section->output_offset;
326 return bfd_reloc_continue;
329 /* Print out the program headers. */
332 _bfd_elf_print_private_bfd_data (abfd, farg)
336 FILE *f = (FILE *) farg;
337 Elf_Internal_Phdr *p;
339 bfd_byte *dynbuf = NULL;
341 p = elf_tdata (abfd)->phdr;
346 fprintf (f, "\nProgram Header:\n");
347 c = elf_elfheader (abfd)->e_phnum;
348 for (i = 0; i < c; i++, p++)
355 case PT_NULL: s = "NULL"; break;
356 case PT_LOAD: s = "LOAD"; break;
357 case PT_DYNAMIC: s = "DYNAMIC"; break;
358 case PT_INTERP: s = "INTERP"; break;
359 case PT_NOTE: s = "NOTE"; break;
360 case PT_SHLIB: s = "SHLIB"; break;
361 case PT_PHDR: s = "PHDR"; break;
362 default: sprintf (buf, "0x%lx", p->p_type); s = buf; break;
364 fprintf (f, "%8s off 0x", s);
365 fprintf_vma (f, p->p_offset);
366 fprintf (f, " vaddr 0x");
367 fprintf_vma (f, p->p_vaddr);
368 fprintf (f, " paddr 0x");
369 fprintf_vma (f, p->p_paddr);
370 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
371 fprintf (f, " filesz 0x");
372 fprintf_vma (f, p->p_filesz);
373 fprintf (f, " memsz 0x");
374 fprintf_vma (f, p->p_memsz);
375 fprintf (f, " flags %c%c%c",
376 (p->p_flags & PF_R) != 0 ? 'r' : '-',
377 (p->p_flags & PF_W) != 0 ? 'w' : '-',
378 (p->p_flags & PF_X) != 0 ? 'x' : '-');
379 if ((p->p_flags &~ (PF_R | PF_W | PF_X)) != 0)
380 fprintf (f, " %lx", p->p_flags &~ (PF_R | PF_W | PF_X));
385 s = bfd_get_section_by_name (abfd, ".dynamic");
390 bfd_byte *extdyn, *extdynend;
392 void (*swap_dyn_in) PARAMS ((bfd *, const PTR, Elf_Internal_Dyn *));
394 fprintf (f, "\nDynamic Section:\n");
396 dynbuf = (bfd_byte *) bfd_malloc (s->_raw_size);
399 if (! bfd_get_section_contents (abfd, s, (PTR) dynbuf, (file_ptr) 0,
403 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
406 link = elf_elfsections (abfd)[elfsec]->sh_link;
408 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
409 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
412 extdynend = extdyn + s->_raw_size;
413 for (; extdyn < extdynend; extdyn += extdynsize)
415 Elf_Internal_Dyn dyn;
420 (*swap_dyn_in) (abfd, (PTR) extdyn, &dyn);
422 if (dyn.d_tag == DT_NULL)
429 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
433 case DT_NEEDED: name = "NEEDED"; stringp = true; break;
434 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
435 case DT_PLTGOT: name = "PLTGOT"; break;
436 case DT_HASH: name = "HASH"; break;
437 case DT_STRTAB: name = "STRTAB"; break;
438 case DT_SYMTAB: name = "SYMTAB"; break;
439 case DT_RELA: name = "RELA"; break;
440 case DT_RELASZ: name = "RELASZ"; break;
441 case DT_RELAENT: name = "RELAENT"; break;
442 case DT_STRSZ: name = "STRSZ"; break;
443 case DT_SYMENT: name = "SYMENT"; break;
444 case DT_INIT: name = "INIT"; break;
445 case DT_FINI: name = "FINI"; break;
446 case DT_SONAME: name = "SONAME"; stringp = true; break;
447 case DT_RPATH: name = "RPATH"; stringp = true; break;
448 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
449 case DT_REL: name = "REL"; break;
450 case DT_RELSZ: name = "RELSZ"; break;
451 case DT_RELENT: name = "RELENT"; break;
452 case DT_PLTREL: name = "PLTREL"; break;
453 case DT_DEBUG: name = "DEBUG"; break;
454 case DT_TEXTREL: name = "TEXTREL"; break;
455 case DT_JMPREL: name = "JMPREL"; break;
458 fprintf (f, " %-11s ", name);
460 fprintf (f, "0x%lx", (unsigned long) dyn.d_un.d_val);
465 string = bfd_elf_string_from_elf_section (abfd, link,
469 fprintf (f, "%s", string);
486 /* Display ELF-specific fields of a symbol. */
488 bfd_elf_print_symbol (ignore_abfd, filep, symbol, how)
492 bfd_print_symbol_type how;
494 FILE *file = (FILE *) filep;
497 case bfd_print_symbol_name:
498 fprintf (file, "%s", symbol->name);
500 case bfd_print_symbol_more:
501 fprintf (file, "elf ");
502 fprintf_vma (file, symbol->value);
503 fprintf (file, " %lx", (long) symbol->flags);
505 case bfd_print_symbol_all:
507 CONST char *section_name;
508 section_name = symbol->section ? symbol->section->name : "(*none*)";
509 bfd_print_symbol_vandf ((PTR) file, symbol);
510 fprintf (file, " %s\t", section_name);
511 /* Print the "other" value for a symbol. For common symbols,
512 we've already printed the size; now print the alignment.
513 For other symbols, we have no specified alignment, and
514 we've printed the address; now print the size. */
516 (bfd_is_com_section (symbol->section)
517 ? ((elf_symbol_type *) symbol)->internal_elf_sym.st_value
518 : ((elf_symbol_type *) symbol)->internal_elf_sym.st_size));
519 fprintf (file, " %s", symbol->name);
525 /* Create an entry in an ELF linker hash table. */
527 struct bfd_hash_entry *
528 _bfd_elf_link_hash_newfunc (entry, table, string)
529 struct bfd_hash_entry *entry;
530 struct bfd_hash_table *table;
533 struct elf_link_hash_entry *ret = (struct elf_link_hash_entry *) entry;
535 /* Allocate the structure if it has not already been allocated by a
537 if (ret == (struct elf_link_hash_entry *) NULL)
538 ret = ((struct elf_link_hash_entry *)
539 bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry)));
540 if (ret == (struct elf_link_hash_entry *) NULL)
541 return (struct bfd_hash_entry *) ret;
543 /* Call the allocation method of the superclass. */
544 ret = ((struct elf_link_hash_entry *)
545 _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
547 if (ret != (struct elf_link_hash_entry *) NULL)
549 /* Set local fields. */
553 ret->dynstr_index = 0;
555 ret->got_offset = (bfd_vma) -1;
556 ret->plt_offset = (bfd_vma) -1;
557 ret->linker_section_pointer = (elf_linker_section_pointers_t *)0;
558 ret->type = STT_NOTYPE;
559 ret->elf_link_hash_flags = 0;
562 return (struct bfd_hash_entry *) ret;
565 /* Initialize an ELF linker hash table. */
568 _bfd_elf_link_hash_table_init (table, abfd, newfunc)
569 struct elf_link_hash_table *table;
571 struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
572 struct bfd_hash_table *,
575 table->dynamic_sections_created = false;
576 table->dynobj = NULL;
577 /* The first dynamic symbol is a dummy. */
578 table->dynsymcount = 1;
579 table->dynstr = NULL;
580 table->bucketcount = 0;
581 table->needed = NULL;
582 return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
585 /* Create an ELF linker hash table. */
587 struct bfd_link_hash_table *
588 _bfd_elf_link_hash_table_create (abfd)
591 struct elf_link_hash_table *ret;
593 ret = ((struct elf_link_hash_table *)
594 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
595 if (ret == (struct elf_link_hash_table *) NULL)
598 if (! _bfd_elf_link_hash_table_init (ret, abfd, _bfd_elf_link_hash_newfunc))
600 bfd_release (abfd, ret);
607 /* This is a hook for the ELF emulation code in the generic linker to
608 tell the backend linker what file name to use for the DT_NEEDED
609 entry for a dynamic object. The generic linker passes name as an
610 empty string to indicate that no DT_NEEDED entry should be made. */
613 bfd_elf_set_dt_needed_name (abfd, name)
617 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
618 elf_dt_needed_name (abfd) = name;
621 /* Get the list of DT_NEEDED entries for a link. */
623 struct bfd_link_needed_list *
624 bfd_elf_get_needed_list (abfd, info)
626 struct bfd_link_info *info;
628 if (info->hash->creator->flavour != bfd_target_elf_flavour)
630 return elf_hash_table (info)->needed;
633 /* Allocate an ELF string table--force the first byte to be zero. */
635 struct bfd_strtab_hash *
636 _bfd_elf_stringtab_init ()
638 struct bfd_strtab_hash *ret;
640 ret = _bfd_stringtab_init ();
645 loc = _bfd_stringtab_add (ret, "", true, false);
646 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
647 if (loc == (bfd_size_type) -1)
649 _bfd_stringtab_free (ret);
656 /* ELF .o/exec file reading */
658 /* Create a new bfd section from an ELF section header. */
661 bfd_section_from_shdr (abfd, shindex)
663 unsigned int shindex;
665 Elf_Internal_Shdr *hdr = elf_elfsections (abfd)[shindex];
666 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
667 struct elf_backend_data *bed = get_elf_backend_data (abfd);
670 name = elf_string_from_elf_strtab (abfd, hdr->sh_name);
672 switch (hdr->sh_type)
675 /* Inactive section. Throw it away. */
678 case SHT_PROGBITS: /* Normal section with contents. */
679 case SHT_DYNAMIC: /* Dynamic linking information. */
680 case SHT_NOBITS: /* .bss section. */
681 case SHT_HASH: /* .hash section. */
682 case SHT_NOTE: /* .note section. */
683 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
685 case SHT_SYMTAB: /* A symbol table */
686 if (elf_onesymtab (abfd) == shindex)
689 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
690 BFD_ASSERT (elf_onesymtab (abfd) == 0);
691 elf_onesymtab (abfd) = shindex;
692 elf_tdata (abfd)->symtab_hdr = *hdr;
693 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
694 abfd->flags |= HAS_SYMS;
696 /* Sometimes a shared object will map in the symbol table. If
697 SHF_ALLOC is set, and this is a shared object, then we also
698 treat this section as a BFD section. We can not base the
699 decision purely on SHF_ALLOC, because that flag is sometimes
700 set in a relocateable object file, which would confuse the
702 if ((hdr->sh_flags & SHF_ALLOC) != 0
703 && (abfd->flags & DYNAMIC) != 0
704 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
709 case SHT_DYNSYM: /* A dynamic symbol table */
710 if (elf_dynsymtab (abfd) == shindex)
713 BFD_ASSERT (hdr->sh_entsize == bed->s->sizeof_sym);
714 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
715 elf_dynsymtab (abfd) = shindex;
716 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
717 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
718 abfd->flags |= HAS_SYMS;
720 /* Besides being a symbol table, we also treat this as a regular
721 section, so that objcopy can handle it. */
722 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
724 case SHT_STRTAB: /* A string table */
725 if (hdr->bfd_section != NULL)
727 if (ehdr->e_shstrndx == shindex)
729 elf_tdata (abfd)->shstrtab_hdr = *hdr;
730 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
736 for (i = 1; i < ehdr->e_shnum; i++)
738 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
739 if (hdr2->sh_link == shindex)
741 if (! bfd_section_from_shdr (abfd, i))
743 if (elf_onesymtab (abfd) == i)
745 elf_tdata (abfd)->strtab_hdr = *hdr;
746 elf_elfsections (abfd)[shindex] =
747 &elf_tdata (abfd)->strtab_hdr;
750 if (elf_dynsymtab (abfd) == i)
752 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
753 elf_elfsections (abfd)[shindex] = hdr =
754 &elf_tdata (abfd)->dynstrtab_hdr;
755 /* We also treat this as a regular section, so
756 that objcopy can handle it. */
759 #if 0 /* Not handling other string tables specially right now. */
760 hdr2 = elf_elfsections (abfd)[i]; /* in case it moved */
761 /* We have a strtab for some random other section. */
762 newsect = (asection *) hdr2->bfd_section;
765 hdr->bfd_section = newsect;
766 hdr2 = &elf_section_data (newsect)->str_hdr;
768 elf_elfsections (abfd)[shindex] = hdr2;
774 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
778 /* *These* do a lot of work -- but build no sections! */
780 asection *target_sect;
781 Elf_Internal_Shdr *hdr2;
782 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
784 /* For some incomprehensible reason Oracle distributes
785 libraries for Solaris in which some of the objects have
786 bogus sh_link fields. It would be nice if we could just
787 reject them, but, unfortunately, some people need to use
788 them. We scan through the section headers; if we find only
789 one suitable symbol table, we clobber the sh_link to point
790 to it. I hope this doesn't break anything. */
791 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
792 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
798 for (scan = 1; scan < ehdr->e_shnum; scan++)
800 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
801 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
812 hdr->sh_link = found;
815 /* Get the symbol table. */
816 if (elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
817 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
820 /* If this reloc section does not use the main symbol table we
821 don't treat it as a reloc section. BFD can't adequately
822 represent such a section, so at least for now, we don't
823 try. We just present it as a normal section. */
824 if (hdr->sh_link != elf_onesymtab (abfd))
825 return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
827 /* Don't allow REL relocations on a machine that uses RELA and
829 /* @@ Actually, the generic ABI does suggest that both might be
830 used in one file. But the four ABI Processor Supplements I
831 have access to right now all specify that only one is used on
832 each of those architectures. It's conceivable that, e.g., a
833 bunch of absolute 32-bit relocs might be more compact in REL
834 form even on a RELA machine... */
835 BFD_ASSERT (use_rela_p
836 ? (hdr->sh_type == SHT_RELA
837 && hdr->sh_entsize == bed->s->sizeof_rela)
838 : (hdr->sh_type == SHT_REL
839 && hdr->sh_entsize == bed->s->sizeof_rel));
841 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
843 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
844 if (target_sect == NULL)
847 hdr2 = &elf_section_data (target_sect)->rel_hdr;
849 elf_elfsections (abfd)[shindex] = hdr2;
850 target_sect->reloc_count = hdr->sh_size / hdr->sh_entsize;
851 target_sect->flags |= SEC_RELOC;
852 target_sect->relocation = NULL;
853 target_sect->rel_filepos = hdr->sh_offset;
854 abfd->flags |= HAS_RELOC;
863 /* Check for any processor-specific section types. */
865 if (bed->elf_backend_section_from_shdr)
866 (*bed->elf_backend_section_from_shdr) (abfd, hdr, name);
874 /* Given an ELF section number, retrieve the corresponding BFD
878 bfd_section_from_elf_index (abfd, index)
882 BFD_ASSERT (index > 0 && index < SHN_LORESERVE);
883 if (index >= elf_elfheader (abfd)->e_shnum)
885 return elf_elfsections (abfd)[index]->bfd_section;
889 _bfd_elf_new_section_hook (abfd, sec)
893 struct bfd_elf_section_data *sdata;
895 sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
898 sec->used_by_bfd = (PTR) sdata;
899 memset (sdata, 0, sizeof (*sdata));
903 /* Create a new bfd section from an ELF program header.
905 Since program segments have no names, we generate a synthetic name
906 of the form segment<NUM>, where NUM is generally the index in the
907 program header table. For segments that are split (see below) we
908 generate the names segment<NUM>a and segment<NUM>b.
910 Note that some program segments may have a file size that is different than
911 (less than) the memory size. All this means is that at execution the
912 system must allocate the amount of memory specified by the memory size,
913 but only initialize it with the first "file size" bytes read from the
914 file. This would occur for example, with program segments consisting
915 of combined data+bss.
917 To handle the above situation, this routine generates TWO bfd sections
918 for the single program segment. The first has the length specified by
919 the file size of the segment, and the second has the length specified
920 by the difference between the two sizes. In effect, the segment is split
921 into it's initialized and uninitialized parts.
926 bfd_section_from_phdr (abfd, hdr, index)
928 Elf_Internal_Phdr *hdr;
936 split = ((hdr->p_memsz > 0) &&
937 (hdr->p_filesz > 0) &&
938 (hdr->p_memsz > hdr->p_filesz));
939 sprintf (namebuf, split ? "segment%da" : "segment%d", index);
940 name = bfd_alloc (abfd, strlen (namebuf) + 1);
943 strcpy (name, namebuf);
944 newsect = bfd_make_section (abfd, name);
947 newsect->vma = hdr->p_vaddr;
948 newsect->lma = hdr->p_paddr;
949 newsect->_raw_size = hdr->p_filesz;
950 newsect->filepos = hdr->p_offset;
951 newsect->flags |= SEC_HAS_CONTENTS;
952 if (hdr->p_type == PT_LOAD)
954 newsect->flags |= SEC_ALLOC;
955 newsect->flags |= SEC_LOAD;
956 if (hdr->p_flags & PF_X)
958 /* FIXME: all we known is that it has execute PERMISSION,
960 newsect->flags |= SEC_CODE;
963 if (!(hdr->p_flags & PF_W))
965 newsect->flags |= SEC_READONLY;
970 sprintf (namebuf, "segment%db", index);
971 name = bfd_alloc (abfd, strlen (namebuf) + 1);
974 strcpy (name, namebuf);
975 newsect = bfd_make_section (abfd, name);
978 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
979 newsect->lma = hdr->p_paddr + hdr->p_filesz;
980 newsect->_raw_size = hdr->p_memsz - hdr->p_filesz;
981 if (hdr->p_type == PT_LOAD)
983 newsect->flags |= SEC_ALLOC;
984 if (hdr->p_flags & PF_X)
985 newsect->flags |= SEC_CODE;
987 if (!(hdr->p_flags & PF_W))
988 newsect->flags |= SEC_READONLY;
994 /* Set up an ELF internal section header for a section. */
998 elf_fake_sections (abfd, asect, failedptrarg)
1003 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1004 boolean *failedptr = (boolean *) failedptrarg;
1005 Elf_Internal_Shdr *this_hdr;
1009 /* We already failed; just get out of the bfd_map_over_sections
1014 this_hdr = &elf_section_data (asect)->this_hdr;
1016 this_hdr->sh_name = (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd),
1019 if (this_hdr->sh_name == (unsigned long) -1)
1025 this_hdr->sh_flags = 0;
1027 if ((asect->flags & SEC_ALLOC) != 0)
1028 this_hdr->sh_addr = asect->vma;
1030 this_hdr->sh_addr = 0;
1032 this_hdr->sh_offset = 0;
1033 this_hdr->sh_size = asect->_raw_size;
1034 this_hdr->sh_link = 0;
1035 this_hdr->sh_addralign = 1 << asect->alignment_power;
1036 /* The sh_entsize and sh_info fields may have been set already by
1037 copy_private_section_data. */
1039 this_hdr->bfd_section = asect;
1040 this_hdr->contents = NULL;
1042 /* FIXME: This should not be based on section names. */
1043 if (strcmp (asect->name, ".dynstr") == 0)
1044 this_hdr->sh_type = SHT_STRTAB;
1045 else if (strcmp (asect->name, ".hash") == 0)
1047 this_hdr->sh_type = SHT_HASH;
1048 this_hdr->sh_entsize = bed->s->arch_size / 8;
1050 else if (strcmp (asect->name, ".dynsym") == 0)
1052 this_hdr->sh_type = SHT_DYNSYM;
1053 this_hdr->sh_entsize = bed->s->sizeof_sym;
1055 else if (strcmp (asect->name, ".dynamic") == 0)
1057 this_hdr->sh_type = SHT_DYNAMIC;
1058 this_hdr->sh_entsize = bed->s->sizeof_dyn;
1060 else if (strncmp (asect->name, ".rela", 5) == 0
1061 && get_elf_backend_data (abfd)->use_rela_p)
1063 this_hdr->sh_type = SHT_RELA;
1064 this_hdr->sh_entsize = bed->s->sizeof_rela;
1066 else if (strncmp (asect->name, ".rel", 4) == 0
1067 && ! get_elf_backend_data (abfd)->use_rela_p)
1069 this_hdr->sh_type = SHT_REL;
1070 this_hdr->sh_entsize = bed->s->sizeof_rel;
1072 else if (strcmp (asect->name, ".note") == 0)
1073 this_hdr->sh_type = SHT_NOTE;
1074 else if (strncmp (asect->name, ".stab", 5) == 0
1075 && strcmp (asect->name + strlen (asect->name) - 3, "str") == 0)
1076 this_hdr->sh_type = SHT_STRTAB;
1077 else if ((asect->flags & SEC_ALLOC) != 0
1078 && (asect->flags & SEC_LOAD) != 0)
1079 this_hdr->sh_type = SHT_PROGBITS;
1080 else if ((asect->flags & SEC_ALLOC) != 0
1081 && ((asect->flags & SEC_LOAD) == 0))
1082 this_hdr->sh_type = SHT_NOBITS;
1086 this_hdr->sh_type = SHT_PROGBITS;
1089 if ((asect->flags & SEC_ALLOC) != 0)
1090 this_hdr->sh_flags |= SHF_ALLOC;
1091 if ((asect->flags & SEC_READONLY) == 0)
1092 this_hdr->sh_flags |= SHF_WRITE;
1093 if ((asect->flags & SEC_CODE) != 0)
1094 this_hdr->sh_flags |= SHF_EXECINSTR;
1096 /* Check for processor-specific section types. */
1098 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1100 if (bed->elf_backend_fake_sections)
1101 (*bed->elf_backend_fake_sections) (abfd, this_hdr, asect);
1104 /* If the section has relocs, set up a section header for the
1105 SHT_REL[A] section. */
1106 if ((asect->flags & SEC_RELOC) != 0)
1108 Elf_Internal_Shdr *rela_hdr;
1109 int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
1112 rela_hdr = &elf_section_data (asect)->rel_hdr;
1113 name = bfd_alloc (abfd, sizeof ".rela" + strlen (asect->name));
1119 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
1121 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd), name,
1123 if (rela_hdr->sh_name == (unsigned int) -1)
1128 rela_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
1129 rela_hdr->sh_entsize = (use_rela_p
1130 ? bed->s->sizeof_rela
1131 : bed->s->sizeof_rel);
1132 rela_hdr->sh_addralign = bed->s->file_align;
1133 rela_hdr->sh_flags = 0;
1134 rela_hdr->sh_addr = 0;
1135 rela_hdr->sh_size = 0;
1136 rela_hdr->sh_offset = 0;
1140 /* Assign all ELF section numbers. The dummy first section is handled here
1141 too. The link/info pointers for the standard section types are filled
1142 in here too, while we're at it. */
1145 assign_section_numbers (abfd)
1148 struct elf_obj_tdata *t = elf_tdata (abfd);
1150 unsigned int section_number;
1151 Elf_Internal_Shdr **i_shdrp;
1152 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1156 for (sec = abfd->sections; sec; sec = sec->next)
1158 struct bfd_elf_section_data *d = elf_section_data (sec);
1160 d->this_idx = section_number++;
1161 if ((sec->flags & SEC_RELOC) == 0)
1164 d->rel_idx = section_number++;
1167 t->shstrtab_section = section_number++;
1168 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
1169 t->shstrtab_hdr.sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1171 if (abfd->symcount > 0)
1173 t->symtab_section = section_number++;
1174 t->strtab_section = section_number++;
1177 elf_elfheader (abfd)->e_shnum = section_number;
1179 /* Set up the list of section header pointers, in agreement with the
1181 i_shdrp = ((Elf_Internal_Shdr **)
1182 bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *)));
1183 if (i_shdrp == NULL)
1186 i_shdrp[0] = ((Elf_Internal_Shdr *)
1187 bfd_alloc (abfd, sizeof (Elf_Internal_Shdr)));
1188 if (i_shdrp[0] == NULL)
1190 bfd_release (abfd, i_shdrp);
1193 memset (i_shdrp[0], 0, sizeof (Elf_Internal_Shdr));
1195 elf_elfsections (abfd) = i_shdrp;
1197 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
1198 if (abfd->symcount > 0)
1200 i_shdrp[t->symtab_section] = &t->symtab_hdr;
1201 i_shdrp[t->strtab_section] = &t->strtab_hdr;
1202 t->symtab_hdr.sh_link = t->strtab_section;
1204 for (sec = abfd->sections; sec; sec = sec->next)
1206 struct bfd_elf_section_data *d = elf_section_data (sec);
1210 i_shdrp[d->this_idx] = &d->this_hdr;
1211 if (d->rel_idx != 0)
1212 i_shdrp[d->rel_idx] = &d->rel_hdr;
1214 /* Fill in the sh_link and sh_info fields while we're at it. */
1216 /* sh_link of a reloc section is the section index of the symbol
1217 table. sh_info is the section index of the section to which
1218 the relocation entries apply. */
1219 if (d->rel_idx != 0)
1221 d->rel_hdr.sh_link = t->symtab_section;
1222 d->rel_hdr.sh_info = d->this_idx;
1225 switch (d->this_hdr.sh_type)
1229 /* A reloc section which we are treating as a normal BFD
1230 section. sh_link is the section index of the symbol
1231 table. sh_info is the section index of the section to
1232 which the relocation entries apply. We assume that an
1233 allocated reloc section uses the dynamic symbol table.
1234 FIXME: How can we be sure? */
1235 s = bfd_get_section_by_name (abfd, ".dynsym");
1237 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1239 /* We look up the section the relocs apply to by name. */
1241 if (d->this_hdr.sh_type == SHT_REL)
1245 s = bfd_get_section_by_name (abfd, name);
1247 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
1251 /* We assume that a section named .stab*str is a stabs
1252 string section. We look for a section with the same name
1253 but without the trailing ``str'', and set its sh_link
1254 field to point to this section. */
1255 if (strncmp (sec->name, ".stab", sizeof ".stab" - 1) == 0
1256 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
1261 len = strlen (sec->name);
1262 alc = (char *) bfd_malloc (len - 2);
1265 strncpy (alc, sec->name, len - 3);
1266 alc[len - 3] = '\0';
1267 s = bfd_get_section_by_name (abfd, alc);
1271 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
1273 /* This is a .stab section. */
1274 elf_section_data (s)->this_hdr.sh_entsize =
1275 4 + 2 * (bed->s->arch_size / 8);
1282 /* sh_link is the section header index of the string table
1283 used for the dynamic entries or symbol table. */
1284 s = bfd_get_section_by_name (abfd, ".dynstr");
1286 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1290 /* sh_link is the section header index of the symbol table
1291 this hash table is for. */
1292 s = bfd_get_section_by_name (abfd, ".dynsym");
1294 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
1302 /* Map symbol from it's internal number to the external number, moving
1303 all local symbols to be at the head of the list. */
1306 sym_is_global (abfd, sym)
1310 /* If the backend has a special mapping, use it. */
1311 if (get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1312 return ((*get_elf_backend_data (abfd)->elf_backend_sym_is_global)
1315 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1316 || bfd_is_und_section (bfd_get_section (sym))
1317 || bfd_is_com_section (bfd_get_section (sym)));
1321 elf_map_symbols (abfd)
1324 int symcount = bfd_get_symcount (abfd);
1325 asymbol **syms = bfd_get_outsymbols (abfd);
1326 asymbol **sect_syms;
1328 int num_globals = 0;
1329 int num_locals2 = 0;
1330 int num_globals2 = 0;
1332 int num_sections = 0;
1338 fprintf (stderr, "elf_map_symbols\n");
1342 /* Add a section symbol for each BFD section. FIXME: Is this really
1344 for (asect = abfd->sections; asect; asect = asect->next)
1346 if (max_index < asect->index)
1347 max_index = asect->index;
1351 sect_syms = (asymbol **) bfd_zalloc (abfd, max_index * sizeof (asymbol *));
1352 if (sect_syms == NULL)
1354 elf_section_syms (abfd) = sect_syms;
1356 for (idx = 0; idx < symcount; idx++)
1358 if ((syms[idx]->flags & BSF_SECTION_SYM) != 0
1359 && (syms[idx]->value + syms[idx]->section->vma) == 0)
1363 sec = syms[idx]->section;
1364 if (sec->owner != NULL)
1366 if (sec->owner != abfd)
1368 if (sec->output_offset != 0)
1370 sec = sec->output_section;
1371 BFD_ASSERT (sec->owner == abfd);
1373 sect_syms[sec->index] = syms[idx];
1378 for (asect = abfd->sections; asect; asect = asect->next)
1382 if (sect_syms[asect->index] != NULL)
1385 sym = bfd_make_empty_symbol (abfd);
1388 sym->the_bfd = abfd;
1389 sym->name = asect->name;
1391 /* Set the flags to 0 to indicate that this one was newly added. */
1393 sym->section = asect;
1394 sect_syms[asect->index] = sym;
1398 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1399 asect->name, (long) asect->vma, asect->index, (long) asect);
1403 /* Classify all of the symbols. */
1404 for (idx = 0; idx < symcount; idx++)
1406 if (!sym_is_global (abfd, syms[idx]))
1411 for (asect = abfd->sections; asect; asect = asect->next)
1413 if (sect_syms[asect->index] != NULL
1414 && sect_syms[asect->index]->flags == 0)
1416 sect_syms[asect->index]->flags = BSF_SECTION_SYM;
1417 if (!sym_is_global (abfd, sect_syms[asect->index]))
1421 sect_syms[asect->index]->flags = 0;
1425 /* Now sort the symbols so the local symbols are first. */
1426 new_syms = ((asymbol **)
1428 (num_locals + num_globals) * sizeof (asymbol *)));
1429 if (new_syms == NULL)
1432 for (idx = 0; idx < symcount; idx++)
1434 asymbol *sym = syms[idx];
1437 if (!sym_is_global (abfd, sym))
1440 i = num_locals + num_globals2++;
1442 sym->udata.i = i + 1;
1444 for (asect = abfd->sections; asect; asect = asect->next)
1446 if (sect_syms[asect->index] != NULL
1447 && sect_syms[asect->index]->flags == 0)
1449 asymbol *sym = sect_syms[asect->index];
1452 sym->flags = BSF_SECTION_SYM;
1453 if (!sym_is_global (abfd, sym))
1456 i = num_locals + num_globals2++;
1458 sym->udata.i = i + 1;
1462 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
1464 elf_num_locals (abfd) = num_locals;
1465 elf_num_globals (abfd) = num_globals;
1469 /* Align to the maximum file alignment that could be required for any
1470 ELF data structure. */
1472 static INLINE file_ptr align_file_position PARAMS ((file_ptr, int));
1473 static INLINE file_ptr
1474 align_file_position (off, align)
1478 return (off + align - 1) & ~(align - 1);
1481 /* Assign a file position to a section, optionally aligning to the
1482 required section alignment. */
1485 _bfd_elf_assign_file_position_for_section (i_shdrp, offset, align)
1486 Elf_Internal_Shdr *i_shdrp;
1494 al = i_shdrp->sh_addralign;
1496 offset = BFD_ALIGN (offset, al);
1498 i_shdrp->sh_offset = offset;
1499 if (i_shdrp->bfd_section != NULL)
1500 i_shdrp->bfd_section->filepos = offset;
1501 if (i_shdrp->sh_type != SHT_NOBITS)
1502 offset += i_shdrp->sh_size;
1506 /* Compute the file positions we are going to put the sections at, and
1507 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1508 is not NULL, this is being called by the ELF backend linker. */
1511 _bfd_elf_compute_section_file_positions (abfd, link_info)
1513 struct bfd_link_info *link_info;
1515 struct elf_backend_data *bed = get_elf_backend_data (abfd);
1517 struct bfd_strtab_hash *strtab;
1518 Elf_Internal_Shdr *shstrtab_hdr;
1520 if (abfd->output_has_begun)
1523 /* Do any elf backend specific processing first. */
1524 if (bed->elf_backend_begin_write_processing)
1525 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
1527 if (! prep_headers (abfd))
1531 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
1535 if (!assign_section_numbers (abfd))
1538 /* The backend linker builds symbol table information itself. */
1539 if (link_info == NULL && abfd->symcount > 0)
1541 if (! swap_out_syms (abfd, &strtab))
1545 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
1546 /* sh_name was set in prep_headers. */
1547 shstrtab_hdr->sh_type = SHT_STRTAB;
1548 shstrtab_hdr->sh_flags = 0;
1549 shstrtab_hdr->sh_addr = 0;
1550 shstrtab_hdr->sh_size = _bfd_stringtab_size (elf_shstrtab (abfd));
1551 shstrtab_hdr->sh_entsize = 0;
1552 shstrtab_hdr->sh_link = 0;
1553 shstrtab_hdr->sh_info = 0;
1554 /* sh_offset is set in assign_file_positions_except_relocs. */
1555 shstrtab_hdr->sh_addralign = 1;
1557 if (!assign_file_positions_except_relocs (abfd))
1560 if (link_info == NULL && abfd->symcount > 0)
1563 Elf_Internal_Shdr *hdr;
1565 off = elf_tdata (abfd)->next_file_pos;
1567 hdr = &elf_tdata (abfd)->symtab_hdr;
1568 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
1570 hdr = &elf_tdata (abfd)->strtab_hdr;
1571 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
1573 elf_tdata (abfd)->next_file_pos = off;
1575 /* Now that we know where the .strtab section goes, write it
1577 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
1578 || ! _bfd_stringtab_emit (abfd, strtab))
1580 _bfd_stringtab_free (strtab);
1583 abfd->output_has_begun = true;
1588 /* Create a mapping from a set of sections to a program segment. */
1590 static INLINE struct elf_segment_map *
1591 make_mapping (abfd, sections, from, to)
1593 asection **sections;
1597 struct elf_segment_map *m;
1601 m = ((struct elf_segment_map *)
1603 (sizeof (struct elf_segment_map)
1604 + (to - from - 1) * sizeof (asection *))));
1608 m->p_type = PT_LOAD;
1609 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
1610 m->sections[i - from] = *hdrpp;
1611 m->count = to - from;
1615 /* Include the headers in the first PT_LOAD segment. */
1616 m->includes_filehdr = 1;
1617 m->includes_phdrs = 1;
1623 /* Set up a mapping from BFD sections to program segments. */
1626 map_sections_to_segments (abfd)
1629 asection **sections = NULL;
1633 struct elf_segment_map *mfirst;
1634 struct elf_segment_map **pm;
1635 struct elf_segment_map *m;
1637 unsigned int phdr_index;
1638 bfd_vma maxpagesize;
1641 if (elf_tdata (abfd)->segment_map != NULL)
1644 if (bfd_count_sections (abfd) == 0)
1647 /* Select the allocated sections, and sort them. */
1649 sections = (asection **) bfd_malloc (bfd_count_sections (abfd)
1650 * sizeof (asection *));
1651 if (sections == NULL)
1655 for (s = abfd->sections; s != NULL; s = s->next)
1657 if ((s->flags & SEC_ALLOC) != 0)
1663 BFD_ASSERT (i <= bfd_count_sections (abfd));
1666 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
1668 /* Build the mapping. */
1673 /* If we have a .interp section, then create a PT_PHDR segment for
1674 the program headers and a PT_INTERP segment for the .interp
1676 s = bfd_get_section_by_name (abfd, ".interp");
1677 if (s != NULL && (s->flags & SEC_LOAD) != 0)
1679 m = ((struct elf_segment_map *)
1680 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
1684 m->p_type = PT_PHDR;
1685 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1686 m->p_flags = PF_R | PF_X;
1687 m->p_flags_valid = 1;
1688 m->includes_phdrs = 1;
1693 m = ((struct elf_segment_map *)
1694 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
1698 m->p_type = PT_INTERP;
1706 /* Look through the sections. We put sections in the same program
1707 segment when the start of the second section can be placed within
1708 a few bytes of the end of the first section. */
1711 maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
1712 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
1718 /* See if this section and the last one will fit in the same
1720 if (last_hdr == NULL
1721 || ((BFD_ALIGN (last_hdr->lma + last_hdr->_raw_size, maxpagesize)
1723 && ((last_hdr->flags & SEC_LOAD) != 0
1724 || (hdr->flags & SEC_LOAD) == 0)))
1730 /* This section won't fit in the program segment. We must
1731 create a new program header holding all the sections from
1732 phdr_index until hdr. */
1734 m = make_mapping (abfd, sections, phdr_index, i);
1745 /* Create a final PT_LOAD program segment. */
1746 if (last_hdr != NULL)
1748 m = make_mapping (abfd, sections, phdr_index, i);
1756 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1757 s = bfd_get_section_by_name (abfd, ".dynamic");
1758 if (s != NULL && (s->flags & SEC_LOAD) != 0)
1760 m = ((struct elf_segment_map *)
1761 bfd_zalloc (abfd, sizeof (struct elf_segment_map)));
1765 m->p_type = PT_DYNAMIC;
1776 elf_tdata (abfd)->segment_map = mfirst;
1780 if (sections != NULL)
1785 /* Sort sections by VMA. */
1788 elf_sort_sections (arg1, arg2)
1792 const asection *sec1 = *(const asection **) arg1;
1793 const asection *sec2 = *(const asection **) arg2;
1795 if (sec1->vma < sec2->vma)
1797 else if (sec1->vma > sec2->vma)
1800 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1802 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1806 return sec1->target_index - sec2->target_index;
1815 /* Sort by size, to put zero sized sections before others at the
1818 if (sec1->_raw_size < sec2->_raw_size)
1820 if (sec1->_raw_size > sec2->_raw_size)
1823 return sec1->target_index - sec2->target_index;
1826 /* Assign file positions to the sections based on the mapping from
1827 sections to segments. This function also sets up some fields in
1828 the file header, and writes out the program headers. */
1831 assign_file_positions_for_segments (abfd)
1834 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1836 struct elf_segment_map *m;
1838 Elf_Internal_Phdr *phdrs;
1840 bfd_vma filehdr_vaddr, filehdr_paddr;
1841 bfd_vma phdrs_vaddr, phdrs_paddr;
1842 Elf_Internal_Phdr *p;
1844 if (elf_tdata (abfd)->segment_map == NULL)
1846 if (! map_sections_to_segments (abfd))
1850 if (bed->elf_backend_modify_segment_map)
1852 if (! (*bed->elf_backend_modify_segment_map) (abfd))
1857 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1860 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
1861 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
1862 elf_elfheader (abfd)->e_phnum = count;
1867 /* If we already counted the number of program segments, make sure
1868 that we allocated enough space. This happens when SIZEOF_HEADERS
1869 is used in a linker script. */
1870 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
1871 if (alloc != 0 && count > alloc)
1873 ((*_bfd_error_handler)
1874 ("%s: Not enough room for program headers (allocated %u, need %u)",
1875 bfd_get_filename (abfd), alloc, count));
1876 bfd_set_error (bfd_error_bad_value);
1883 phdrs = ((Elf_Internal_Phdr *)
1884 bfd_alloc (abfd, alloc * sizeof (Elf_Internal_Phdr)));
1888 off = bed->s->sizeof_ehdr;
1889 off += alloc * bed->s->sizeof_phdr;
1895 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
1902 /* If elf_segment_map is not from map_sections_to_segments, the
1903 sections may not be correctly ordered. */
1905 qsort (m->sections, (size_t) m->count, sizeof (asection *),
1908 p->p_type = m->p_type;
1910 if (m->p_flags_valid)
1911 p->p_flags = m->p_flags;
1915 if (p->p_type == PT_LOAD
1917 && (m->sections[0]->flags & SEC_LOAD) != 0)
1918 off += (m->sections[0]->vma - off) % bed->maxpagesize;
1923 p->p_vaddr = m->sections[0]->vma;
1925 if (m->p_paddr_valid)
1926 p->p_paddr = m->p_paddr;
1927 else if (m->count == 0)
1930 p->p_paddr = m->sections[0]->lma;
1932 if (p->p_type == PT_LOAD)
1933 p->p_align = bed->maxpagesize;
1934 else if (m->count == 0)
1935 p->p_align = bed->s->file_align;
1943 if (m->includes_filehdr)
1945 if (! m->p_flags_valid)
1948 p->p_filesz = bed->s->sizeof_ehdr;
1949 p->p_memsz = bed->s->sizeof_ehdr;
1952 BFD_ASSERT (p->p_type == PT_LOAD);
1954 if (! m->p_paddr_valid)
1957 if (p->p_type == PT_LOAD)
1959 filehdr_vaddr = p->p_vaddr;
1960 filehdr_paddr = p->p_paddr;
1964 if (m->includes_phdrs)
1966 if (! m->p_flags_valid)
1968 if (m->includes_filehdr)
1970 if (p->p_type == PT_LOAD)
1972 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
1973 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
1978 p->p_offset = bed->s->sizeof_ehdr;
1981 BFD_ASSERT (p->p_type == PT_LOAD);
1982 p->p_vaddr -= off - p->p_offset;
1983 if (! m->p_paddr_valid)
1984 p->p_paddr -= off - p->p_offset;
1986 if (p->p_type == PT_LOAD)
1988 phdrs_vaddr = p->p_vaddr;
1989 phdrs_paddr = p->p_paddr;
1992 p->p_filesz += alloc * bed->s->sizeof_phdr;
1993 p->p_memsz += alloc * bed->s->sizeof_phdr;
1996 if (p->p_type == PT_LOAD)
1998 if (! m->includes_filehdr && ! m->includes_phdrs)
2004 adjust = off - (p->p_offset + p->p_filesz);
2005 p->p_filesz += adjust;
2006 p->p_memsz += adjust;
2010 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
2014 bfd_size_type align;
2019 if (p->p_type == PT_LOAD)
2023 /* The section VMA must equal the file position modulo
2025 if ((flags & SEC_LOAD) != 0)
2027 adjust = (sec->vma - off) % bed->maxpagesize;
2032 p->p_memsz += adjust;
2033 if ((flags & SEC_LOAD) != 0)
2034 p->p_filesz += adjust;
2041 if ((flags & SEC_LOAD) != 0)
2042 off += sec->_raw_size;
2045 p->p_memsz += sec->_raw_size;
2047 if ((flags & SEC_LOAD) != 0)
2048 p->p_filesz += sec->_raw_size;
2050 align = 1 << bfd_get_section_alignment (abfd, sec);
2051 if (align > p->p_align)
2054 if (! m->p_flags_valid)
2057 if ((flags & SEC_CODE) != 0)
2059 if ((flags & SEC_READONLY) == 0)
2065 /* Now that we have set the section file positions, we can set up
2066 the file positions for the non PT_LOAD segments. */
2067 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
2071 if (p->p_type != PT_LOAD && m->count > 0)
2073 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
2074 p->p_offset = m->sections[0]->filepos;
2078 if (m->includes_filehdr)
2080 p->p_vaddr = filehdr_vaddr;
2081 if (! m->p_paddr_valid)
2082 p->p_paddr = filehdr_paddr;
2084 else if (m->includes_phdrs)
2086 p->p_vaddr = phdrs_vaddr;
2087 if (! m->p_paddr_valid)
2088 p->p_paddr = phdrs_paddr;
2093 /* Clear out any program headers we allocated but did not use. */
2094 for (; count < alloc; count++, p++)
2096 memset (p, 0, sizeof *p);
2097 p->p_type = PT_NULL;
2100 elf_tdata (abfd)->phdr = phdrs;
2102 elf_tdata (abfd)->next_file_pos = off;
2104 /* Write out the program headers. */
2105 if (bfd_seek (abfd, bed->s->sizeof_ehdr, SEEK_SET) != 0
2106 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
2112 /* Get the size of the program header.
2114 If this is called by the linker before any of the section VMA's are set, it
2115 can't calculate the correct value for a strange memory layout. This only
2116 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2117 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2118 data segment (exclusive of .interp and .dynamic).
2120 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2121 will be two segments. */
2123 static bfd_size_type
2124 get_program_header_size (abfd)
2129 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2131 /* We can't return a different result each time we're called. */
2132 if (elf_tdata (abfd)->program_header_size != 0)
2133 return elf_tdata (abfd)->program_header_size;
2135 if (elf_tdata (abfd)->segment_map != NULL)
2137 struct elf_segment_map *m;
2140 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2142 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2143 return elf_tdata (abfd)->program_header_size;
2146 /* Assume we will need exactly two PT_LOAD segments: one for text
2147 and one for data. */
2150 s = bfd_get_section_by_name (abfd, ".interp");
2151 if (s != NULL && (s->flags & SEC_LOAD) != 0)
2153 /* If we have a loadable interpreter section, we need a
2154 PT_INTERP segment. In this case, assume we also need a
2155 PT_PHDR segment, although that may not be true for all
2160 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
2162 /* We need a PT_DYNAMIC segment. */
2166 /* Let the backend count up any program headers it might need. */
2167 if (bed->elf_backend_additional_program_headers)
2171 a = (*bed->elf_backend_additional_program_headers) (abfd);
2177 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
2178 return elf_tdata (abfd)->program_header_size;
2181 /* Work out the file positions of all the sections. This is called by
2182 _bfd_elf_compute_section_file_positions. All the section sizes and
2183 VMAs must be known before this is called.
2185 We do not consider reloc sections at this point, unless they form
2186 part of the loadable image. Reloc sections are assigned file
2187 positions in assign_file_positions_for_relocs, which is called by
2188 write_object_contents and final_link.
2190 We also don't set the positions of the .symtab and .strtab here. */
2193 assign_file_positions_except_relocs (abfd)
2196 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
2197 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
2198 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
2200 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2202 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
2204 Elf_Internal_Shdr **hdrpp;
2207 /* Start after the ELF header. */
2208 off = i_ehdrp->e_ehsize;
2210 /* We are not creating an executable, which means that we are
2211 not creating a program header, and that the actual order of
2212 the sections in the file is unimportant. */
2213 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
2215 Elf_Internal_Shdr *hdr;
2218 if (hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
2220 hdr->sh_offset = -1;
2223 if (i == tdata->symtab_section
2224 || i == tdata->strtab_section)
2226 hdr->sh_offset = -1;
2230 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2236 Elf_Internal_Shdr **hdrpp;
2238 /* Assign file positions for the loaded sections based on the
2239 assignment of sections to segments. */
2240 if (! assign_file_positions_for_segments (abfd))
2243 /* Assign file positions for the other sections. */
2245 off = elf_tdata (abfd)->next_file_pos;
2246 for (i = 1, hdrpp = i_shdrpp + 1; i < i_ehdrp->e_shnum; i++, hdrpp++)
2248 Elf_Internal_Shdr *hdr;
2251 if (hdr->bfd_section != NULL
2252 && hdr->bfd_section->filepos != 0)
2253 hdr->sh_offset = hdr->bfd_section->filepos;
2254 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
2256 ((*_bfd_error_handler)
2257 ("%s: warning: allocated section `%s' not in segment",
2258 bfd_get_filename (abfd),
2259 (hdr->bfd_section == NULL
2261 : hdr->bfd_section->name)));
2262 off += (hdr->sh_addr - off) % bed->maxpagesize;
2263 off = _bfd_elf_assign_file_position_for_section (hdr, off,
2266 else if (hdr->sh_type == SHT_REL
2267 || hdr->sh_type == SHT_RELA
2268 || hdr == i_shdrpp[tdata->symtab_section]
2269 || hdr == i_shdrpp[tdata->strtab_section])
2270 hdr->sh_offset = -1;
2272 off = _bfd_elf_assign_file_position_for_section (hdr, off, true);
2276 /* Place the section headers. */
2277 off = align_file_position (off, bed->s->file_align);
2278 i_ehdrp->e_shoff = off;
2279 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
2281 elf_tdata (abfd)->next_file_pos = off;
2290 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
2291 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
2292 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
2294 struct bfd_strtab_hash *shstrtab;
2295 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2297 i_ehdrp = elf_elfheader (abfd);
2298 i_shdrp = elf_elfsections (abfd);
2300 shstrtab = _bfd_elf_stringtab_init ();
2301 if (shstrtab == NULL)
2304 elf_shstrtab (abfd) = shstrtab;
2306 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
2307 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
2308 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
2309 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
2311 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
2312 i_ehdrp->e_ident[EI_DATA] =
2313 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
2314 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
2316 for (count = EI_PAD; count < EI_NIDENT; count++)
2317 i_ehdrp->e_ident[count] = 0;
2319 if ((abfd->flags & DYNAMIC) != 0)
2320 i_ehdrp->e_type = ET_DYN;
2321 else if ((abfd->flags & EXEC_P) != 0)
2322 i_ehdrp->e_type = ET_EXEC;
2324 i_ehdrp->e_type = ET_REL;
2326 switch (bfd_get_arch (abfd))
2328 case bfd_arch_unknown:
2329 i_ehdrp->e_machine = EM_NONE;
2331 case bfd_arch_sparc:
2332 if (bed->s->arch_size == 64)
2333 i_ehdrp->e_machine = EM_SPARC64;
2335 i_ehdrp->e_machine = EM_SPARC;
2338 i_ehdrp->e_machine = EM_386;
2341 i_ehdrp->e_machine = EM_68K;
2344 i_ehdrp->e_machine = EM_88K;
2347 i_ehdrp->e_machine = EM_860;
2349 case bfd_arch_mips: /* MIPS Rxxxx */
2350 i_ehdrp->e_machine = EM_MIPS; /* only MIPS R3000 */
2353 i_ehdrp->e_machine = EM_PARISC;
2355 case bfd_arch_powerpc:
2356 i_ehdrp->e_machine = EM_PPC;
2358 /* start-sanitize-arc */
2360 i_ehdrp->e_machine = EM_CYGNUS_ARC;
2362 /* end-sanitize-arc */
2363 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2365 i_ehdrp->e_machine = EM_NONE;
2367 i_ehdrp->e_version = bed->s->ev_current;
2368 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
2370 /* no program header, for now. */
2371 i_ehdrp->e_phoff = 0;
2372 i_ehdrp->e_phentsize = 0;
2373 i_ehdrp->e_phnum = 0;
2375 /* each bfd section is section header entry */
2376 i_ehdrp->e_entry = bfd_get_start_address (abfd);
2377 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
2379 /* if we're building an executable, we'll need a program header table */
2380 if (abfd->flags & EXEC_P)
2382 /* it all happens later */
2384 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
2386 /* elf_build_phdrs() returns a (NULL-terminated) array of
2387 Elf_Internal_Phdrs */
2388 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
2389 i_ehdrp->e_phoff = outbase;
2390 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
2395 i_ehdrp->e_phentsize = 0;
2397 i_ehdrp->e_phoff = 0;
2400 elf_tdata (abfd)->symtab_hdr.sh_name =
2401 (unsigned int) _bfd_stringtab_add (shstrtab, ".symtab", true, false);
2402 elf_tdata (abfd)->strtab_hdr.sh_name =
2403 (unsigned int) _bfd_stringtab_add (shstrtab, ".strtab", true, false);
2404 elf_tdata (abfd)->shstrtab_hdr.sh_name =
2405 (unsigned int) _bfd_stringtab_add (shstrtab, ".shstrtab", true, false);
2406 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
2407 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
2408 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
2414 /* Assign file positions for all the reloc sections which are not part
2415 of the loadable file image. */
2418 _bfd_elf_assign_file_positions_for_relocs (abfd)
2423 Elf_Internal_Shdr **shdrpp;
2425 off = elf_tdata (abfd)->next_file_pos;
2427 for (i = 1, shdrpp = elf_elfsections (abfd) + 1;
2428 i < elf_elfheader (abfd)->e_shnum;
2431 Elf_Internal_Shdr *shdrp;
2434 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
2435 && shdrp->sh_offset == -1)
2436 off = _bfd_elf_assign_file_position_for_section (shdrp, off, true);
2439 elf_tdata (abfd)->next_file_pos = off;
2443 _bfd_elf_write_object_contents (abfd)
2446 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2447 Elf_Internal_Ehdr *i_ehdrp;
2448 Elf_Internal_Shdr **i_shdrp;
2452 if (! abfd->output_has_begun
2453 && ! _bfd_elf_compute_section_file_positions (abfd,
2454 (struct bfd_link_info *) NULL))
2457 i_shdrp = elf_elfsections (abfd);
2458 i_ehdrp = elf_elfheader (abfd);
2461 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
2464 _bfd_elf_assign_file_positions_for_relocs (abfd);
2466 /* After writing the headers, we need to write the sections too... */
2467 for (count = 1; count < i_ehdrp->e_shnum; count++)
2469 if (bed->elf_backend_section_processing)
2470 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
2471 if (i_shdrp[count]->contents)
2473 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
2474 || (bfd_write (i_shdrp[count]->contents, i_shdrp[count]->sh_size,
2476 != i_shdrp[count]->sh_size))
2481 /* Write out the section header names. */
2482 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
2483 || ! _bfd_stringtab_emit (abfd, elf_shstrtab (abfd)))
2486 if (bed->elf_backend_final_write_processing)
2487 (*bed->elf_backend_final_write_processing) (abfd,
2488 elf_tdata (abfd)->linker);
2490 return bed->s->write_shdrs_and_ehdr (abfd);
2493 /* given a section, search the header to find them... */
2495 _bfd_elf_section_from_bfd_section (abfd, asect)
2499 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2500 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
2502 Elf_Internal_Shdr *hdr;
2503 int maxindex = elf_elfheader (abfd)->e_shnum;
2505 for (index = 0; index < maxindex; index++)
2507 hdr = i_shdrp[index];
2508 if (hdr->bfd_section == asect)
2512 if (bed->elf_backend_section_from_bfd_section)
2514 for (index = 0; index < maxindex; index++)
2518 hdr = i_shdrp[index];
2520 if ((*bed->elf_backend_section_from_bfd_section)
2521 (abfd, hdr, asect, &retval))
2526 if (bfd_is_abs_section (asect))
2528 if (bfd_is_com_section (asect))
2530 if (bfd_is_und_section (asect))
2536 /* given a symbol, return the bfd index for that symbol. */
2538 _bfd_elf_symbol_from_bfd_symbol (abfd, asym_ptr_ptr)
2540 struct symbol_cache_entry **asym_ptr_ptr;
2542 struct symbol_cache_entry *asym_ptr = *asym_ptr_ptr;
2544 flagword flags = asym_ptr->flags;
2546 /* When gas creates relocations against local labels, it creates its
2547 own symbol for the section, but does put the symbol into the
2548 symbol chain, so udata is 0. When the linker is generating
2549 relocatable output, this section symbol may be for one of the
2550 input sections rather than the output section. */
2551 if (asym_ptr->udata.i == 0
2552 && (flags & BSF_SECTION_SYM)
2553 && asym_ptr->section)
2557 if (asym_ptr->section->output_section != NULL)
2558 indx = asym_ptr->section->output_section->index;
2560 indx = asym_ptr->section->index;
2561 if (elf_section_syms (abfd)[indx])
2562 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
2565 idx = asym_ptr->udata.i;
2566 BFD_ASSERT (idx != 0);
2571 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2572 (long) asym_ptr, asym_ptr->name, idx, flags, elf_symbol_flags (flags));
2580 /* Copy private BFD data. This copies any program header information. */
2583 copy_private_bfd_data (ibfd, obfd)
2587 Elf_Internal_Ehdr *iehdr;
2588 struct elf_segment_map *mfirst;
2589 struct elf_segment_map **pm;
2590 Elf_Internal_Phdr *p;
2593 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2594 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2597 if (elf_tdata (ibfd)->phdr == NULL)
2600 iehdr = elf_elfheader (ibfd);
2605 c = elf_elfheader (ibfd)->e_phnum;
2606 for (i = 0, p = elf_tdata (ibfd)->phdr; i < c; i++, p++)
2610 struct elf_segment_map *m;
2615 /* The complicated case when p_vaddr is 0 is to handle the
2616 Solaris linker, which generates a PT_INTERP section with
2617 p_vaddr and p_memsz set to 0. */
2618 for (s = ibfd->sections; s != NULL; s = s->next)
2619 if (((s->vma >= p->p_vaddr
2620 && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz
2621 || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz))
2624 && (s->flags & SEC_HAS_CONTENTS) != 0
2625 && (bfd_vma) s->filepos >= p->p_offset
2626 && ((bfd_vma) s->filepos + s->_raw_size
2627 <= p->p_offset + p->p_filesz)))
2628 && (s->flags & SEC_ALLOC) != 0
2629 && s->output_section != NULL)
2632 m = ((struct elf_segment_map *)
2634 (sizeof (struct elf_segment_map)
2635 + (csecs - 1) * sizeof (asection *))));
2640 m->p_type = p->p_type;
2641 m->p_flags = p->p_flags;
2642 m->p_flags_valid = 1;
2643 m->p_paddr = p->p_paddr;
2644 m->p_paddr_valid = 1;
2646 m->includes_filehdr = (p->p_offset == 0
2647 && p->p_filesz >= iehdr->e_ehsize);
2649 m->includes_phdrs = (p->p_offset <= (bfd_vma) iehdr->e_phoff
2650 && (p->p_offset + p->p_filesz
2651 >= ((bfd_vma) iehdr->e_phoff
2652 + iehdr->e_phnum * iehdr->e_phentsize)));
2655 for (s = ibfd->sections; s != NULL; s = s->next)
2657 if (((s->vma >= p->p_vaddr
2658 && (s->vma + s->_raw_size <= p->p_vaddr + p->p_memsz
2659 || s->vma + s->_raw_size <= p->p_vaddr + p->p_filesz))
2662 && (s->flags & SEC_HAS_CONTENTS) != 0
2663 && (bfd_vma) s->filepos >= p->p_offset
2664 && ((bfd_vma) s->filepos + s->_raw_size
2665 <= p->p_offset + p->p_filesz)))
2666 && (s->flags & SEC_ALLOC) != 0
2667 && s->output_section != NULL)
2669 m->sections[isec] = s->output_section;
2673 BFD_ASSERT (isec == csecs);
2680 elf_tdata (obfd)->segment_map = mfirst;
2685 /* Copy private section information. This copies over the entsize
2686 field, and sometimes the info field. */
2689 _bfd_elf_copy_private_section_data (ibfd, isec, obfd, osec)
2695 Elf_Internal_Shdr *ihdr, *ohdr;
2697 if (ibfd->xvec->flavour != bfd_target_elf_flavour
2698 || obfd->xvec->flavour != bfd_target_elf_flavour)
2701 /* Copy over private BFD data if it has not already been copied.
2702 This must be done here, rather than in the copy_private_bfd_data
2703 entry point, because the latter is called after the section
2704 contents have been set, which means that the program headers have
2705 already been worked out. */
2706 if (elf_tdata (obfd)->segment_map == NULL
2707 && elf_tdata (ibfd)->phdr != NULL)
2711 /* Only set up the segments when all the sections have been set
2713 for (s = ibfd->sections; s != NULL; s = s->next)
2714 if (s->output_section == NULL)
2718 if (! copy_private_bfd_data (ibfd, obfd))
2723 ihdr = &elf_section_data (isec)->this_hdr;
2724 ohdr = &elf_section_data (osec)->this_hdr;
2726 ohdr->sh_entsize = ihdr->sh_entsize;
2728 if (ihdr->sh_type == SHT_SYMTAB
2729 || ihdr->sh_type == SHT_DYNSYM)
2730 ohdr->sh_info = ihdr->sh_info;
2735 /* Copy private symbol information. If this symbol is in a section
2736 which we did not map into a BFD section, try to map the section
2737 index correctly. We use special macro definitions for the mapped
2738 section indices; these definitions are interpreted by the
2739 swap_out_syms function. */
2741 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2742 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2743 #define MAP_STRTAB (SHN_LORESERVE - 3)
2744 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2747 _bfd_elf_copy_private_symbol_data (ibfd, isymarg, obfd, osymarg)
2753 elf_symbol_type *isym, *osym;
2755 isym = elf_symbol_from (ibfd, isymarg);
2756 osym = elf_symbol_from (obfd, osymarg);
2760 && bfd_is_abs_section (isym->symbol.section))
2764 shndx = isym->internal_elf_sym.st_shndx;
2765 if (shndx == elf_onesymtab (ibfd))
2766 shndx = MAP_ONESYMTAB;
2767 else if (shndx == elf_dynsymtab (ibfd))
2768 shndx = MAP_DYNSYMTAB;
2769 else if (shndx == elf_tdata (ibfd)->strtab_section)
2771 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
2772 shndx = MAP_SHSTRTAB;
2773 osym->internal_elf_sym.st_shndx = shndx;
2779 /* Swap out the symbols. */
2782 swap_out_syms (abfd, sttp)
2784 struct bfd_strtab_hash **sttp;
2786 struct elf_backend_data *bed = get_elf_backend_data (abfd);
2788 if (!elf_map_symbols (abfd))
2791 /* Dump out the symtabs. */
2793 int symcount = bfd_get_symcount (abfd);
2794 asymbol **syms = bfd_get_outsymbols (abfd);
2795 struct bfd_strtab_hash *stt;
2796 Elf_Internal_Shdr *symtab_hdr;
2797 Elf_Internal_Shdr *symstrtab_hdr;
2798 char *outbound_syms;
2801 stt = _bfd_elf_stringtab_init ();
2805 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2806 symtab_hdr->sh_type = SHT_SYMTAB;
2807 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
2808 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
2809 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
2810 symtab_hdr->sh_addralign = bed->s->file_align;
2812 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
2813 symstrtab_hdr->sh_type = SHT_STRTAB;
2815 outbound_syms = bfd_alloc (abfd,
2816 (1 + symcount) * bed->s->sizeof_sym);
2817 if (outbound_syms == NULL)
2819 symtab_hdr->contents = (PTR) outbound_syms;
2821 /* now generate the data (for "contents") */
2823 /* Fill in zeroth symbol and swap it out. */
2824 Elf_Internal_Sym sym;
2830 sym.st_shndx = SHN_UNDEF;
2831 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
2832 outbound_syms += bed->s->sizeof_sym;
2834 for (idx = 0; idx < symcount; idx++)
2836 Elf_Internal_Sym sym;
2837 bfd_vma value = syms[idx]->value;
2838 elf_symbol_type *type_ptr;
2839 flagword flags = syms[idx]->flags;
2842 if (flags & BSF_SECTION_SYM)
2843 /* Section symbols have no names. */
2847 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
2850 if (sym.st_name == (unsigned long) -1)
2854 type_ptr = elf_symbol_from (abfd, syms[idx]);
2856 if (bfd_is_com_section (syms[idx]->section))
2858 /* ELF common symbols put the alignment into the `value' field,
2859 and the size into the `size' field. This is backwards from
2860 how BFD handles it, so reverse it here. */
2861 sym.st_size = value;
2862 if (type_ptr == NULL
2863 || type_ptr->internal_elf_sym.st_value == 0)
2864 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
2866 sym.st_value = type_ptr->internal_elf_sym.st_value;
2867 sym.st_shndx = _bfd_elf_section_from_bfd_section (abfd,
2868 syms[idx]->section);
2872 asection *sec = syms[idx]->section;
2875 if (sec->output_section)
2877 value += sec->output_offset;
2878 sec = sec->output_section;
2881 sym.st_value = value;
2882 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
2884 if (bfd_is_abs_section (sec)
2886 && type_ptr->internal_elf_sym.st_shndx != 0)
2888 /* This symbol is in a real ELF section which we did
2889 not create as a BFD section. Undo the mapping done
2890 by copy_private_symbol_data. */
2891 shndx = type_ptr->internal_elf_sym.st_shndx;
2895 shndx = elf_onesymtab (abfd);
2898 shndx = elf_dynsymtab (abfd);
2901 shndx = elf_tdata (abfd)->strtab_section;
2904 shndx = elf_tdata (abfd)->shstrtab_section;
2912 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2918 /* Writing this would be a hell of a lot easier if
2919 we had some decent documentation on bfd, and
2920 knew what to expect of the library, and what to
2921 demand of applications. For example, it
2922 appears that `objcopy' might not set the
2923 section of a symbol to be a section that is
2924 actually in the output file. */
2925 sec2 = bfd_get_section_by_name (abfd, sec->name);
2926 BFD_ASSERT (sec2 != 0);
2927 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
2928 BFD_ASSERT (shndx != -1);
2932 sym.st_shndx = shndx;
2935 if ((flags & BSF_FUNCTION) != 0)
2937 else if ((flags & BSF_OBJECT) != 0)
2942 if (bfd_is_com_section (syms[idx]->section))
2943 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
2944 else if (bfd_is_und_section (syms[idx]->section))
2945 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
2949 else if (flags & BSF_SECTION_SYM)
2950 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
2951 else if (flags & BSF_FILE)
2952 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
2955 int bind = STB_LOCAL;
2957 if (flags & BSF_LOCAL)
2959 else if (flags & BSF_WEAK)
2961 else if (flags & BSF_GLOBAL)
2964 sym.st_info = ELF_ST_INFO (bind, type);
2968 bed->s->swap_symbol_out (abfd, &sym, (PTR) outbound_syms);
2969 outbound_syms += bed->s->sizeof_sym;
2973 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
2974 symstrtab_hdr->sh_type = SHT_STRTAB;
2976 symstrtab_hdr->sh_flags = 0;
2977 symstrtab_hdr->sh_addr = 0;
2978 symstrtab_hdr->sh_entsize = 0;
2979 symstrtab_hdr->sh_link = 0;
2980 symstrtab_hdr->sh_info = 0;
2981 symstrtab_hdr->sh_addralign = 1;
2987 /* Return the number of bytes required to hold the symtab vector.
2989 Note that we base it on the count plus 1, since we will null terminate
2990 the vector allocated based on this size. However, the ELF symbol table
2991 always has a dummy entry as symbol #0, so it ends up even. */
2994 _bfd_elf_get_symtab_upper_bound (abfd)
2999 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
3001 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3002 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
3008 _bfd_elf_get_dynamic_symtab_upper_bound (abfd)
3013 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
3015 if (elf_dynsymtab (abfd) == 0)
3017 bfd_set_error (bfd_error_invalid_operation);
3021 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3022 symtab_size = (symcount - 1 + 1) * (sizeof (asymbol *));
3028 _bfd_elf_get_reloc_upper_bound (abfd, asect)
3032 return (asect->reloc_count + 1) * sizeof (arelent *);
3035 /* Canonicalize the relocs. */
3038 _bfd_elf_canonicalize_reloc (abfd, section, relptr, symbols)
3047 if (! get_elf_backend_data (abfd)->s->slurp_reloc_table (abfd, section, symbols))
3050 tblptr = section->relocation;
3051 for (i = 0; i < section->reloc_count; i++)
3052 *relptr++ = tblptr++;
3056 return section->reloc_count;
3060 _bfd_elf_get_symtab (abfd, alocation)
3062 asymbol **alocation;
3064 long symcount = get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, false);
3067 bfd_get_symcount (abfd) = symcount;
3072 _bfd_elf_canonicalize_dynamic_symtab (abfd, alocation)
3074 asymbol **alocation;
3076 return get_elf_backend_data (abfd)->s->slurp_symbol_table (abfd, alocation, true);
3080 _bfd_elf_make_empty_symbol (abfd)
3083 elf_symbol_type *newsym;
3085 newsym = (elf_symbol_type *) bfd_zalloc (abfd, sizeof (elf_symbol_type));
3090 newsym->symbol.the_bfd = abfd;
3091 return &newsym->symbol;
3096 _bfd_elf_get_symbol_info (ignore_abfd, symbol, ret)
3101 bfd_symbol_info (symbol, ret);
3105 _bfd_elf_get_lineno (ignore_abfd, symbol)
3114 _bfd_elf_set_arch_mach (abfd, arch, machine)
3116 enum bfd_architecture arch;
3117 unsigned long machine;
3119 /* If this isn't the right architecture for this backend, and this
3120 isn't the generic backend, fail. */
3121 if (arch != get_elf_backend_data (abfd)->arch
3122 && arch != bfd_arch_unknown
3123 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
3126 return bfd_default_set_arch_mach (abfd, arch, machine);
3129 /* Find the nearest line to a particular section and offset, for error
3133 _bfd_elf_find_nearest_line (abfd,
3144 CONST char **filename_ptr;
3145 CONST char **functionname_ptr;
3146 unsigned int *line_ptr;
3149 const char *filename;
3154 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
3155 &found, filename_ptr,
3156 functionname_ptr, line_ptr,
3157 &elf_tdata (abfd)->line_info))
3162 if (symbols == NULL)
3169 for (p = symbols; *p != NULL; p++)
3173 q = (elf_symbol_type *) *p;
3175 if (bfd_get_section (&q->symbol) != section)
3178 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
3183 filename = bfd_asymbol_name (&q->symbol);
3186 if (q->symbol.section == section
3187 && q->symbol.value >= low_func
3188 && q->symbol.value <= offset)
3190 func = (asymbol *) q;
3191 low_func = q->symbol.value;
3200 *filename_ptr = filename;
3201 *functionname_ptr = bfd_asymbol_name (func);
3207 _bfd_elf_sizeof_headers (abfd, reloc)
3213 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
3215 ret += get_program_header_size (abfd);
3220 _bfd_elf_set_section_contents (abfd, section, location, offset, count)
3225 bfd_size_type count;
3227 Elf_Internal_Shdr *hdr;
3229 if (! abfd->output_has_begun
3230 && ! _bfd_elf_compute_section_file_positions (abfd,
3231 (struct bfd_link_info *) NULL))
3234 hdr = &elf_section_data (section)->this_hdr;
3236 if (bfd_seek (abfd, hdr->sh_offset + offset, SEEK_SET) == -1)
3238 if (bfd_write (location, 1, count, abfd) != count)
3245 _bfd_elf_no_info_to_howto (abfd, cache_ptr, dst)
3248 Elf_Internal_Rela *dst;
3255 _bfd_elf_no_info_to_howto_rel (abfd, cache_ptr, dst)
3258 Elf_Internal_Rel *dst;