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 case SHT_NOTE
: /* .note section. */
580 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
582 case SHT_SYMTAB
: /* A symbol table */
583 if (elf_onesymtab (abfd
) == shindex
)
586 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
587 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
588 elf_onesymtab (abfd
) = shindex
;
589 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
590 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
591 abfd
->flags
|= HAS_SYMS
;
593 /* Sometimes a shared object will map in the symbol table. If
594 SHF_ALLOC is set, and this is a shared object, then we also
595 treat this section as a BFD section. We can not base the
596 decision purely on SHF_ALLOC, because that flag is sometimes
597 set in a relocateable object file, which would confuse the
599 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
600 && (abfd
->flags
& DYNAMIC
) != 0
601 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
606 case SHT_DYNSYM
: /* A dynamic symbol table */
607 if (elf_dynsymtab (abfd
) == shindex
)
610 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
611 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
612 elf_dynsymtab (abfd
) = shindex
;
613 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
614 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
615 abfd
->flags
|= HAS_SYMS
;
617 /* Besides being a symbol table, we also treat this as a regular
618 section, so that objcopy can handle it. */
619 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
621 case SHT_STRTAB
: /* A string table */
622 if (hdr
->bfd_section
!= NULL
)
624 if (ehdr
->e_shstrndx
== shindex
)
626 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
627 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
633 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
635 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
636 if (hdr2
->sh_link
== shindex
)
638 if (! bfd_section_from_shdr (abfd
, i
))
640 if (elf_onesymtab (abfd
) == i
)
642 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
643 elf_elfsections (abfd
)[shindex
] =
644 &elf_tdata (abfd
)->strtab_hdr
;
647 if (elf_dynsymtab (abfd
) == i
)
649 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
650 elf_elfsections (abfd
)[shindex
] = hdr
=
651 &elf_tdata (abfd
)->dynstrtab_hdr
;
652 /* We also treat this as a regular section, so
653 that objcopy can handle it. */
656 #if 0 /* Not handling other string tables specially right now. */
657 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
658 /* We have a strtab for some random other section. */
659 newsect
= (asection
*) hdr2
->bfd_section
;
662 hdr
->bfd_section
= newsect
;
663 hdr2
= &elf_section_data (newsect
)->str_hdr
;
665 elf_elfsections (abfd
)[shindex
] = hdr2
;
671 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
675 /* *These* do a lot of work -- but build no sections! */
677 asection
*target_sect
;
678 Elf_Internal_Shdr
*hdr2
;
679 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
681 /* For some incomprehensible reason Oracle distributes
682 libraries for Solaris in which some of the objects have
683 bogus sh_link fields. It would be nice if we could just
684 reject them, but, unfortunately, some people need to use
685 them. We scan through the section headers; if we find only
686 one suitable symbol table, we clobber the sh_link to point
687 to it. I hope this doesn't break anything. */
688 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
689 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
695 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
697 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
698 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
709 hdr
->sh_link
= found
;
712 /* Get the symbol table. */
713 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
714 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
717 /* If this reloc section does not use the main symbol table we
718 don't treat it as a reloc section. BFD can't adequately
719 represent such a section, so at least for now, we don't
720 try. We just present it as a normal section. */
721 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
722 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
724 /* Don't allow REL relocations on a machine that uses RELA and
726 /* @@ Actually, the generic ABI does suggest that both might be
727 used in one file. But the four ABI Processor Supplements I
728 have access to right now all specify that only one is used on
729 each of those architectures. It's conceivable that, e.g., a
730 bunch of absolute 32-bit relocs might be more compact in REL
731 form even on a RELA machine... */
732 BFD_ASSERT (use_rela_p
733 ? (hdr
->sh_type
== SHT_RELA
734 && hdr
->sh_entsize
== bed
->s
->sizeof_rela
)
735 : (hdr
->sh_type
== SHT_REL
736 && hdr
->sh_entsize
== bed
->s
->sizeof_rel
));
738 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
740 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
741 if (target_sect
== NULL
)
744 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
746 elf_elfsections (abfd
)[shindex
] = hdr2
;
747 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
748 target_sect
->flags
|= SEC_RELOC
;
749 target_sect
->relocation
= NULL
;
750 target_sect
->rel_filepos
= hdr
->sh_offset
;
751 abfd
->flags
|= HAS_RELOC
;
760 /* Check for any processor-specific section types. */
762 if (bed
->elf_backend_section_from_shdr
)
763 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
771 /* Given an ELF section number, retrieve the corresponding BFD
775 bfd_section_from_elf_index (abfd
, index
)
779 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
780 if (index
>= elf_elfheader (abfd
)->e_shnum
)
782 return elf_elfsections (abfd
)[index
]->bfd_section
;
786 _bfd_elf_new_section_hook (abfd
, sec
)
790 struct bfd_elf_section_data
*sdata
;
792 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
795 sec
->used_by_bfd
= (PTR
) sdata
;
796 memset (sdata
, 0, sizeof (*sdata
));
800 /* Create a new bfd section from an ELF program header.
802 Since program segments have no names, we generate a synthetic name
803 of the form segment<NUM>, where NUM is generally the index in the
804 program header table. For segments that are split (see below) we
805 generate the names segment<NUM>a and segment<NUM>b.
807 Note that some program segments may have a file size that is different than
808 (less than) the memory size. All this means is that at execution the
809 system must allocate the amount of memory specified by the memory size,
810 but only initialize it with the first "file size" bytes read from the
811 file. This would occur for example, with program segments consisting
812 of combined data+bss.
814 To handle the above situation, this routine generates TWO bfd sections
815 for the single program segment. The first has the length specified by
816 the file size of the segment, and the second has the length specified
817 by the difference between the two sizes. In effect, the segment is split
818 into it's initialized and uninitialized parts.
823 bfd_section_from_phdr (abfd
, hdr
, index
)
825 Elf_Internal_Phdr
*hdr
;
833 split
= ((hdr
->p_memsz
> 0) &&
834 (hdr
->p_filesz
> 0) &&
835 (hdr
->p_memsz
> hdr
->p_filesz
));
836 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
837 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
840 strcpy (name
, namebuf
);
841 newsect
= bfd_make_section (abfd
, name
);
844 newsect
->vma
= hdr
->p_vaddr
;
845 newsect
->lma
= hdr
->p_paddr
;
846 newsect
->_raw_size
= hdr
->p_filesz
;
847 newsect
->filepos
= hdr
->p_offset
;
848 newsect
->flags
|= SEC_HAS_CONTENTS
;
849 if (hdr
->p_type
== PT_LOAD
)
851 newsect
->flags
|= SEC_ALLOC
;
852 newsect
->flags
|= SEC_LOAD
;
853 if (hdr
->p_flags
& PF_X
)
855 /* FIXME: all we known is that it has execute PERMISSION,
857 newsect
->flags
|= SEC_CODE
;
860 if (!(hdr
->p_flags
& PF_W
))
862 newsect
->flags
|= SEC_READONLY
;
867 sprintf (namebuf
, "segment%db", index
);
868 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
871 strcpy (name
, namebuf
);
872 newsect
= bfd_make_section (abfd
, name
);
875 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
876 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
877 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
878 if (hdr
->p_type
== PT_LOAD
)
880 newsect
->flags
|= SEC_ALLOC
;
881 if (hdr
->p_flags
& PF_X
)
882 newsect
->flags
|= SEC_CODE
;
884 if (!(hdr
->p_flags
& PF_W
))
885 newsect
->flags
|= SEC_READONLY
;
891 /* Set up an ELF internal section header for a section. */
895 elf_fake_sections (abfd
, asect
, failedptrarg
)
900 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
901 boolean
*failedptr
= (boolean
*) failedptrarg
;
902 Elf_Internal_Shdr
*this_hdr
;
906 /* We already failed; just get out of the bfd_map_over_sections
911 this_hdr
= &elf_section_data (asect
)->this_hdr
;
913 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
916 if (this_hdr
->sh_name
== (unsigned long) -1)
922 this_hdr
->sh_flags
= 0;
924 if ((asect
->flags
& SEC_ALLOC
) != 0)
925 this_hdr
->sh_addr
= asect
->vma
;
927 this_hdr
->sh_addr
= 0;
929 this_hdr
->sh_offset
= 0;
930 this_hdr
->sh_size
= asect
->_raw_size
;
931 this_hdr
->sh_link
= 0;
932 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
933 /* The sh_entsize and sh_info fields may have been set already by
934 copy_private_section_data. */
936 this_hdr
->bfd_section
= asect
;
937 this_hdr
->contents
= NULL
;
939 /* FIXME: This should not be based on section names. */
940 if (strcmp (asect
->name
, ".dynstr") == 0)
941 this_hdr
->sh_type
= SHT_STRTAB
;
942 else if (strcmp (asect
->name
, ".hash") == 0)
944 this_hdr
->sh_type
= SHT_HASH
;
945 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
947 else if (strcmp (asect
->name
, ".dynsym") == 0)
949 this_hdr
->sh_type
= SHT_DYNSYM
;
950 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
952 else if (strcmp (asect
->name
, ".dynamic") == 0)
954 this_hdr
->sh_type
= SHT_DYNAMIC
;
955 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
957 else if (strncmp (asect
->name
, ".rela", 5) == 0
958 && get_elf_backend_data (abfd
)->use_rela_p
)
960 this_hdr
->sh_type
= SHT_RELA
;
961 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
963 else if (strncmp (asect
->name
, ".rel", 4) == 0
964 && ! get_elf_backend_data (abfd
)->use_rela_p
)
966 this_hdr
->sh_type
= SHT_REL
;
967 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
969 else if (strcmp (asect
->name
, ".note") == 0)
970 this_hdr
->sh_type
= SHT_NOTE
;
971 else if (strncmp (asect
->name
, ".stab", 5) == 0
972 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
973 this_hdr
->sh_type
= SHT_STRTAB
;
974 else if ((asect
->flags
& SEC_ALLOC
) != 0
975 && (asect
->flags
& SEC_LOAD
) != 0)
976 this_hdr
->sh_type
= SHT_PROGBITS
;
977 else if ((asect
->flags
& SEC_ALLOC
) != 0
978 && ((asect
->flags
& SEC_LOAD
) == 0))
979 this_hdr
->sh_type
= SHT_NOBITS
;
983 this_hdr
->sh_type
= SHT_PROGBITS
;
986 if ((asect
->flags
& SEC_ALLOC
) != 0)
987 this_hdr
->sh_flags
|= SHF_ALLOC
;
988 if ((asect
->flags
& SEC_READONLY
) == 0)
989 this_hdr
->sh_flags
|= SHF_WRITE
;
990 if ((asect
->flags
& SEC_CODE
) != 0)
991 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
993 /* Check for processor-specific section types. */
995 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
997 if (bed
->elf_backend_fake_sections
)
998 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1001 /* If the section has relocs, set up a section header for the
1002 SHT_REL[A] section. */
1003 if ((asect
->flags
& SEC_RELOC
) != 0)
1005 Elf_Internal_Shdr
*rela_hdr
;
1006 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1009 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1010 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1016 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1018 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1020 if (rela_hdr
->sh_name
== (unsigned int) -1)
1025 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1026 rela_hdr
->sh_entsize
= (use_rela_p
1027 ? bed
->s
->sizeof_rela
1028 : bed
->s
->sizeof_rel
);
1029 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1030 rela_hdr
->sh_flags
= 0;
1031 rela_hdr
->sh_addr
= 0;
1032 rela_hdr
->sh_size
= 0;
1033 rela_hdr
->sh_offset
= 0;
1037 /* Assign all ELF section numbers. The dummy first section is handled here
1038 too. The link/info pointers for the standard section types are filled
1039 in here too, while we're at it. */
1042 assign_section_numbers (abfd
)
1045 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1047 unsigned int section_number
;
1048 Elf_Internal_Shdr
**i_shdrp
;
1049 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1053 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1055 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1057 d
->this_idx
= section_number
++;
1058 if ((sec
->flags
& SEC_RELOC
) == 0)
1061 d
->rel_idx
= section_number
++;
1064 t
->shstrtab_section
= section_number
++;
1065 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1066 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1068 if (abfd
->symcount
> 0)
1070 t
->symtab_section
= section_number
++;
1071 t
->strtab_section
= section_number
++;
1074 elf_elfheader (abfd
)->e_shnum
= section_number
;
1076 /* Set up the list of section header pointers, in agreement with the
1078 i_shdrp
= ((Elf_Internal_Shdr
**)
1079 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1080 if (i_shdrp
== NULL
)
1083 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1084 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1085 if (i_shdrp
[0] == NULL
)
1087 bfd_release (abfd
, i_shdrp
);
1090 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1092 elf_elfsections (abfd
) = i_shdrp
;
1094 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1095 if (abfd
->symcount
> 0)
1097 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1098 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1099 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1101 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1103 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1107 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1108 if (d
->rel_idx
!= 0)
1109 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1111 /* Fill in the sh_link and sh_info fields while we're at it. */
1113 /* sh_link of a reloc section is the section index of the symbol
1114 table. sh_info is the section index of the section to which
1115 the relocation entries apply. */
1116 if (d
->rel_idx
!= 0)
1118 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1119 d
->rel_hdr
.sh_info
= d
->this_idx
;
1122 switch (d
->this_hdr
.sh_type
)
1126 /* A reloc section which we are treating as a normal BFD
1127 section. sh_link is the section index of the symbol
1128 table. sh_info is the section index of the section to
1129 which the relocation entries apply. We assume that an
1130 allocated reloc section uses the dynamic symbol table.
1131 FIXME: How can we be sure? */
1132 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1134 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1136 /* We look up the section the relocs apply to by name. */
1138 if (d
->this_hdr
.sh_type
== SHT_REL
)
1142 s
= bfd_get_section_by_name (abfd
, name
);
1144 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1148 /* We assume that a section named .stab*str is a stabs
1149 string section. We look for a section with the same name
1150 but without the trailing ``str'', and set its sh_link
1151 field to point to this section. */
1152 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1153 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1158 len
= strlen (sec
->name
);
1159 alc
= (char *) bfd_malloc (len
- 2);
1162 strncpy (alc
, sec
->name
, len
- 3);
1163 alc
[len
- 3] = '\0';
1164 s
= bfd_get_section_by_name (abfd
, alc
);
1168 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1170 /* This is a .stab section. */
1171 elf_section_data (s
)->this_hdr
.sh_entsize
=
1172 4 + 2 * (bed
->s
->arch_size
/ 8);
1179 /* sh_link is the section header index of the string table
1180 used for the dynamic entries or symbol table. */
1181 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1183 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1187 /* sh_link is the section header index of the symbol table
1188 this hash table is for. */
1189 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1191 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1199 /* Map symbol from it's internal number to the external number, moving
1200 all local symbols to be at the head of the list. */
1203 sym_is_global (abfd
, sym
)
1207 /* If the backend has a special mapping, use it. */
1208 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1209 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1212 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1213 || bfd_is_und_section (bfd_get_section (sym
))
1214 || bfd_is_com_section (bfd_get_section (sym
)));
1218 elf_map_symbols (abfd
)
1221 int symcount
= bfd_get_symcount (abfd
);
1222 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1223 asymbol
**sect_syms
;
1225 int num_globals
= 0;
1226 int num_locals2
= 0;
1227 int num_globals2
= 0;
1229 int num_sections
= 0;
1235 fprintf (stderr
, "elf_map_symbols\n");
1239 /* Add a section symbol for each BFD section. FIXME: Is this really
1241 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1243 if (max_index
< asect
->index
)
1244 max_index
= asect
->index
;
1248 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1249 if (sect_syms
== NULL
)
1251 elf_section_syms (abfd
) = sect_syms
;
1253 for (idx
= 0; idx
< symcount
; idx
++)
1255 if ((syms
[idx
]->flags
& BSF_SECTION_SYM
) != 0
1256 && (syms
[idx
]->value
+ syms
[idx
]->section
->vma
) == 0)
1260 sec
= syms
[idx
]->section
;
1261 if (sec
->owner
!= NULL
)
1263 if (sec
->owner
!= abfd
)
1265 if (sec
->output_offset
!= 0)
1267 sec
= sec
->output_section
;
1268 BFD_ASSERT (sec
->owner
== abfd
);
1270 sect_syms
[sec
->index
] = syms
[idx
];
1275 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1279 if (sect_syms
[asect
->index
] != NULL
)
1282 sym
= bfd_make_empty_symbol (abfd
);
1285 sym
->the_bfd
= abfd
;
1286 sym
->name
= asect
->name
;
1288 /* Set the flags to 0 to indicate that this one was newly added. */
1290 sym
->section
= asect
;
1291 sect_syms
[asect
->index
] = sym
;
1295 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1296 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1300 /* Classify all of the symbols. */
1301 for (idx
= 0; idx
< symcount
; idx
++)
1303 if (!sym_is_global (abfd
, syms
[idx
]))
1308 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1310 if (sect_syms
[asect
->index
] != NULL
1311 && sect_syms
[asect
->index
]->flags
== 0)
1313 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1314 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1318 sect_syms
[asect
->index
]->flags
= 0;
1322 /* Now sort the symbols so the local symbols are first. */
1323 new_syms
= ((asymbol
**)
1325 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1326 if (new_syms
== NULL
)
1329 for (idx
= 0; idx
< symcount
; idx
++)
1331 asymbol
*sym
= syms
[idx
];
1334 if (!sym_is_global (abfd
, sym
))
1337 i
= num_locals
+ num_globals2
++;
1339 sym
->udata
.i
= i
+ 1;
1341 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1343 if (sect_syms
[asect
->index
] != NULL
1344 && sect_syms
[asect
->index
]->flags
== 0)
1346 asymbol
*sym
= sect_syms
[asect
->index
];
1349 sym
->flags
= BSF_SECTION_SYM
;
1350 if (!sym_is_global (abfd
, sym
))
1353 i
= num_locals
+ num_globals2
++;
1355 sym
->udata
.i
= i
+ 1;
1359 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1361 elf_num_locals (abfd
) = num_locals
;
1362 elf_num_globals (abfd
) = num_globals
;
1366 /* Align to the maximum file alignment that could be required for any
1367 ELF data structure. */
1369 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1370 static INLINE file_ptr
1371 align_file_position (off
, align
)
1375 return (off
+ align
- 1) & ~(align
- 1);
1378 /* Assign a file position to a section, optionally aligning to the
1379 required section alignment. */
1382 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1383 Elf_Internal_Shdr
*i_shdrp
;
1391 al
= i_shdrp
->sh_addralign
;
1393 offset
= BFD_ALIGN (offset
, al
);
1395 i_shdrp
->sh_offset
= offset
;
1396 if (i_shdrp
->bfd_section
!= NULL
)
1397 i_shdrp
->bfd_section
->filepos
= offset
;
1398 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1399 offset
+= i_shdrp
->sh_size
;
1403 /* Compute the file positions we are going to put the sections at, and
1404 otherwise prepare to begin writing out the ELF file. If LINK_INFO
1405 is not NULL, this is being called by the ELF backend linker. */
1408 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
1410 struct bfd_link_info
*link_info
;
1412 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1414 struct bfd_strtab_hash
*strtab
;
1415 Elf_Internal_Shdr
*shstrtab_hdr
;
1417 if (abfd
->output_has_begun
)
1420 /* Do any elf backend specific processing first. */
1421 if (bed
->elf_backend_begin_write_processing
)
1422 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
1424 if (! prep_headers (abfd
))
1428 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
1432 if (!assign_section_numbers (abfd
))
1435 /* The backend linker builds symbol table information itself. */
1436 if (link_info
== NULL
&& abfd
->symcount
> 0)
1438 if (! swap_out_syms (abfd
, &strtab
))
1442 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
1443 /* sh_name was set in prep_headers. */
1444 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
1445 shstrtab_hdr
->sh_flags
= 0;
1446 shstrtab_hdr
->sh_addr
= 0;
1447 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1448 shstrtab_hdr
->sh_entsize
= 0;
1449 shstrtab_hdr
->sh_link
= 0;
1450 shstrtab_hdr
->sh_info
= 0;
1451 /* sh_offset is set in assign_file_positions_except_relocs. */
1452 shstrtab_hdr
->sh_addralign
= 1;
1454 if (!assign_file_positions_except_relocs (abfd
))
1457 if (link_info
== NULL
&& abfd
->symcount
> 0)
1460 Elf_Internal_Shdr
*hdr
;
1462 off
= elf_tdata (abfd
)->next_file_pos
;
1464 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1465 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1467 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
1468 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
1470 elf_tdata (abfd
)->next_file_pos
= off
;
1472 /* Now that we know where the .strtab section goes, write it
1474 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
1475 || ! _bfd_stringtab_emit (abfd
, strtab
))
1477 _bfd_stringtab_free (strtab
);
1480 abfd
->output_has_begun
= true;
1485 /* Create a mapping from a set of sections to a program segment. */
1487 static INLINE
struct elf_segment_map
*
1488 make_mapping (abfd
, sections
, from
, to
)
1490 asection
**sections
;
1494 struct elf_segment_map
*m
;
1498 m
= ((struct elf_segment_map
*)
1500 (sizeof (struct elf_segment_map
)
1501 + (to
- from
- 1) * sizeof (asection
*))));
1505 m
->p_type
= PT_LOAD
;
1506 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
1507 m
->sections
[i
- from
] = *hdrpp
;
1508 m
->count
= to
- from
;
1512 /* Include the headers in the first PT_LOAD segment. */
1513 m
->includes_filehdr
= 1;
1514 m
->includes_phdrs
= 1;
1520 /* Set up a mapping from BFD sections to program segments. */
1523 map_sections_to_segments (abfd
)
1526 asection
**sections
= NULL
;
1530 struct elf_segment_map
*mfirst
;
1531 struct elf_segment_map
**pm
;
1532 struct elf_segment_map
*m
;
1534 unsigned int phdr_index
;
1535 bfd_vma maxpagesize
;
1538 if (elf_tdata (abfd
)->segment_map
!= NULL
)
1541 if (bfd_count_sections (abfd
) == 0)
1544 /* Select the allocated sections, and sort them. */
1546 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
1547 * sizeof (asection
*));
1548 if (sections
== NULL
)
1552 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
1554 if ((s
->flags
& SEC_ALLOC
) != 0)
1560 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
1563 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
1565 /* Build the mapping. */
1570 /* If we have a .interp section, then create a PT_PHDR segment for
1571 the program headers and a PT_INTERP segment for the .interp
1573 s
= bfd_get_section_by_name (abfd
, ".interp");
1574 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1576 m
= ((struct elf_segment_map
*)
1577 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1581 m
->p_type
= PT_PHDR
;
1582 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
1583 m
->p_flags
= PF_R
| PF_X
;
1584 m
->p_flags_valid
= 1;
1585 m
->includes_phdrs
= 1;
1590 m
= ((struct elf_segment_map
*)
1591 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1595 m
->p_type
= PT_INTERP
;
1603 /* Look through the sections. We put sections in the same program
1604 segment when the start of the second section can be placed within
1605 a few bytes of the end of the first section. */
1608 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1609 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
1615 /* See if this section and the last one will fit in the same
1617 if (last_hdr
== NULL
1618 || ((BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
1620 && ((last_hdr
->flags
& SEC_LOAD
) != 0
1621 || (hdr
->flags
& SEC_LOAD
) == 0)))
1627 /* This section won't fit in the program segment. We must
1628 create a new program header holding all the sections from
1629 phdr_index until hdr. */
1631 m
= make_mapping (abfd
, sections
, phdr_index
, i
);
1642 /* Create a final PT_LOAD program segment. */
1643 if (last_hdr
!= NULL
)
1645 m
= make_mapping (abfd
, sections
, phdr_index
, i
);
1653 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
1654 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1655 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
1657 m
= ((struct elf_segment_map
*)
1658 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
1662 m
->p_type
= PT_DYNAMIC
;
1673 elf_tdata (abfd
)->segment_map
= mfirst
;
1677 if (sections
!= NULL
)
1682 /* Sort sections by VMA. */
1685 elf_sort_sections (arg1
, arg2
)
1689 const asection
*sec1
= *(const asection
**) arg1
;
1690 const asection
*sec2
= *(const asection
**) arg2
;
1692 if (sec1
->vma
< sec2
->vma
)
1694 else if (sec1
->vma
> sec2
->vma
)
1697 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
1699 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
1703 return sec1
->target_index
- sec2
->target_index
;
1712 /* Sort by size, to put zero sized sections before others at the
1715 if (sec1
->_raw_size
< sec2
->_raw_size
)
1717 if (sec1
->_raw_size
> sec2
->_raw_size
)
1720 return sec1
->target_index
- sec2
->target_index
;
1723 /* Assign file positions to the sections based on the mapping from
1724 sections to segments. This function also sets up some fields in
1725 the file header, and writes out the program headers. */
1728 assign_file_positions_for_segments (abfd
)
1731 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1733 struct elf_segment_map
*m
;
1735 Elf_Internal_Phdr
*phdrs
;
1737 bfd_vma filehdr_vaddr
, filehdr_paddr
;
1738 bfd_vma phdrs_vaddr
, phdrs_paddr
;
1739 Elf_Internal_Phdr
*p
;
1741 if (elf_tdata (abfd
)->segment_map
== NULL
)
1743 if (! map_sections_to_segments (abfd
))
1747 if (bed
->elf_backend_modify_segment_map
)
1749 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
1754 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1757 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
1758 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
1759 elf_elfheader (abfd
)->e_phnum
= count
;
1764 /* If we already counted the number of program segments, make sure
1765 that we allocated enough space. This happens when SIZEOF_HEADERS
1766 is used in a linker script. */
1767 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
1768 if (alloc
!= 0 && count
> alloc
)
1770 ((*_bfd_error_handler
)
1771 ("%s: Not enough room for program headers (allocated %u, need %u)",
1772 bfd_get_filename (abfd
), alloc
, count
));
1773 bfd_set_error (bfd_error_bad_value
);
1780 phdrs
= ((Elf_Internal_Phdr
*)
1781 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
1785 off
= bed
->s
->sizeof_ehdr
;
1786 off
+= alloc
* bed
->s
->sizeof_phdr
;
1792 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
1799 /* If elf_segment_map is not from map_sections_to_segments, the
1800 sections may not be correctly ordered. */
1802 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
1805 p
->p_type
= m
->p_type
;
1807 if (m
->p_flags_valid
)
1808 p
->p_flags
= m
->p_flags
;
1810 if (p
->p_type
== PT_LOAD
&& m
->count
> 0)
1811 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
1816 p
->p_vaddr
= m
->sections
[0]->vma
;
1818 if (m
->p_paddr_valid
)
1819 p
->p_paddr
= m
->p_paddr
;
1820 else if (m
->count
== 0)
1823 p
->p_paddr
= m
->sections
[0]->lma
;
1825 if (p
->p_type
== PT_LOAD
)
1826 p
->p_align
= bed
->maxpagesize
;
1827 else if (m
->count
== 0)
1828 p
->p_align
= bed
->s
->file_align
;
1836 if (m
->includes_filehdr
)
1839 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
1840 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
1843 BFD_ASSERT (p
->p_type
== PT_LOAD
);
1845 if (! m
->p_paddr_valid
)
1848 if (p
->p_type
== PT_LOAD
)
1850 filehdr_vaddr
= p
->p_vaddr
;
1851 filehdr_paddr
= p
->p_paddr
;
1855 if (m
->includes_phdrs
)
1857 if (m
->includes_filehdr
)
1859 if (p
->p_type
== PT_LOAD
)
1861 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
1862 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
1867 p
->p_offset
= bed
->s
->sizeof_ehdr
;
1870 BFD_ASSERT (p
->p_type
== PT_LOAD
);
1871 p
->p_vaddr
-= off
- p
->p_offset
;
1872 if (! m
->p_paddr_valid
)
1873 p
->p_paddr
-= off
- p
->p_offset
;
1875 if (p
->p_type
== PT_LOAD
)
1877 phdrs_vaddr
= p
->p_vaddr
;
1878 phdrs_paddr
= p
->p_paddr
;
1881 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
1882 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
1885 if (p
->p_type
== PT_LOAD
)
1887 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
1893 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
1894 p
->p_filesz
+= adjust
;
1895 p
->p_memsz
+= adjust
;
1899 if (! m
->p_flags_valid
)
1901 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
1905 bfd_size_type align
;
1910 if (p
->p_type
== PT_LOAD
)
1914 /* The section VMA must equal the file position modulo
1916 adjust
= (sec
->vma
- off
) % bed
->maxpagesize
;
1921 p
->p_memsz
+= adjust
;
1922 if ((flags
& SEC_LOAD
) != 0)
1923 p
->p_filesz
+= adjust
;
1929 if ((flags
& SEC_LOAD
) != 0)
1930 off
+= sec
->_raw_size
;
1933 p
->p_memsz
+= sec
->_raw_size
;
1935 if ((flags
& SEC_LOAD
) != 0)
1936 p
->p_filesz
+= sec
->_raw_size
;
1938 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
1939 if (align
> p
->p_align
)
1942 if (! m
->p_flags_valid
)
1944 if ((flags
& SEC_CODE
) != 0)
1946 if ((flags
& SEC_READONLY
) == 0)
1952 /* Now that we have set the section file positions, we can set up
1953 the file positions for the non PT_LOAD segments. */
1954 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
1958 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
1960 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
1961 p
->p_offset
= m
->sections
[0]->filepos
;
1965 if (m
->includes_filehdr
)
1967 p
->p_vaddr
= filehdr_vaddr
;
1968 if (! m
->p_paddr_valid
)
1969 p
->p_paddr
= filehdr_paddr
;
1971 else if (m
->includes_phdrs
)
1973 p
->p_vaddr
= phdrs_vaddr
;
1974 if (! m
->p_paddr_valid
)
1975 p
->p_paddr
= phdrs_paddr
;
1980 /* Clear out any program headers we allocated but did not use. */
1981 for (; count
< alloc
; count
++, p
++)
1983 memset (p
, 0, sizeof *p
);
1984 p
->p_type
= PT_NULL
;
1987 elf_tdata (abfd
)->phdr
= phdrs
;
1989 elf_tdata (abfd
)->next_file_pos
= off
;
1991 /* Write out the program headers. */
1992 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
1993 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
1999 /* Get the size of the program header.
2001 If this is called by the linker before any of the section VMA's are set, it
2002 can't calculate the correct value for a strange memory layout. This only
2003 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2004 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2005 data segment (exclusive of .interp and .dynamic).
2007 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2008 will be two segments. */
2010 static bfd_size_type
2011 get_program_header_size (abfd
)
2016 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2018 /* We can't return a different result each time we're called. */
2019 if (elf_tdata (abfd
)->program_header_size
!= 0)
2020 return elf_tdata (abfd
)->program_header_size
;
2022 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2024 struct elf_segment_map
*m
;
2027 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2029 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2030 return elf_tdata (abfd
)->program_header_size
;
2033 /* Assume we will need exactly two PT_LOAD segments: one for text
2034 and one for data. */
2037 s
= bfd_get_section_by_name (abfd
, ".interp");
2038 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2040 /* If we have a loadable interpreter section, we need a
2041 PT_INTERP segment. In this case, assume we also need a
2042 PT_PHDR segment, although that may not be true for all
2047 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2049 /* We need a PT_DYNAMIC segment. */
2053 /* Let the backend count up any program headers it might need. */
2054 if (bed
->elf_backend_additional_program_headers
)
2058 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
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 bfd_big_endian (abfd
) ? 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
->flags
& SEC_ALLOC
) != 0
2516 && s
->output_section
!= NULL
)
2519 m
= ((struct elf_segment_map
*)
2521 (sizeof (struct elf_segment_map
)
2522 + (csecs
- 1) * sizeof (asection
*))));
2527 m
->p_type
= p
->p_type
;
2528 m
->p_flags
= p
->p_flags
;
2529 m
->p_flags_valid
= 1;
2530 m
->p_paddr
= p
->p_paddr
;
2531 m
->p_paddr_valid
= 1;
2533 m
->includes_filehdr
= (p
->p_offset
== 0
2534 && p
->p_filesz
>= iehdr
->e_ehsize
);
2536 m
->includes_phdrs
= (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
2537 && (p
->p_offset
+ p
->p_filesz
2538 >= ((bfd_vma
) iehdr
->e_phoff
2539 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
2542 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2544 if (((s
->vma
>= p
->p_vaddr
2545 && (s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_memsz
2546 || s
->vma
+ s
->_raw_size
<= p
->p_vaddr
+ p
->p_filesz
))
2549 && (s
->flags
& SEC_HAS_CONTENTS
) != 0
2550 && (bfd_vma
) s
->filepos
>= p
->p_offset
2551 && ((bfd_vma
) s
->filepos
+ s
->_raw_size
2552 <= p
->p_offset
+ p
->p_filesz
)))
2553 && (s
->flags
& SEC_ALLOC
) != 0
2554 && s
->output_section
!= NULL
)
2556 m
->sections
[isec
] = s
->output_section
;
2560 BFD_ASSERT (isec
== csecs
);
2567 elf_tdata (obfd
)->segment_map
= mfirst
;
2572 /* Copy private section information. This copies over the entsize
2573 field, and sometimes the info field. */
2576 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
2582 Elf_Internal_Shdr
*ihdr
, *ohdr
;
2584 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
2585 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
2588 /* Copy over private BFD data if it has not already been copied.
2589 This must be done here, rather than in the copy_private_bfd_data
2590 entry point, because the latter is called after the section
2591 contents have been set, which means that the program headers have
2592 already been worked out. */
2593 if (elf_tdata (obfd
)->segment_map
== NULL
2594 && elf_tdata (ibfd
)->phdr
!= NULL
)
2598 /* Only set up the segments when all the sections have been set
2600 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2601 if (s
->output_section
== NULL
)
2605 if (! copy_private_bfd_data (ibfd
, obfd
))
2610 ihdr
= &elf_section_data (isec
)->this_hdr
;
2611 ohdr
= &elf_section_data (osec
)->this_hdr
;
2613 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
2615 if (ihdr
->sh_type
== SHT_SYMTAB
2616 || ihdr
->sh_type
== SHT_DYNSYM
)
2617 ohdr
->sh_info
= ihdr
->sh_info
;
2622 /* Copy private symbol information. If this symbol is in a section
2623 which we did not map into a BFD section, try to map the section
2624 index correctly. We use special macro definitions for the mapped
2625 section indices; these definitions are interpreted by the
2626 swap_out_syms function. */
2628 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
2629 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
2630 #define MAP_STRTAB (SHN_LORESERVE - 3)
2631 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
2634 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
2640 elf_symbol_type
*isym
, *osym
;
2642 isym
= elf_symbol_from (ibfd
, isymarg
);
2643 osym
= elf_symbol_from (obfd
, osymarg
);
2647 && bfd_is_abs_section (isym
->symbol
.section
))
2651 shndx
= isym
->internal_elf_sym
.st_shndx
;
2652 if (shndx
== elf_onesymtab (ibfd
))
2653 shndx
= MAP_ONESYMTAB
;
2654 else if (shndx
== elf_dynsymtab (ibfd
))
2655 shndx
= MAP_DYNSYMTAB
;
2656 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
2658 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
2659 shndx
= MAP_SHSTRTAB
;
2660 osym
->internal_elf_sym
.st_shndx
= shndx
;
2666 /* Swap out the symbols. */
2669 swap_out_syms (abfd
, sttp
)
2671 struct bfd_strtab_hash
**sttp
;
2673 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2675 if (!elf_map_symbols (abfd
))
2678 /* Dump out the symtabs. */
2680 int symcount
= bfd_get_symcount (abfd
);
2681 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2682 struct bfd_strtab_hash
*stt
;
2683 Elf_Internal_Shdr
*symtab_hdr
;
2684 Elf_Internal_Shdr
*symstrtab_hdr
;
2685 char *outbound_syms
;
2688 stt
= _bfd_elf_stringtab_init ();
2692 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2693 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2694 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
2695 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2696 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2697 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
2699 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2700 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2702 outbound_syms
= bfd_alloc (abfd
,
2703 (1 + symcount
) * bed
->s
->sizeof_sym
);
2704 if (outbound_syms
== NULL
)
2706 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2708 /* now generate the data (for "contents") */
2710 /* Fill in zeroth symbol and swap it out. */
2711 Elf_Internal_Sym sym
;
2717 sym
.st_shndx
= SHN_UNDEF
;
2718 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2719 outbound_syms
+= bed
->s
->sizeof_sym
;
2721 for (idx
= 0; idx
< symcount
; idx
++)
2723 Elf_Internal_Sym sym
;
2724 bfd_vma value
= syms
[idx
]->value
;
2725 elf_symbol_type
*type_ptr
;
2726 flagword flags
= syms
[idx
]->flags
;
2728 if (flags
& BSF_SECTION_SYM
)
2729 /* Section symbols have no names. */
2733 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
2736 if (sym
.st_name
== (unsigned long) -1)
2740 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2742 if (bfd_is_com_section (syms
[idx
]->section
))
2744 /* ELF common symbols put the alignment into the `value' field,
2745 and the size into the `size' field. This is backwards from
2746 how BFD handles it, so reverse it here. */
2747 sym
.st_size
= value
;
2748 if (type_ptr
== NULL
2749 || type_ptr
->internal_elf_sym
.st_value
== 0)
2750 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
2752 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
2753 sym
.st_shndx
= _bfd_elf_section_from_bfd_section (abfd
,
2754 syms
[idx
]->section
);
2758 asection
*sec
= syms
[idx
]->section
;
2761 if (sec
->output_section
)
2763 value
+= sec
->output_offset
;
2764 sec
= sec
->output_section
;
2767 sym
.st_value
= value
;
2768 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2770 if (bfd_is_abs_section (sec
)
2772 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
2774 /* This symbol is in a real ELF section which we did
2775 not create as a BFD section. Undo the mapping done
2776 by copy_private_symbol_data. */
2777 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
2781 shndx
= elf_onesymtab (abfd
);
2784 shndx
= elf_dynsymtab (abfd
);
2787 shndx
= elf_tdata (abfd
)->strtab_section
;
2790 shndx
= elf_tdata (abfd
)->shstrtab_section
;
2798 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2804 /* Writing this would be a hell of a lot easier if
2805 we had some decent documentation on bfd, and
2806 knew what to expect of the library, and what to
2807 demand of applications. For example, it
2808 appears that `objcopy' might not set the
2809 section of a symbol to be a section that is
2810 actually in the output file. */
2811 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2812 BFD_ASSERT (sec2
!= 0);
2813 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
2814 BFD_ASSERT (shndx
!= -1);
2818 sym
.st_shndx
= shndx
;
2821 if (bfd_is_com_section (syms
[idx
]->section
))
2822 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2823 else if (bfd_is_und_section (syms
[idx
]->section
))
2824 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
2827 ((flags
& BSF_FUNCTION
)
2830 else if (flags
& BSF_SECTION_SYM
)
2831 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2832 else if (flags
& BSF_FILE
)
2833 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2836 int bind
= STB_LOCAL
;
2837 int type
= STT_OBJECT
;
2839 if (flags
& BSF_LOCAL
)
2841 else if (flags
& BSF_WEAK
)
2843 else if (flags
& BSF_GLOBAL
)
2846 if (flags
& BSF_FUNCTION
)
2849 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2853 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
2854 outbound_syms
+= bed
->s
->sizeof_sym
;
2858 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
2859 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2861 symstrtab_hdr
->sh_flags
= 0;
2862 symstrtab_hdr
->sh_addr
= 0;
2863 symstrtab_hdr
->sh_entsize
= 0;
2864 symstrtab_hdr
->sh_link
= 0;
2865 symstrtab_hdr
->sh_info
= 0;
2866 symstrtab_hdr
->sh_addralign
= 1;
2872 /* Return the number of bytes required to hold the symtab vector.
2874 Note that we base it on the count plus 1, since we will null terminate
2875 the vector allocated based on this size. However, the ELF symbol table
2876 always has a dummy entry as symbol #0, so it ends up even. */
2879 _bfd_elf_get_symtab_upper_bound (abfd
)
2884 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2886 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2887 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2893 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
2898 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
2900 if (elf_dynsymtab (abfd
) == 0)
2902 bfd_set_error (bfd_error_invalid_operation
);
2906 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
2907 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2913 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
2917 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2920 /* Canonicalize the relocs. */
2923 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2932 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
, section
, symbols
))
2935 tblptr
= section
->relocation
;
2936 for (i
= 0; i
< section
->reloc_count
; i
++)
2937 *relptr
++ = tblptr
++;
2941 return section
->reloc_count
;
2945 _bfd_elf_get_symtab (abfd
, alocation
)
2947 asymbol
**alocation
;
2949 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, false);
2952 bfd_get_symcount (abfd
) = symcount
;
2957 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
2959 asymbol
**alocation
;
2961 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table (abfd
, alocation
, true);
2965 _bfd_elf_make_empty_symbol (abfd
)
2968 elf_symbol_type
*newsym
;
2970 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
2975 newsym
->symbol
.the_bfd
= abfd
;
2976 return &newsym
->symbol
;
2981 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
2986 bfd_symbol_info (symbol
, ret
);
2990 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
2999 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
3001 enum bfd_architecture arch
;
3002 unsigned long machine
;
3004 /* If this isn't the right architecture for this backend, and this
3005 isn't the generic backend, fail. */
3006 if (arch
!= get_elf_backend_data (abfd
)->arch
3007 && arch
!= bfd_arch_unknown
3008 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
3011 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3014 /* Find the nearest line to a particular section and offset, for error
3018 _bfd_elf_find_nearest_line (abfd
,
3029 CONST
char **filename_ptr
;
3030 CONST
char **functionname_ptr
;
3031 unsigned int *line_ptr
;
3033 const char *filename
;
3037 if (symbols
== NULL
)
3043 for (p
= symbols
; *p
!= NULL
; p
++)
3047 q
= (elf_symbol_type
*) *p
;
3049 if (bfd_get_section (&q
->symbol
) != section
)
3052 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
3057 filename
= bfd_asymbol_name (&q
->symbol
);
3061 || q
->symbol
.value
<= offset
)
3062 func
= (asymbol
*) q
;
3070 *filename_ptr
= filename
;
3071 *functionname_ptr
= bfd_asymbol_name (func
);
3077 _bfd_elf_sizeof_headers (abfd
, reloc
)
3083 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
3085 ret
+= get_program_header_size (abfd
);
3090 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3095 bfd_size_type count
;
3097 Elf_Internal_Shdr
*hdr
;
3099 if (! abfd
->output_has_begun
3100 && ! _bfd_elf_compute_section_file_positions (abfd
,
3101 (struct bfd_link_info
*) NULL
))
3104 hdr
= &elf_section_data (section
)->this_hdr
;
3106 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3108 if (bfd_write (location
, 1, count
, abfd
) != count
)
3115 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3118 Elf_Internal_Rela
*dst
;
3125 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3128 Elf_Internal_Rel
*dst
;