1 /* ELF executable support for BFD.
2 Copyright 1993 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
;
340 p
= elf_tdata (abfd
)->phdr
;
344 c
= elf_elfheader (abfd
)->e_phnum
;
345 for (i
= 0; i
< c
; i
++, p
++)
352 case PT_NULL
: s
= "NULL"; break;
353 case PT_LOAD
: s
= "LOAD"; break;
354 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
355 case PT_INTERP
: s
= "INTERP"; break;
356 case PT_NOTE
: s
= "NOTE"; break;
357 case PT_SHLIB
: s
= "SHLIB"; break;
358 case PT_PHDR
: s
= "PHDR"; break;
359 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
361 fprintf (f
, "%8s off 0x", s
);
362 fprintf_vma (f
, p
->p_offset
);
363 fprintf (f
, " vaddr 0x");
364 fprintf_vma (f
, p
->p_vaddr
);
365 fprintf (f
, " paddr 0x");
366 fprintf_vma (f
, p
->p_paddr
);
367 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
368 fprintf (f
, " filesz 0x");
369 fprintf_vma (f
, p
->p_filesz
);
370 fprintf (f
, " memsz 0x");
371 fprintf_vma (f
, p
->p_memsz
);
372 fprintf (f
, " flags %c%c%c",
373 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
374 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
375 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
376 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
377 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
384 /* Display ELF-specific fields of a symbol. */
386 bfd_elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
390 bfd_print_symbol_type how
;
392 FILE *file
= (FILE *) filep
;
395 case bfd_print_symbol_name
:
396 fprintf (file
, "%s", symbol
->name
);
398 case bfd_print_symbol_more
:
399 fprintf (file
, "elf ");
400 fprintf_vma (file
, symbol
->value
);
401 fprintf (file
, " %lx", (long) symbol
->flags
);
403 case bfd_print_symbol_all
:
405 CONST
char *section_name
;
406 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
407 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
408 fprintf (file
, " %s\t", section_name
);
409 /* Print the "other" value for a symbol. For common symbols,
410 we've already printed the size; now print the alignment.
411 For other symbols, we have no specified alignment, and
412 we've printed the address; now print the size. */
414 (bfd_is_com_section (symbol
->section
)
415 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
416 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
417 fprintf (file
, " %s", symbol
->name
);
423 /* Create an entry in an ELF linker hash table. */
425 struct bfd_hash_entry
*
426 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
427 struct bfd_hash_entry
*entry
;
428 struct bfd_hash_table
*table
;
431 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
433 /* Allocate the structure if it has not already been allocated by a
435 if (ret
== (struct elf_link_hash_entry
*) NULL
)
436 ret
= ((struct elf_link_hash_entry
*)
437 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
438 if (ret
== (struct elf_link_hash_entry
*) NULL
)
439 return (struct bfd_hash_entry
*) ret
;
441 /* Call the allocation method of the superclass. */
442 ret
= ((struct elf_link_hash_entry
*)
443 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
445 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
447 /* Set local fields. */
451 ret
->dynstr_index
= 0;
453 ret
->got_offset
= (bfd_vma
) -1;
454 ret
->plt_offset
= (bfd_vma
) -1;
455 ret
->type
= STT_NOTYPE
;
456 ret
->elf_link_hash_flags
= 0;
459 return (struct bfd_hash_entry
*) ret
;
462 /* Initialize an ELF linker hash table. */
465 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
466 struct elf_link_hash_table
*table
;
468 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
469 struct bfd_hash_table
*,
472 table
->dynamic_sections_created
= false;
473 table
->dynobj
= NULL
;
474 /* The first dynamic symbol is a dummy. */
475 table
->dynsymcount
= 1;
476 table
->dynstr
= NULL
;
477 table
->bucketcount
= 0;
478 table
->needed
= NULL
;
479 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
482 /* Create an ELF linker hash table. */
484 struct bfd_link_hash_table
*
485 _bfd_elf_link_hash_table_create (abfd
)
488 struct elf_link_hash_table
*ret
;
490 ret
= ((struct elf_link_hash_table
*)
491 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
492 if (ret
== (struct elf_link_hash_table
*) NULL
)
495 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
497 bfd_release (abfd
, ret
);
504 /* This is a hook for the ELF emulation code in the generic linker to
505 tell the backend linker what file name to use for the DT_NEEDED
506 entry for a dynamic object. The generic linker passes name as an
507 empty string to indicate that no DT_NEEDED entry should be made. */
510 bfd_elf_set_dt_needed_name (abfd
, name
)
514 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
515 elf_dt_needed_name (abfd
) = name
;
518 /* Get the list of DT_NEEDED entries for a link. */
520 struct bfd_link_needed_list
*
521 bfd_elf_get_needed_list (abfd
, info
)
523 struct bfd_link_info
*info
;
525 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
527 return elf_hash_table (info
)->needed
;
530 /* Allocate an ELF string table--force the first byte to be zero. */
532 struct bfd_strtab_hash
*
533 _bfd_elf_stringtab_init ()
535 struct bfd_strtab_hash
*ret
;
537 ret
= _bfd_stringtab_init ();
542 loc
= _bfd_stringtab_add (ret
, "", true, false);
543 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
544 if (loc
== (bfd_size_type
) -1)
546 _bfd_stringtab_free (ret
);
553 /* ELF .o/exec file reading */
555 /* Create a new bfd section from an ELF section header. */
558 bfd_section_from_shdr (abfd
, shindex
)
560 unsigned int shindex
;
562 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
563 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
564 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
567 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
569 switch (hdr
->sh_type
)
572 /* Inactive section. Throw it away. */
575 case SHT_PROGBITS
: /* Normal section with contents. */
576 case SHT_DYNAMIC
: /* Dynamic linking information. */
577 case SHT_NOBITS
: /* .bss section. */
578 case SHT_HASH
: /* .hash section. */
579 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
581 case SHT_SYMTAB
: /* A symbol table */
582 if (elf_onesymtab (abfd
) == shindex
)
585 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
586 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
587 elf_onesymtab (abfd
) = shindex
;
588 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
589 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
590 abfd
->flags
|= HAS_SYMS
;
592 /* Sometimes a shared object will map in the symbol table. If
593 SHF_ALLOC is set, and this is a shared object, then we also
594 treat this section as a BFD section. We can not base the
595 decision purely on SHF_ALLOC, because that flag is sometimes
596 set in a relocateable object file, which would confuse the
598 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
599 && (abfd
->flags
& DYNAMIC
) != 0
600 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
605 case SHT_DYNSYM
: /* A dynamic symbol table */
606 if (elf_dynsymtab (abfd
) == shindex
)
609 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
610 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
611 elf_dynsymtab (abfd
) = shindex
;
612 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
613 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
614 abfd
->flags
|= HAS_SYMS
;
616 /* Besides being a symbol table, we also treat this as a regular
617 section, so that objcopy can handle it. */
618 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
620 case SHT_STRTAB
: /* A string table */
621 if (hdr
->bfd_section
!= NULL
)
623 if (ehdr
->e_shstrndx
== shindex
)
625 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
626 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
632 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
634 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
635 if (hdr2
->sh_link
== shindex
)
637 if (! bfd_section_from_shdr (abfd
, i
))
639 if (elf_onesymtab (abfd
) == i
)
641 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
642 elf_elfsections (abfd
)[shindex
] =
643 &elf_tdata (abfd
)->strtab_hdr
;
646 if (elf_dynsymtab (abfd
) == i
)
648 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
649 elf_elfsections (abfd
)[shindex
] = hdr
=
650 &elf_tdata (abfd
)->dynstrtab_hdr
;
651 /* We also treat this as a regular section, so
652 that objcopy can handle it. */
655 #if 0 /* Not handling other string tables specially right now. */
656 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
657 /* We have a strtab for some random other section. */
658 newsect
= (asection
*) hdr2
->bfd_section
;
661 hdr
->bfd_section
= newsect
;
662 hdr2
= &elf_section_data (newsect
)->str_hdr
;
664 elf_elfsections (abfd
)[shindex
] = hdr2
;
670 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
674 /* *These* do a lot of work -- but build no sections! */
676 asection
*target_sect
;
677 Elf_Internal_Shdr
*hdr2
;
678 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
680 /* For some incomprehensible reason Oracle distributes
681 libraries for Solaris in which some of the objects have
682 bogus sh_link fields. It would be nice if we could just
683 reject them, but, unfortunately, some people need to use
684 them. We scan through the section headers; if we find only
685 one suitable symbol table, we clobber the sh_link to point
686 to it. I hope this doesn't break anything. */
687 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
688 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
694 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
696 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
697 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
708 hdr
->sh_link
= found
;
711 /* Get the symbol table. */
712 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
713 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
716 /* If this reloc section does not use the main symbol table we
717 don't treat it as a reloc section. BFD can't adequately
718 represent such a section, so at least for now, we don't
719 try. We just present it as a normal section. */
720 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
721 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
723 /* Don't allow REL relocations on a machine that uses RELA and
725 /* @@ Actually, the generic ABI does suggest that both might be
726 used in one file. But the four ABI Processor Supplements I
727 have access to right now all specify that only one is used on
728 each of those architectures. It's conceivable that, e.g., a
729 bunch of absolute 32-bit relocs might be more compact in REL
730 form even on a RELA machine... */
731 BFD_ASSERT (use_rela_p
732 ? (hdr
->sh_type
== SHT_RELA
733 && hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
734 : (hdr
->sh_type
== SHT_REL
735 && hdr
->sh_entsize
== bed
->s
->sizeof_rel
));
737 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
739 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
740 if (target_sect
== NULL
)
743 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
745 elf_elfsections (abfd
)[shindex
] = hdr2
;
746 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
747 target_sect
->flags
|= SEC_RELOC
;
748 target_sect
->relocation
= NULL
;
749 target_sect
->rel_filepos
= hdr
->sh_offset
;
750 abfd
->flags
|= HAS_RELOC
;
762 /* Check for any processor-specific section types. */
764 if (bed
->elf_backend_section_from_shdr
)
765 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
773 /* Given an ELF section number, retrieve the corresponding BFD
777 bfd_section_from_elf_index (abfd
, index
)
781 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
782 if (index
>= elf_elfheader (abfd
)->e_shnum
)
784 return elf_elfsections (abfd
)[index
]->bfd_section
;
788 _bfd_elf_new_section_hook (abfd
, sec
)
792 struct bfd_elf_section_data
*sdata
;
794 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
797 sec
->used_by_bfd
= (PTR
) sdata
;
798 memset (sdata
, 0, sizeof (*sdata
));
802 /* Create a new bfd section from an ELF program header.
804 Since program segments have no names, we generate a synthetic name
805 of the form segment<NUM>, where NUM is generally the index in the
806 program header table. For segments that are split (see below) we
807 generate the names segment<NUM>a and segment<NUM>b.
809 Note that some program segments may have a file size that is different than
810 (less than) the memory size. All this means is that at execution the
811 system must allocate the amount of memory specified by the memory size,
812 but only initialize it with the first "file size" bytes read from the
813 file. This would occur for example, with program segments consisting
814 of combined data+bss.
816 To handle the above situation, this routine generates TWO bfd sections
817 for the single program segment. The first has the length specified by
818 the file size of the segment, and the second has the length specified
819 by the difference between the two sizes. In effect, the segment is split
820 into it's initialized and uninitialized parts.
825 bfd_section_from_phdr (abfd
, hdr
, index
)
827 Elf_Internal_Phdr
*hdr
;
835 split
= ((hdr
->p_memsz
> 0) &&
836 (hdr
->p_filesz
> 0) &&
837 (hdr
->p_memsz
> hdr
->p_filesz
));
838 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
839 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
842 strcpy (name
, namebuf
);
843 newsect
= bfd_make_section (abfd
, name
);
846 newsect
->vma
= hdr
->p_vaddr
;
847 newsect
->lma
= hdr
->p_paddr
;
848 newsect
->_raw_size
= hdr
->p_filesz
;
849 newsect
->filepos
= hdr
->p_offset
;
850 newsect
->flags
|= SEC_HAS_CONTENTS
;
851 if (hdr
->p_type
== PT_LOAD
)
853 newsect
->flags
|= SEC_ALLOC
;
854 newsect
->flags
|= SEC_LOAD
;
855 if (hdr
->p_flags
& PF_X
)
857 /* FIXME: all we known is that it has execute PERMISSION,
859 newsect
->flags
|= SEC_CODE
;
862 if (!(hdr
->p_flags
& PF_W
))
864 newsect
->flags
|= SEC_READONLY
;
869 sprintf (namebuf
, "segment%db", index
);
870 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
873 strcpy (name
, namebuf
);
874 newsect
= bfd_make_section (abfd
, name
);
877 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
878 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
879 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
880 if (hdr
->p_type
== PT_LOAD
)
882 newsect
->flags
|= SEC_ALLOC
;
883 if (hdr
->p_flags
& PF_X
)
884 newsect
->flags
|= SEC_CODE
;
886 if (!(hdr
->p_flags
& PF_W
))
887 newsect
->flags
|= SEC_READONLY
;
893 /* Set up an ELF internal section header for a section. */
897 elf_fake_sections (abfd
, asect
, failedptrarg
)
902 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
903 boolean
*failedptr
= (boolean
*) failedptrarg
;
904 Elf_Internal_Shdr
*this_hdr
;
908 /* We already failed; just get out of the bfd_map_over_sections
913 this_hdr
= &elf_section_data (asect
)->this_hdr
;
915 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
918 if (this_hdr
->sh_name
== (unsigned long) -1)
924 this_hdr
->sh_flags
= 0;
926 if ((asect
->flags
& SEC_ALLOC
) != 0)
927 this_hdr
->sh_addr
= asect
->vma
;
929 this_hdr
->sh_addr
= 0;
931 this_hdr
->sh_offset
= 0;
932 this_hdr
->sh_size
= asect
->_raw_size
;
933 this_hdr
->sh_link
= 0;
934 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
935 /* The sh_entsize and sh_info fields may have been set already by
936 copy_private_section_data. */
938 this_hdr
->bfd_section
= asect
;
939 this_hdr
->contents
= NULL
;
941 /* FIXME: This should not be based on section names. */
942 if (strcmp (asect
->name
, ".dynstr") == 0)
943 this_hdr
->sh_type
= SHT_STRTAB
;
944 else if (strcmp (asect
->name
, ".hash") == 0)
946 this_hdr
->sh_type
= SHT_HASH
;
947 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
949 else if (strcmp (asect
->name
, ".dynsym") == 0)
951 this_hdr
->sh_type
= SHT_DYNSYM
;
952 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
954 else if (strcmp (asect
->name
, ".dynamic") == 0)
956 this_hdr
->sh_type
= SHT_DYNAMIC
;
957 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
959 else if (strncmp (asect
->name
, ".rela", 5) == 0
960 && get_elf_backend_data (abfd
)->use_rela_p
)
962 this_hdr
->sh_type
= SHT_RELA
;
963 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
965 else if (strncmp (asect
->name
, ".rel", 4) == 0
966 && ! get_elf_backend_data (abfd
)->use_rela_p
)
968 this_hdr
->sh_type
= SHT_REL
;
969 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
971 else if (strcmp (asect
->name
, ".note") == 0)
972 this_hdr
->sh_type
= SHT_NOTE
;
973 else if (strncmp (asect
->name
, ".stab", 5) == 0
974 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
975 this_hdr
->sh_type
= SHT_STRTAB
;
976 else if ((asect
->flags
& SEC_ALLOC
) != 0
977 && (asect
->flags
& SEC_LOAD
) != 0)
978 this_hdr
->sh_type
= SHT_PROGBITS
;
979 else if ((asect
->flags
& SEC_ALLOC
) != 0
980 && ((asect
->flags
& SEC_LOAD
) == 0))
981 this_hdr
->sh_type
= SHT_NOBITS
;
985 this_hdr
->sh_type
= SHT_PROGBITS
;
988 if ((asect
->flags
& SEC_ALLOC
) != 0)
989 this_hdr
->sh_flags
|= SHF_ALLOC
;
990 if ((asect
->flags
& SEC_READONLY
) == 0)
991 this_hdr
->sh_flags
|= SHF_WRITE
;
992 if ((asect
->flags
& SEC_CODE
) != 0)
993 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
995 /* Check for processor-specific section types. */
997 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
999 if (bed
->elf_backend_fake_sections
)
1000 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1003 /* If the section has relocs, set up a section header for the
1004 SHT_REL[A] section. */
1005 if ((asect
->flags
& SEC_RELOC
) != 0)
1007 Elf_Internal_Shdr
*rela_hdr
;
1008 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1011 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1012 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1018 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1020 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1022 if (rela_hdr
->sh_name
== (unsigned int) -1)
1027 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1028 rela_hdr
->sh_entsize
= (use_rela_p
1029 ? bed
->s
->sizeof_rela
1030 : bed
->s
->sizeof_rel
);
1031 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1032 rela_hdr
->sh_flags
= 0;
1033 rela_hdr
->sh_addr
= 0;
1034 rela_hdr
->sh_size
= 0;
1035 rela_hdr
->sh_offset
= 0;
1039 /* Assign all ELF section numbers. The dummy first section is handled here
1040 too. The link/info pointers for the standard section types are filled
1041 in here too, while we're at it. */
1044 assign_section_numbers (abfd
)
1047 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1049 unsigned int section_number
;
1050 Elf_Internal_Shdr
**i_shdrp
;
1051 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1055 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1057 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1059 d
->this_idx
= section_number
++;
1060 if ((sec
->flags
& SEC_RELOC
) == 0)
1063 d
->rel_idx
= section_number
++;
1066 t
->shstrtab_section
= section_number
++;
1067 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1068 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1070 if (abfd
->symcount
> 0)
1072 t
->symtab_section
= section_number
++;
1073 t
->strtab_section
= section_number
++;
1076 elf_elfheader (abfd
)->e_shnum
= section_number
;
1078 /* Set up the list of section header pointers, in agreement with the
1080 i_shdrp
= ((Elf_Internal_Shdr
**)
1081 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1082 if (i_shdrp
== NULL
)
1085 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1086 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1087 if (i_shdrp
[0] == NULL
)
1089 bfd_release (abfd
, i_shdrp
);
1092 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1094 elf_elfsections (abfd
) = i_shdrp
;
1096 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1097 if (abfd
->symcount
> 0)
1099 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1100 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1101 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1103 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1105 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1109 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1110 if (d
->rel_idx
!= 0)
1111 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1113 /* Fill in the sh_link and sh_info fields while we're at it. */
1115 /* sh_link of a reloc section is the section index of the symbol
1116 table. sh_info is the section index of the section to which
1117 the relocation entries apply. */
1118 if (d
->rel_idx
!= 0)
1120 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1121 d
->rel_hdr
.sh_info
= d
->this_idx
;
1124 switch (d
->this_hdr
.sh_type
)
1128 /* A reloc section which we are treating as a normal BFD
1129 section. sh_link is the section index of the symbol
1130 table. sh_info is the section index of the section to
1131 which the relocation entries apply. We assume that an
1132 allocated reloc section uses the dynamic symbol table.
1133 FIXME: How can we be sure? */
1134 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1136 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1138 /* We look up the section the relocs apply to by name. */
1140 if (d
->this_hdr
.sh_type
== SHT_REL
)
1144 s
= bfd_get_section_by_name (abfd
, name
);
1146 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1150 /* We assume that a section named .stab*str is a stabs
1151 string section. We look for a section with the same name
1152 but without the trailing ``str'', and set its sh_link
1153 field to point to this section. */
1154 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1155 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1160 len
= strlen (sec
->name
);
1161 alc
= (char *) bfd_malloc (len
- 2);
1164 strncpy (alc
, sec
->name
, len
- 3);
1165 alc
[len
- 3] = '\0';
1166 s
= bfd_get_section_by_name (abfd
, alc
);
1170 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1172 /* This is a .stab section. */
1173 elf_section_data (s
)->this_hdr
.sh_entsize
=
1174 4 + 2 * (bed
->s
->arch_size
/ 8);
1181 /* sh_link is the section header index of the string table
1182 used for the dynamic entries or symbol table. */
1183 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1185 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1189 /* sh_link is the section header index of the symbol table
1190 this hash table is for. */
1191 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1193 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1201 /* Map symbol from it's internal number to the external number, moving
1202 all local symbols to be at the head of the list. */
1205 sym_is_global (abfd
, sym
)
1209 /* If the backend has a special mapping, use it. */
1210 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1211 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1214 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1215 || bfd_is_und_section (bfd_get_section (sym
))
1216 || bfd_is_com_section (bfd_get_section (sym
)));
1220 elf_map_symbols (abfd
)
1223 int symcount
= bfd_get_symcount (abfd
);
1224 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1225 asymbol
**sect_syms
;
1227 int num_globals
= 0;
1228 int num_locals2
= 0;
1229 int num_globals2
= 0;
1231 int num_sections
= 0;
1237 fprintf (stderr
, "elf_map_symbols\n");
1241 /* Add a section symbol for each BFD section. FIXME: Is this really
1243 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1245 if (max_index
< asect
->index
)
1246 max_index
= asect
->index
;
1250 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1251 if (sect_syms
== NULL
)
1253 elf_section_syms (abfd
) = sect_syms
;
1255 for (idx
= 0; idx
< symcount
; idx
++)
1257 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1258 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1262 sec
= syms
[idx
]->section
;
1263 if (sec
->owner
!= NULL
)
1265 if (sec
->owner
!= abfd
)
1267 if (sec
->output_offset
!= 0)
1269 sec
= sec
->output_section
;
1270 BFD_ASSERT (sec
->owner
== abfd
);
1272 sect_syms
[sec
->index
] = syms
[idx
];
1277 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1281 if (sect_syms
[asect
->index
] != NULL
)
1284 sym
= bfd_make_empty_symbol (abfd
);
1287 sym
->the_bfd
= abfd
;
1288 sym
->name
= asect
->name
;
1290 /* Set the flags to 0 to indicate that this one was newly added. */
1292 sym
->section
= asect
;
1293 sect_syms
[asect
->index
] = sym
;
1297 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1298 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1302 /* Classify all of the symbols. */
1303 for (idx
= 0; idx
< symcount
; idx
++)
1305 if (!sym_is_global (abfd
, syms
[idx
]))
1310 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1312 if (sect_syms
[asect
->index
] != NULL
1313 && sect_syms
[asect
->index
]->flags
== 0)
1315 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1316 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1320 sect_syms
[asect
->index
]->flags
= 0;
1324 /* Now sort the symbols so the local symbols are first. */
1325 new_syms
= ((asymbol
**)
1327 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1328 if (new_syms
== NULL
)
1331 for (idx
= 0; idx
< symcount
; idx
++)
1333 asymbol
*sym
= syms
[idx
];
1336 if (!sym_is_global (abfd
, sym
))
1339 i
= num_locals
+ num_globals2
++;
1341 sym
->udata
.i
= i
+ 1;
1343 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1345 if (sect_syms
[asect
->index
] != NULL
1346 && sect_syms
[asect
->index
]->flags
== 0)
1348 asymbol
*sym
= sect_syms
[asect
->index
];
1351 sym
->flags
= BSF_SECTION_SYM
;
1352 if (!sym_is_global (abfd
, sym
))
1355 i
= num_locals
+ num_globals2
++;
1357 sym
->udata
.i
= i
+ 1;
1361 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1363 elf_num_locals (abfd
) = num_locals
;
1364 elf_num_globals (abfd
) = num_globals
;
1368 /* Align to the maximum file alignment that could be required for any
1369 ELF data structure. */
1371 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1372 static INLINE file_ptr
1373 align_file_position (off
, align
)
1377 return (off
+ align
- 1) & ~(align
- 1);
1380 /* Assign a file position to a section, optionally aligning to the
1381 required section alignment. */
1384 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1385 Elf_Internal_Shdr
*i_shdrp
;
1393 al
= i_shdrp
->sh_addralign
;
1395 offset
= BFD_ALIGN (offset
, al
);
1397 i_shdrp
->sh_offset
= offset
;
1398 if (i_shdrp
->bfd_section
!= NULL
)
1399 i_shdrp
->bfd_section
->filepos
= offset
;
1400 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1401 offset
+= i_shdrp
->sh_size
;
1405 /* Compute the file positions we are going to put the sections at, and
1406 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1407 is not NULL, this is being called by the ELF backend linker. */
1410 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1412 struct bfd_link_info
*link_info
;
1414 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1416 struct bfd_strtab_hash
*strtab
;
1417 Elf_Internal_Shdr
*shstrtab_hdr
;
1419 if (abfd
->output_has_begun
)
1422 /* Do any elf backend specific processing first. */
1423 if (bed
->elf_backend_begin_write_processing
)
1424 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1426 if (! prep_headers (abfd
))
1430 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1434 if (!assign_section_numbers (abfd
))
1437 /* The backend linker builds symbol table information itself. */
1438 if (link_info
== NULL
&& abfd
->symcount
> 0)
1440 if (! swap_out_syms (abfd
, &strtab
))
1444 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1445 /* sh_name was set in prep_headers. */
1446 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1447 shstrtab_hdr
->sh_flags
= 0;
1448 shstrtab_hdr
->sh_addr
= 0;
1449 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1450 shstrtab_hdr
->sh_entsize
= 0;
1451 shstrtab_hdr
->sh_link
= 0;
1452 shstrtab_hdr
->sh_info
= 0;
1453 /* sh_offset is set in assign_file_positions_except_relocs. */
1454 shstrtab_hdr
->sh_addralign
= 1;
1456 if (!assign_file_positions_except_relocs (abfd
))
1459 if (link_info
== NULL
&& abfd
->symcount
> 0)
1462 Elf_Internal_Shdr
*hdr
;
1464 off
= elf_tdata (abfd
)->next_file_pos
;
1466 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1467 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1469 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1470 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1472 elf_tdata (abfd
)->next_file_pos
= off
;
1474 /* Now that we know where the .strtab section goes, write it
1476 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1477 || ! _bfd_stringtab_emit (abfd
, strtab
))
1479 _bfd_stringtab_free (strtab
);
1482 abfd
->output_has_begun
= true;
1487 /* Create a mapping from a set of sections to a program segment. */
1489 static INLINE
struct elf_segment_map
*
1490 make_mapping (abfd
, sections
, from
, to
)
1492 asection
**sections
;
1496 struct elf_segment_map
*m
;
1500 m
= ((struct elf_segment_map
*)
1502 (sizeof (struct elf_segment_map
)
1503 + (to
- from
- 1) * sizeof (asection
*))));
1507 m
->p_type
= PT_LOAD
;
1508 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1509 m
->sections
[i
- from
] = *hdrpp
;
1510 m
->count
= to
- from
;
1514 /* Include the headers in the first PT_LOAD segment. */
1515 m
->includes_filehdr
= 1;
1516 m
->includes_phdrs
= 1;
1522 /* Set up a mapping from BFD sections to program segments. */
1525 map_sections_to_segments (abfd
)
1528 asection
**sections
= NULL
;
1532 struct elf_segment_map
*mfirst
;
1533 struct elf_segment_map
**pm
;
1534 struct elf_segment_map
*m
;
1536 unsigned int phdr_index
;
1537 bfd_vma maxpagesize
;
1540 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1543 if (bfd_count_sections (abfd
) == 0)
1546 /* Select the allocated sections, and sort them. */
1548 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1549 * sizeof (asection
*));
1550 if (sections
== NULL
)
1554 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1556 if ((s
->flags
& SEC_ALLOC
) != 0)
1562 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1565 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1567 /* Build the mapping. */
1572 /* If we have a .interp section, then create a PT_PHDR segment for
1573 the program headers and a PT_INTERP segment for the .interp
1575 s
= bfd_get_section_by_name (abfd
, ".interp");
1576 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1578 m
= ((struct elf_segment_map
*)
1579 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1583 m
->p_type
= PT_PHDR
;
1584 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1585 m
->p_flags
= PF_R
| PF_X
;
1586 m
->p_flags_valid
= 1;
1587 m
->includes_phdrs
= 1;
1592 m
= ((struct elf_segment_map
*)
1593 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1597 m
->p_type
= PT_INTERP
;
1605 /* Look through the sections. We put sections in the same program
1606 segment when the start of the second section can be placed within
1607 a few bytes of the end of the first section. */
1610 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1611 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1617 /* See if this section and the last one will fit in the same
1619 if (last_hdr
== NULL
1620 || ((BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1622 && ((last_hdr
->flags
& SEC_LOAD
) != 0
1623 || (hdr
->flags
& SEC_LOAD
) == 0)))
1629 /* This section won't fit in the program segment. We must
1630 create a new program header holding all the sections from
1631 phdr_index until hdr. */
1633 m
= make_mapping (abfd
, sections
, phdr_index
, i
);
1644 /* Create a final PT_LOAD program segment. */
1645 if (last_hdr
!= NULL
)
1647 m
= make_mapping (abfd
, sections
, phdr_index
, i
);
1655 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1656 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1657 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1659 m
= ((struct elf_segment_map
*)
1660 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1664 m
->p_type
= PT_DYNAMIC
;
1675 elf_tdata (abfd
)->segment_map
= mfirst
;
1679 if (sections
!= NULL
)
1684 /* Sort sections by VMA. */
1687 elf_sort_sections (arg1
, arg2
)
1691 const asection
*sec1
= *(const asection
**) arg1
;
1692 const asection
*sec2
= *(const asection
**) arg2
;
1694 if (sec1
->vma
< sec2
->vma
)
1696 else if (sec1
->vma
> sec2
->vma
)
1699 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1701 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1705 return sec1
->target_index
- sec2
->target_index
;
1714 /* Sort by size, to put zero sized sections before others at the
1717 if (sec1
->_raw_size
< sec2
->_raw_size
)
1719 if (sec1
->_raw_size
> sec2
->_raw_size
)
1722 return sec1
->target_index
- sec2
->target_index
;
1725 /* Assign file positions to the sections based on the mapping from
1726 sections to segments. This function also sets up some fields in
1727 the file header, and writes out the program headers. */
1730 assign_file_positions_for_segments (abfd
)
1733 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1735 struct elf_segment_map
*m
;
1737 Elf_Internal_Phdr
*phdrs
;
1739 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1740 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1741 Elf_Internal_Phdr
*p
;
1743 if (elf_tdata (abfd
)->segment_map
== NULL
)
1745 if (! map_sections_to_segments (abfd
))
1750 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1753 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
1754 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
1755 elf_elfheader (abfd
)->e_phnum
= count
;
1760 /* Let the backend count up any program headers it might need. */
1761 if (bed
->elf_backend_create_program_headers
)
1762 count
= ((*bed
->elf_backend_create_program_headers
)
1763 (abfd
, (Elf_Internal_Phdr
*) NULL
, count
));
1765 /* If we already counted the number of program segments, make sure
1766 that we allocated enough space. This happens when SIZEOF_HEADERS
1767 is used in a linker script. */
1768 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
1769 if (alloc
!= 0 && count
> alloc
)
1771 ((*_bfd_error_handler
)
1772 ("%s: Not enough room for program headers (allocated %u, need %u)",
1773 bfd_get_filename (abfd
), alloc
, count
));
1774 bfd_set_error (bfd_error_bad_value
);
1781 phdrs
= ((Elf_Internal_Phdr
*)
1782 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
1786 off
= bed
->s
->sizeof_ehdr
;
1787 off
+= alloc
* bed
->s
->sizeof_phdr
;
1793 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
1800 /* If elf_segment_map is not from map_sections_to_segments, the
1801 sections may not be correctly ordered. */
1803 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
1806 p
->p_type
= m
->p_type
;
1808 if (m
->p_flags_valid
)
1809 p
->p_flags
= m
->p_flags
;
1811 if (p
->p_type
== PT_LOAD
&& m
->count
> 0)
1812 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
1817 p
->p_vaddr
= m
->sections
[0]->vma
;
1819 if (m
->p_paddr_valid
)
1820 p
->p_paddr
= m
->p_paddr
;
1821 else if (m
->count
== 0)
1824 p
->p_paddr
= m
->sections
[0]->lma
;
1826 if (p
->p_type
== PT_LOAD
)
1827 p
->p_align
= bed
->maxpagesize
;
1828 else if (m
->count
== 0)
1829 p
->p_align
= bed
->s
->file_align
;
1837 if (m
->includes_filehdr
)
1840 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
1841 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
1844 BFD_ASSERT (p
->p_type
== PT_LOAD
);
1846 if (! m
->p_paddr_valid
)
1849 if (p
->p_type
== PT_LOAD
)
1851 filehdr_vaddr
= p
->p_vaddr
;
1852 filehdr_paddr
= p
->p_paddr
;
1856 if (m
->includes_phdrs
)
1858 if (m
->includes_filehdr
)
1860 if (p
->p_type
== PT_LOAD
)
1862 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
1863 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
1868 p
->p_offset
= bed
->s
->sizeof_ehdr
;
1871 BFD_ASSERT (p
->p_type
== PT_LOAD
);
1872 p
->p_vaddr
-= off
- p
->p_offset
;
1873 if (! m
->p_paddr_valid
)
1874 p
->p_paddr
-= off
- p
->p_offset
;
1876 if (p
->p_type
== PT_LOAD
)
1878 phdrs_vaddr
= p
->p_vaddr
;
1879 phdrs_paddr
= p
->p_paddr
;
1882 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
1883 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
1886 if (p
->p_type
== PT_LOAD
)
1888 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
1894 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
1895 p
->p_filesz
+= adjust
;
1896 p
->p_memsz
+= adjust
;
1900 if (! m
->p_flags_valid
)
1902 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
1906 bfd_size_type align
;
1911 if (p
->p_type
== PT_LOAD
)
1915 /* The section VMA must equal the file position modulo
1917 adjust
= (sec
->vma
- off
) % bed
->maxpagesize
;
1922 p
->p_memsz
+= adjust
;
1923 if ((flags
& SEC_LOAD
) != 0)
1924 p
->p_filesz
+= adjust
;
1930 if ((flags
& SEC_LOAD
) != 0)
1931 off
+= sec
->_raw_size
;
1934 p
->p_memsz
+= sec
->_raw_size
;
1936 if ((flags
& SEC_LOAD
) != 0)
1937 p
->p_filesz
+= sec
->_raw_size
;
1939 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
1940 if (align
> p
->p_align
)
1943 if (! m
->p_flags_valid
)
1945 if ((flags
& SEC_CODE
) != 0)
1947 if ((flags
& SEC_READONLY
) == 0)
1953 /* Now that we have set the section file positions, we can set up
1954 the file positions for the non PT_LOAD segments. */
1955 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
1959 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
1961 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
1962 p
->p_offset
= m
->sections
[0]->filepos
;
1966 if (m
->includes_filehdr
)
1968 p
->p_vaddr
= filehdr_vaddr
;
1969 if (! m
->p_paddr_valid
)
1970 p
->p_paddr
= filehdr_paddr
;
1972 else if (m
->includes_phdrs
)
1974 p
->p_vaddr
= phdrs_vaddr
;
1975 if (! m
->p_paddr_valid
)
1976 p
->p_paddr
= phdrs_paddr
;
1981 /* Let the backend set up any program headers it might need. */
1982 if (bed
->elf_backend_create_program_headers
)
1983 count
= ((*bed
->elf_backend_create_program_headers
)
1984 (abfd
, phdrs
, count
));
1986 /* Clear out any program headers we allocated but did not use. */
1987 for (; count
< alloc
; count
++, p
++)
1989 memset (p
, 0, sizeof *p
);
1990 p
->p_type
= PT_NULL
;
1993 elf_tdata (abfd
)->phdr
= phdrs
;
1995 elf_tdata (abfd
)->next_file_pos
= off
;
1997 /* Write out the program headers. */
1998 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
1999 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2005 /* Get the size of the program header.
2007 If this is called by the linker before any of the section VMA's are set, it
2008 can't calculate the correct value for a strange memory layout. This only
2009 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2010 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2011 data segment (exclusive of .interp and .dynamic).
2013 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2014 will be two segments. */
2016 static bfd_size_type
2017 get_program_header_size (abfd
)
2022 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2024 /* We can't return a different result each time we're called. */
2025 if (elf_tdata (abfd
)->program_header_size
!= 0)
2026 return elf_tdata (abfd
)->program_header_size
;
2028 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2030 struct elf_segment_map
*m
;
2033 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2035 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2036 return elf_tdata (abfd
)->program_header_size
;
2039 /* Assume we will need exactly two PT_LOAD segments: one for text
2040 and one for data. */
2043 s
= bfd_get_section_by_name (abfd
, ".interp");
2044 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2046 /* If we have a loadable interpreter section, we need a
2047 PT_INTERP segment. In this case, assume we also need a
2048 PT_PHDR segment, although that may not be true for all
2053 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2055 /* We need a PT_DYNAMIC segment. */
2059 /* Let the backend count up any program headers it might need. */
2060 if (bed
->elf_backend_create_program_headers
)
2061 segs
= ((*bed
->elf_backend_create_program_headers
)
2062 (abfd
, (Elf_Internal_Phdr
*) NULL
, segs
));
2064 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2065 return elf_tdata (abfd
)->program_header_size
;
2068 /* Work out the file positions of all the sections. This is called by
2069 _bfd_elf_compute_section_file_positions. All the section sizes and
2070 VMAs must be known before this is called.
2072 We do not consider reloc sections at this point, unless they form
2073 part of the loadable image. Reloc sections are assigned file
2074 positions in assign_file_positions_for_relocs, which is called by
2075 write_object_contents and final_link.
2077 We also don't set the positions of the .symtab and .strtab here. */
2080 assign_file_positions_except_relocs (abfd
)
2083 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2084 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2085 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2087 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2089 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
2091 Elf_Internal_Shdr
**hdrpp
;
2094 /* Start after the ELF header. */
2095 off
= i_ehdrp
->e_ehsize
;
2097 /* We are not creating an executable, which means that we are
2098 not creating a program header, and that the actual order of
2099 the sections in the file is unimportant. */
2100 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2102 Elf_Internal_Shdr
*hdr
;
2105 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2107 hdr
->sh_offset
= -1;
2110 if (i
== tdata
->symtab_section
2111 || i
== tdata
->strtab_section
)
2113 hdr
->sh_offset
= -1;
2117 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2123 Elf_Internal_Shdr
**hdrpp
;
2125 /* Assign file positions for the loaded sections based on the
2126 assignment of sections to segments. */
2127 if (! assign_file_positions_for_segments (abfd
))
2130 /* Assign file positions for the other sections. */
2132 off
= elf_tdata (abfd
)->next_file_pos
;
2133 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2135 Elf_Internal_Shdr
*hdr
;
2138 if (hdr
->bfd_section
!= NULL
2139 && hdr
->bfd_section
->filepos
!= 0)
2140 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2141 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
2143 ((*_bfd_error_handler
)
2144 ("%s: warning: allocated section `%s' not in segment",
2145 bfd_get_filename (abfd
),
2146 (hdr
->bfd_section
== NULL
2148 : hdr
->bfd_section
->name
)));
2149 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
2150 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
2153 else if (hdr
->sh_type
== SHT_REL
2154 || hdr
->sh_type
== SHT_RELA
2155 || hdr
== i_shdrpp
[tdata
->symtab_section
]
2156 || hdr
== i_shdrpp
[tdata
->strtab_section
])
2157 hdr
->sh_offset
= -1;
2159 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2163 /* Place the section headers. */
2164 off
= align_file_position (off
, bed
->s
->file_align
);
2165 i_ehdrp
->e_shoff
= off
;
2166 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
2168 elf_tdata (abfd
)->next_file_pos
= off
;
2177 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2178 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2179 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2181 struct bfd_strtab_hash
*shstrtab
;
2182 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2184 i_ehdrp
= elf_elfheader (abfd
);
2185 i_shdrp
= elf_elfsections (abfd
);
2187 shstrtab
= _bfd_elf_stringtab_init ();
2188 if (shstrtab
== NULL
)
2191 elf_shstrtab (abfd
) = shstrtab
;
2193 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2194 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2195 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2196 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2198 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
2199 i_ehdrp
->e_ident
[EI_DATA
] =
2200 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2201 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
2203 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2204 i_ehdrp
->e_ident
[count
] = 0;
2206 if ((abfd
->flags
& DYNAMIC
) != 0)
2207 i_ehdrp
->e_type
= ET_DYN
;
2208 else if ((abfd
->flags
& EXEC_P
) != 0)
2209 i_ehdrp
->e_type
= ET_EXEC
;
2211 i_ehdrp
->e_type
= ET_REL
;
2213 switch (bfd_get_arch (abfd
))
2215 case bfd_arch_unknown
:
2216 i_ehdrp
->e_machine
= EM_NONE
;
2218 case bfd_arch_sparc
:
2219 if (bed
->s
->arch_size
== 64)
2220 i_ehdrp
->e_machine
= EM_SPARC64
;
2222 i_ehdrp
->e_machine
= EM_SPARC
;
2225 i_ehdrp
->e_machine
= EM_386
;
2228 i_ehdrp
->e_machine
= EM_68K
;
2231 i_ehdrp
->e_machine
= EM_88K
;
2234 i_ehdrp
->e_machine
= EM_860
;
2236 case bfd_arch_mips
: /* MIPS Rxxxx */
2237 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2240 i_ehdrp
->e_machine
= EM_PARISC
;
2242 case bfd_arch_powerpc
:
2243 i_ehdrp
->e_machine
= EM_PPC
;
2245 /* start-sanitize-arc */
2247 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
2249 /* end-sanitize-arc */
2250 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2252 i_ehdrp
->e_machine
= EM_NONE
;
2254 i_ehdrp
->e_version
= bed
->s
->ev_current
;
2255 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
2257 /* no program header, for now. */
2258 i_ehdrp
->e_phoff
= 0;
2259 i_ehdrp
->e_phentsize
= 0;
2260 i_ehdrp
->e_phnum
= 0;
2262 /* each bfd section is section header entry */
2263 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2264 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
2266 /* if we're building an executable, we'll need a program header table */
2267 if (abfd
->flags
& EXEC_P
)
2269 /* it all happens later */
2271 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2273 /* elf_build_phdrs() returns a (NULL-terminated) array of
2274 Elf_Internal_Phdrs */
2275 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2276 i_ehdrp
->e_phoff
= outbase
;
2277 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2282 i_ehdrp
->e_phentsize
= 0;
2284 i_ehdrp
->e_phoff
= 0;
2287 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
2288 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
2289 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
2290 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
2291 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
2292 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
2293 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2294 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
2295 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
2301 /* Assign file positions for all the reloc sections which are not part
2302 of the loadable file image. */
2305 _bfd_elf_assign_file_positions_for_relocs (abfd
)
2310 Elf_Internal_Shdr
**shdrpp
;
2312 off
= elf_tdata (abfd
)->next_file_pos
;
2314 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
2315 i
< elf_elfheader (abfd
)->e_shnum
;
2318 Elf_Internal_Shdr
*shdrp
;
2321 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
2322 && shdrp
->sh_offset
== -1)
2323 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
2326 elf_tdata (abfd
)->next_file_pos
= off
;
2330 _bfd_elf_write_object_contents (abfd
)
2333 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2334 Elf_Internal_Ehdr
*i_ehdrp
;
2335 Elf_Internal_Shdr
**i_shdrp
;
2339 if (! abfd
->output_has_begun
2340 && ! _bfd_elf_compute_section_file_positions (abfd
,
2341 (struct bfd_link_info
*) NULL
))
2344 i_shdrp
= elf_elfsections (abfd
);
2345 i_ehdrp
= elf_elfheader (abfd
);
2348 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
2351 _bfd_elf_assign_file_positions_for_relocs (abfd
);
2353 /* After writing the headers, we need to write the sections too... */
2354 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2356 if (bed
->elf_backend_section_processing
)
2357 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2358 if (i_shdrp
[count
]->contents
)
2360 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2361 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2363 != i_shdrp
[count
]->sh_size
))
2368 /* Write out the section header names. */
2369 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
2370 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
2373 if (bed
->elf_backend_final_write_processing
)
2374 (*bed
->elf_backend_final_write_processing
) (abfd
,
2375 elf_tdata (abfd
)->linker
);
2377 return bed
->s
->write_shdrs_and_ehdr (abfd
);
2380 /* given a section, search the header to find them... */
2382 _bfd_elf_section_from_bfd_section (abfd
, asect
)
2386 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2387 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2389 Elf_Internal_Shdr
*hdr
;
2390 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2392 for (index
= 0; index
< maxindex
; index
++)
2394 hdr
= i_shdrp
[index
];
2395 if (hdr
->bfd_section
== asect
)
2399 if (bed
->elf_backend_section_from_bfd_section
)
2401 for (index
= 0; index
< maxindex
; index
++)
2405 hdr
= i_shdrp
[index
];
2407 if ((*bed
->elf_backend_section_from_bfd_section
)
2408 (abfd
, hdr
, asect
, &retval
))
2413 if (bfd_is_abs_section (asect
))
2415 if (bfd_is_com_section (asect
))
2417 if (bfd_is_und_section (asect
))
2423 /* given a symbol, return the bfd index for that symbol. */
2425 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2427 struct symbol_cache_entry
**asym_ptr_ptr
;
2429 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2431 flagword flags
= asym_ptr
->flags
;
2433 /* When gas creates relocations against local labels, it creates its
2434 own symbol for the section, but does put the symbol into the
2435 symbol chain, so udata is 0. When the linker is generating
2436 relocatable output, this section symbol may be for one of the
2437 input sections rather than the output section. */
2438 if (asym_ptr
->udata
.i
== 0
2439 && (flags
& BSF_SECTION_SYM
)
2440 && asym_ptr
->section
)
2444 if (asym_ptr
->section
->output_section
!= NULL
)
2445 indx
= asym_ptr
->section
->output_section
->index
;
2447 indx
= asym_ptr
->section
->index
;
2448 if (elf_section_syms (abfd
)[indx
])
2449 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
2452 idx
= asym_ptr
->udata
.i
;
2453 BFD_ASSERT (idx
!= 0);
2458 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
2459 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2467 /* Copy private BFD data. This copies any program header information. */
2470 copy_private_bfd_data (ibfd
, obfd
)
2474 Elf_Internal_Ehdr
*iehdr
;
2475 struct elf_segment_map
*mfirst
;
2476 struct elf_segment_map
**pm
;
2477 Elf_Internal_Phdr
*p
;
2480 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2481 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2484 if (elf_tdata (ibfd
)->phdr
== NULL
)
2487 iehdr
= elf_elfheader (ibfd
);
2492 c
= elf_elfheader (ibfd
)->e_phnum
;
2493 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< c
; i
++, p
++)
2497 struct elf_segment_map
*m
;
2502 /* The complicated case when p_vaddr is 0 is to handle the
2503 Solaris linker, which generates a PT_INTERP section with
2504 p_vaddr and p_memsz set to 0. */
2505 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2506 if (((s
->vma
>= p
->p_vaddr
2507 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2508 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2511 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2512 && (bfd_vma
) s
->filepos
>= p
->p_offset
2513 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2514 <= p
->p_offset
+ p
->p_filesz
)))
2515 && s
->output_section
!= NULL
)
2518 m
= ((struct elf_segment_map
*)
2520 (sizeof (struct elf_segment_map
)
2521 + (csecs
- 1) * sizeof (asection
*))));
2526 m
->p_type
= p
->p_type
;
2527 m
->p_flags
= p
->p_flags
;
2528 m
->p_flags_valid
= 1;
2529 m
->p_paddr
= p
->p_paddr
;
2530 m
->p_paddr_valid
= 1;
2532 m
->includes_filehdr
= (p
->p_offset
== 0
2533 && p
->p_filesz
>= iehdr
->e_ehsize
);
2535 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2536 && (p
->p_offset
+ p
->p_filesz
2537 >= ((bfd_vma
) iehdr
->e_phoff
2538 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2541 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2543 if (((s
->vma
>= p
->p_vaddr
2544 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2545 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2548 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2549 && (bfd_vma
) s
->filepos
>= p
->p_offset
2550 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2551 <= p
->p_offset
+ p
->p_filesz
)))
2552 && s
->output_section
!= NULL
)
2554 m
->sections
[isec
] = s
->output_section
;
2558 BFD_ASSERT (isec
== csecs
);
2565 elf_tdata (obfd
)->segment_map
= mfirst
;
2570 /* Copy private section information. This copies over the entsize
2571 field, and sometimes the info field. */
2574 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2580 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2582 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2583 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2586 /* Copy over private BFD data if it has not already been copied.
2587 This must be done here, rather than in the copy_private_bfd_data
2588 entry point, because the latter is called after the section
2589 contents have been set, which means that the program headers have
2590 already been worked out. */
2591 if (elf_tdata (obfd
)->segment_map
== NULL
2592 && elf_tdata (ibfd
)->phdr
!= NULL
)
2596 /* Only set up the segments when all the sections have been set
2598 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2599 if (s
->output_section
== NULL
)
2603 if (! copy_private_bfd_data (ibfd
, obfd
))
2608 ihdr
= &elf_section_data (isec
)->this_hdr
;
2609 ohdr
= &elf_section_data (osec
)->this_hdr
;
2611 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2613 if (ihdr
->sh_type
== SHT_SYMTAB
2614 || ihdr
->sh_type
== SHT_DYNSYM
)
2615 ohdr
->sh_info
= ihdr
->sh_info
;
2620 /* Copy private symbol information. If this symbol is in a section
2621 which we did not map into a BFD section, try to map the section
2622 index correctly. We use special macro definitions for the mapped
2623 section indices; these definitions are interpreted by the
2624 swap_out_syms function. */
2626 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2627 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2628 #define MAP_STRTAB (SHN_LORESERVE - 3)
2629 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2632 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2638 elf_symbol_type
*isym
, *osym
;
2640 isym
= elf_symbol_from (ibfd
, isymarg
);
2641 osym
= elf_symbol_from (obfd
, osymarg
);
2645 && bfd_is_abs_section (isym
->symbol
.section
))
2649 shndx
= isym
->internal_elf_sym
.st_shndx
;
2650 if (shndx
== elf_onesymtab (ibfd
))
2651 shndx
= MAP_ONESYMTAB
;
2652 else if (shndx
== elf_dynsymtab (ibfd
))
2653 shndx
= MAP_DYNSYMTAB
;
2654 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2656 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2657 shndx
= MAP_SHSTRTAB
;
2658 osym
->internal_elf_sym
.st_shndx
= shndx
;
2664 /* Swap out the symbols. */
2667 swap_out_syms (abfd
, sttp
)
2669 struct bfd_strtab_hash
**sttp
;
2671 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2673 if (!elf_map_symbols (abfd
))
2676 /* Dump out the symtabs. */
2678 int symcount
= bfd_get_symcount (abfd
);
2679 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2680 struct bfd_strtab_hash
*stt
;
2681 Elf_Internal_Shdr
*symtab_hdr
;
2682 Elf_Internal_Shdr
*symstrtab_hdr
;
2683 char *outbound_syms
;
2686 stt
= _bfd_elf_stringtab_init ();
2690 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2691 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2692 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2693 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2694 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2695 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
2697 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2698 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2700 outbound_syms
= bfd_alloc (abfd
,
2701 (1 + symcount
) * bed
->s
->sizeof_sym
);
2702 if (outbound_syms
== NULL
)
2704 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2706 /* now generate the data (for "contents") */
2708 /* Fill in zeroth symbol and swap it out. */
2709 Elf_Internal_Sym sym
;
2715 sym
.st_shndx
= SHN_UNDEF
;
2716 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2717 outbound_syms
+= bed
->s
->sizeof_sym
;
2719 for (idx
= 0; idx
< symcount
; idx
++)
2721 Elf_Internal_Sym sym
;
2722 bfd_vma value
= syms
[idx
]->value
;
2723 elf_symbol_type
*type_ptr
;
2724 flagword flags
= syms
[idx
]->flags
;
2726 if (flags
& BSF_SECTION_SYM
)
2727 /* Section symbols have no names. */
2731 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2734 if (sym
.st_name
== (unsigned long) -1)
2738 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2740 if (bfd_is_com_section (syms
[idx
]->section
))
2742 /* ELF common symbols put the alignment into the `value' field,
2743 and the size into the `size' field. This is backwards from
2744 how BFD handles it, so reverse it here. */
2745 sym
.st_size
= value
;
2746 if (type_ptr
== NULL
2747 || type_ptr
->internal_elf_sym
.st_value
== 0)
2748 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2750 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2751 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
2752 syms
[idx
]->section
);
2756 asection
*sec
= syms
[idx
]->section
;
2759 if (sec
->output_section
)
2761 value
+= sec
->output_offset
;
2762 sec
= sec
->output_section
;
2765 sym
.st_value
= value
;
2766 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2768 if (bfd_is_abs_section (sec
)
2770 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
2772 /* This symbol is in a real ELF section which we did
2773 not create as a BFD section. Undo the mapping done
2774 by copy_private_symbol_data. */
2775 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
2779 shndx
= elf_onesymtab (abfd
);
2782 shndx
= elf_dynsymtab (abfd
);
2785 shndx
= elf_tdata (abfd
)->strtab_section
;
2788 shndx
= elf_tdata (abfd
)->shstrtab_section
;
2796 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2802 /* Writing this would be a hell of a lot easier if
2803 we had some decent documentation on bfd, and
2804 knew what to expect of the library, and what to
2805 demand of applications. For example, it
2806 appears that `objcopy' might not set the
2807 section of a symbol to be a section that is
2808 actually in the output file. */
2809 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2810 BFD_ASSERT (sec2
!= 0);
2811 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
2812 BFD_ASSERT (shndx
!= -1);
2816 sym
.st_shndx
= shndx
;
2819 if (bfd_is_com_section (syms
[idx
]->section
))
2820 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2821 else if (bfd_is_und_section (syms
[idx
]->section
))
2822 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
2825 ((flags
& BSF_FUNCTION
)
2828 else if (flags
& BSF_SECTION_SYM
)
2829 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2830 else if (flags
& BSF_FILE
)
2831 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2834 int bind
= STB_LOCAL
;
2835 int type
= STT_OBJECT
;
2837 if (flags
& BSF_LOCAL
)
2839 else if (flags
& BSF_WEAK
)
2841 else if (flags
& BSF_GLOBAL
)
2844 if (flags
& BSF_FUNCTION
)
2847 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2851 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2852 outbound_syms
+= bed
->s
->sizeof_sym
;
2856 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2857 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2859 symstrtab_hdr
->sh_flags
= 0;
2860 symstrtab_hdr
->sh_addr
= 0;
2861 symstrtab_hdr
->sh_entsize
= 0;
2862 symstrtab_hdr
->sh_link
= 0;
2863 symstrtab_hdr
->sh_info
= 0;
2864 symstrtab_hdr
->sh_addralign
= 1;
2870 /* Return the number of bytes required to hold the symtab vector.
2872 Note that we base it on the count plus 1, since we will null terminate
2873 the vector allocated based on this size. However, the ELF symbol table
2874 always has a dummy entry as symbol #0, so it ends up even. */
2877 _bfd_elf_get_symtab_upper_bound (abfd
)
2882 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2884 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2885 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2891 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
2896 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2898 if (elf_dynsymtab (abfd
) == 0)
2900 bfd_set_error (bfd_error_invalid_operation
);
2904 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2905 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2911 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
2915 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2918 /* Canonicalize the relocs. */
2921 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2930 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
, section
, symbols
))
2933 tblptr
= section
->relocation
;
2934 for (i
= 0; i
< section
->reloc_count
; i
++)
2935 *relptr
++ = tblptr
++;
2939 return section
->reloc_count
;
2943 _bfd_elf_get_symtab (abfd
, alocation
)
2945 asymbol
**alocation
;
2947 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
2950 bfd_get_symcount (abfd
) = symcount
;
2955 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
2957 asymbol
**alocation
;
2959 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
2963 _bfd_elf_make_empty_symbol (abfd
)
2966 elf_symbol_type
*newsym
;
2968 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
2973 newsym
->symbol
.the_bfd
= abfd
;
2974 return &newsym
->symbol
;
2979 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
2984 bfd_symbol_info (symbol
, ret
);
2988 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
2997 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
2999 enum bfd_architecture arch
;
3000 unsigned long machine
;
3002 /* If this isn't the right architecture for this backend, and this
3003 isn't the generic backend, fail. */
3004 if (arch
!= get_elf_backend_data (abfd
)->arch
3005 && arch
!= bfd_arch_unknown
3006 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3009 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3012 /* Find the nearest line to a particular section and offset, for error
3016 _bfd_elf_find_nearest_line (abfd
,
3027 CONST
char **filename_ptr
;
3028 CONST
char **functionname_ptr
;
3029 unsigned int *line_ptr
;
3031 const char *filename
;
3035 if (symbols
== NULL
)
3041 for (p
= symbols
; *p
!= NULL
; p
++)
3045 q
= (elf_symbol_type
*) *p
;
3047 if (bfd_get_section (&q
->symbol
) != section
)
3050 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3055 filename
= bfd_asymbol_name (&q
->symbol
);
3059 || q
->symbol
.value
<= offset
)
3060 func
= (asymbol
*) q
;
3068 *filename_ptr
= filename
;
3069 *functionname_ptr
= bfd_asymbol_name (func
);
3075 _bfd_elf_sizeof_headers (abfd
, reloc
)
3081 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3083 ret
+= get_program_header_size (abfd
);
3088 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3093 bfd_size_type count
;
3095 Elf_Internal_Shdr
*hdr
;
3097 if (! abfd
->output_has_begun
3098 && ! _bfd_elf_compute_section_file_positions (abfd
,
3099 (struct bfd_link_info
*) NULL
))
3102 hdr
= &elf_section_data (section
)->this_hdr
;
3104 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3106 if (bfd_write (location
, 1, count
, abfd
) != count
)
3113 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3116 Elf_Internal_Rela
*dst
;
3123 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3126 Elf_Internal_Rel
*dst
;