1 /* ELF executable support for BFD.
2 Copyright 1993, 94, 95, 96, 97, 98, 1999 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, boolean
));
43 static boolean map_sections_to_segments
PARAMS ((bfd
*));
44 static int elf_sort_sections
PARAMS ((const PTR
, const PTR
));
45 static boolean assign_file_positions_for_segments
PARAMS ((bfd
*));
46 static boolean assign_file_positions_except_relocs
PARAMS ((bfd
*));
47 static boolean prep_headers
PARAMS ((bfd
*));
48 static boolean swap_out_syms
PARAMS ((bfd
*, struct bfd_strtab_hash
**, int));
49 static boolean copy_private_bfd_data
PARAMS ((bfd
*, bfd
*));
50 static char *elf_read
PARAMS ((bfd
*, long, unsigned int));
51 static void elf_fake_sections
PARAMS ((bfd
*, asection
*, PTR
));
52 static boolean assign_section_numbers
PARAMS ((bfd
*));
53 static INLINE
int sym_is_global
PARAMS ((bfd
*, asymbol
*));
54 static boolean elf_map_symbols
PARAMS ((bfd
*));
55 static bfd_size_type get_program_header_size
PARAMS ((bfd
*));
57 /* Swap version information in and out. The version information is
58 currently size independent. If that ever changes, this code will
59 need to move into elfcode.h. */
61 /* Swap in a Verdef structure. */
64 _bfd_elf_swap_verdef_in (abfd
, src
, dst
)
66 const Elf_External_Verdef
*src
;
67 Elf_Internal_Verdef
*dst
;
69 dst
->vd_version
= bfd_h_get_16 (abfd
, src
->vd_version
);
70 dst
->vd_flags
= bfd_h_get_16 (abfd
, src
->vd_flags
);
71 dst
->vd_ndx
= bfd_h_get_16 (abfd
, src
->vd_ndx
);
72 dst
->vd_cnt
= bfd_h_get_16 (abfd
, src
->vd_cnt
);
73 dst
->vd_hash
= bfd_h_get_32 (abfd
, src
->vd_hash
);
74 dst
->vd_aux
= bfd_h_get_32 (abfd
, src
->vd_aux
);
75 dst
->vd_next
= bfd_h_get_32 (abfd
, src
->vd_next
);
78 /* Swap out a Verdef structure. */
81 _bfd_elf_swap_verdef_out (abfd
, src
, dst
)
83 const Elf_Internal_Verdef
*src
;
84 Elf_External_Verdef
*dst
;
86 bfd_h_put_16 (abfd
, src
->vd_version
, dst
->vd_version
);
87 bfd_h_put_16 (abfd
, src
->vd_flags
, dst
->vd_flags
);
88 bfd_h_put_16 (abfd
, src
->vd_ndx
, dst
->vd_ndx
);
89 bfd_h_put_16 (abfd
, src
->vd_cnt
, dst
->vd_cnt
);
90 bfd_h_put_32 (abfd
, src
->vd_hash
, dst
->vd_hash
);
91 bfd_h_put_32 (abfd
, src
->vd_aux
, dst
->vd_aux
);
92 bfd_h_put_32 (abfd
, src
->vd_next
, dst
->vd_next
);
95 /* Swap in a Verdaux structure. */
98 _bfd_elf_swap_verdaux_in (abfd
, src
, dst
)
100 const Elf_External_Verdaux
*src
;
101 Elf_Internal_Verdaux
*dst
;
103 dst
->vda_name
= bfd_h_get_32 (abfd
, src
->vda_name
);
104 dst
->vda_next
= bfd_h_get_32 (abfd
, src
->vda_next
);
107 /* Swap out a Verdaux structure. */
110 _bfd_elf_swap_verdaux_out (abfd
, src
, dst
)
112 const Elf_Internal_Verdaux
*src
;
113 Elf_External_Verdaux
*dst
;
115 bfd_h_put_32 (abfd
, src
->vda_name
, dst
->vda_name
);
116 bfd_h_put_32 (abfd
, src
->vda_next
, dst
->vda_next
);
119 /* Swap in a Verneed structure. */
122 _bfd_elf_swap_verneed_in (abfd
, src
, dst
)
124 const Elf_External_Verneed
*src
;
125 Elf_Internal_Verneed
*dst
;
127 dst
->vn_version
= bfd_h_get_16 (abfd
, src
->vn_version
);
128 dst
->vn_cnt
= bfd_h_get_16 (abfd
, src
->vn_cnt
);
129 dst
->vn_file
= bfd_h_get_32 (abfd
, src
->vn_file
);
130 dst
->vn_aux
= bfd_h_get_32 (abfd
, src
->vn_aux
);
131 dst
->vn_next
= bfd_h_get_32 (abfd
, src
->vn_next
);
134 /* Swap out a Verneed structure. */
137 _bfd_elf_swap_verneed_out (abfd
, src
, dst
)
139 const Elf_Internal_Verneed
*src
;
140 Elf_External_Verneed
*dst
;
142 bfd_h_put_16 (abfd
, src
->vn_version
, dst
->vn_version
);
143 bfd_h_put_16 (abfd
, src
->vn_cnt
, dst
->vn_cnt
);
144 bfd_h_put_32 (abfd
, src
->vn_file
, dst
->vn_file
);
145 bfd_h_put_32 (abfd
, src
->vn_aux
, dst
->vn_aux
);
146 bfd_h_put_32 (abfd
, src
->vn_next
, dst
->vn_next
);
149 /* Swap in a Vernaux structure. */
152 _bfd_elf_swap_vernaux_in (abfd
, src
, dst
)
154 const Elf_External_Vernaux
*src
;
155 Elf_Internal_Vernaux
*dst
;
157 dst
->vna_hash
= bfd_h_get_32 (abfd
, src
->vna_hash
);
158 dst
->vna_flags
= bfd_h_get_16 (abfd
, src
->vna_flags
);
159 dst
->vna_other
= bfd_h_get_16 (abfd
, src
->vna_other
);
160 dst
->vna_name
= bfd_h_get_32 (abfd
, src
->vna_name
);
161 dst
->vna_next
= bfd_h_get_32 (abfd
, src
->vna_next
);
164 /* Swap out a Vernaux structure. */
167 _bfd_elf_swap_vernaux_out (abfd
, src
, dst
)
169 const Elf_Internal_Vernaux
*src
;
170 Elf_External_Vernaux
*dst
;
172 bfd_h_put_32 (abfd
, src
->vna_hash
, dst
->vna_hash
);
173 bfd_h_put_16 (abfd
, src
->vna_flags
, dst
->vna_flags
);
174 bfd_h_put_16 (abfd
, src
->vna_other
, dst
->vna_other
);
175 bfd_h_put_32 (abfd
, src
->vna_name
, dst
->vna_name
);
176 bfd_h_put_32 (abfd
, src
->vna_next
, dst
->vna_next
);
179 /* Swap in a Versym structure. */
182 _bfd_elf_swap_versym_in (abfd
, src
, dst
)
184 const Elf_External_Versym
*src
;
185 Elf_Internal_Versym
*dst
;
187 dst
->vs_vers
= bfd_h_get_16 (abfd
, src
->vs_vers
);
190 /* Swap out a Versym structure. */
193 _bfd_elf_swap_versym_out (abfd
, src
, dst
)
195 const Elf_Internal_Versym
*src
;
196 Elf_External_Versym
*dst
;
198 bfd_h_put_16 (abfd
, src
->vs_vers
, dst
->vs_vers
);
201 /* Standard ELF hash function. Do not change this function; you will
202 cause invalid hash tables to be generated. */
205 bfd_elf_hash (namearg
)
208 const unsigned char *name
= (const unsigned char *) namearg
;
213 while ((ch
= *name
++) != '\0')
216 if ((g
= (h
& 0xf0000000)) != 0)
219 /* The ELF ABI says `h &= ~g', but this is equivalent in
220 this case and on some machines one insn instead of two. */
227 /* Read a specified number of bytes at a specified offset in an ELF
228 file, into a newly allocated buffer, and return a pointer to the
232 elf_read (abfd
, offset
, size
)
239 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
241 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
243 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
245 if (bfd_get_error () != bfd_error_system_call
)
246 bfd_set_error (bfd_error_file_truncated
);
253 bfd_elf_mkobject (abfd
)
256 /* this just does initialization */
257 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
258 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
259 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
260 if (elf_tdata (abfd
) == 0)
262 /* since everything is done at close time, do we need any
269 bfd_elf_mkcorefile (abfd
)
272 /* I think this can be done just like an object file. */
273 return bfd_elf_mkobject (abfd
);
277 bfd_elf_get_str_section (abfd
, shindex
)
279 unsigned int shindex
;
281 Elf_Internal_Shdr
**i_shdrp
;
282 char *shstrtab
= NULL
;
284 unsigned int shstrtabsize
;
286 i_shdrp
= elf_elfsections (abfd
);
287 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
290 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
291 if (shstrtab
== NULL
)
293 /* No cached one, attempt to read, and cache what we read. */
294 offset
= i_shdrp
[shindex
]->sh_offset
;
295 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
296 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
297 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
303 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
305 unsigned int shindex
;
306 unsigned int strindex
;
308 Elf_Internal_Shdr
*hdr
;
313 hdr
= elf_elfsections (abfd
)[shindex
];
315 if (hdr
->contents
== NULL
316 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
319 if (strindex
>= hdr
->sh_size
)
321 (*_bfd_error_handler
)
322 (_("%s: invalid string offset %u >= %lu for section `%s'"),
323 bfd_get_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
324 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
325 && strindex
== hdr
->sh_name
)
327 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
331 return ((char *) hdr
->contents
) + strindex
;
334 /* Make a BFD section from an ELF section. We store a pointer to the
335 BFD section in the bfd_section field of the header. */
338 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
340 Elf_Internal_Shdr
*hdr
;
346 if (hdr
->bfd_section
!= NULL
)
348 BFD_ASSERT (strcmp (name
,
349 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
353 newsect
= bfd_make_section_anyway (abfd
, name
);
357 newsect
->filepos
= hdr
->sh_offset
;
359 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
360 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
361 || ! bfd_set_section_alignment (abfd
, newsect
,
362 bfd_log2 (hdr
->sh_addralign
)))
365 flags
= SEC_NO_FLAGS
;
366 if (hdr
->sh_type
!= SHT_NOBITS
)
367 flags
|= SEC_HAS_CONTENTS
;
368 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
371 if (hdr
->sh_type
!= SHT_NOBITS
)
374 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
375 flags
|= SEC_READONLY
;
376 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
378 else if ((flags
& SEC_LOAD
) != 0)
381 /* The debugging sections appear to be recognized only by name, not
383 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
384 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
385 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
386 flags
|= SEC_DEBUGGING
;
388 /* As a GNU extension, if the name begins with .gnu.linkonce, we
389 only link a single copy of the section. This is used to support
390 g++. g++ will emit each template expansion in its own section.
391 The symbols will be defined as weak, so that multiple definitions
392 are permitted. The GNU linker extension is to actually discard
393 all but one of the sections. */
394 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
395 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
397 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
400 if ((flags
& SEC_ALLOC
) != 0)
402 Elf_Internal_Phdr
*phdr
;
405 /* Look through the phdrs to see if we need to adjust the lma.
406 If all the p_paddr fields are zero, we ignore them, since
407 some ELF linkers produce such output. */
408 phdr
= elf_tdata (abfd
)->phdr
;
409 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
411 if (phdr
->p_paddr
!= 0)
414 if (i
< elf_elfheader (abfd
)->e_phnum
)
416 phdr
= elf_tdata (abfd
)->phdr
;
417 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
419 if (phdr
->p_type
== PT_LOAD
420 && phdr
->p_vaddr
!= phdr
->p_paddr
421 && phdr
->p_vaddr
<= hdr
->sh_addr
422 && (phdr
->p_vaddr
+ phdr
->p_memsz
423 >= hdr
->sh_addr
+ hdr
->sh_size
)
424 && ((flags
& SEC_LOAD
) == 0
425 || (phdr
->p_offset
<= (bfd_vma
) hdr
->sh_offset
426 && (phdr
->p_offset
+ phdr
->p_filesz
427 >= hdr
->sh_offset
+ hdr
->sh_size
))))
429 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
436 hdr
->bfd_section
= newsect
;
437 elf_section_data (newsect
)->this_hdr
= *hdr
;
447 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
450 Helper functions for GDB to locate the string tables.
451 Since BFD hides string tables from callers, GDB needs to use an
452 internal hook to find them. Sun's .stabstr, in particular,
453 isn't even pointed to by the .stab section, so ordinary
454 mechanisms wouldn't work to find it, even if we had some.
457 struct elf_internal_shdr
*
458 bfd_elf_find_section (abfd
, name
)
462 Elf_Internal_Shdr
**i_shdrp
;
467 i_shdrp
= elf_elfsections (abfd
);
470 shstrtab
= bfd_elf_get_str_section
471 (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
472 if (shstrtab
!= NULL
)
474 max
= elf_elfheader (abfd
)->e_shnum
;
475 for (i
= 1; i
< max
; i
++)
476 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
483 const char *const bfd_elf_section_type_names
[] = {
484 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
485 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
486 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
489 /* ELF relocs are against symbols. If we are producing relocateable
490 output, and the reloc is against an external symbol, and nothing
491 has given us any additional addend, the resulting reloc will also
492 be against the same symbol. In such a case, we don't want to
493 change anything about the way the reloc is handled, since it will
494 all be done at final link time. Rather than put special case code
495 into bfd_perform_relocation, all the reloc types use this howto
496 function. It just short circuits the reloc if producing
497 relocateable output against an external symbol. */
500 bfd_reloc_status_type
501 bfd_elf_generic_reloc (abfd
,
508 bfd
*abfd ATTRIBUTE_UNUSED
;
509 arelent
*reloc_entry
;
511 PTR data ATTRIBUTE_UNUSED
;
512 asection
*input_section
;
514 char **error_message ATTRIBUTE_UNUSED
;
516 if (output_bfd
!= (bfd
*) NULL
517 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
518 && (! reloc_entry
->howto
->partial_inplace
519 || reloc_entry
->addend
== 0))
521 reloc_entry
->address
+= input_section
->output_offset
;
525 return bfd_reloc_continue
;
528 /* Print out the program headers. */
531 _bfd_elf_print_private_bfd_data (abfd
, farg
)
535 FILE *f
= (FILE *) farg
;
536 Elf_Internal_Phdr
*p
;
538 bfd_byte
*dynbuf
= NULL
;
540 p
= elf_tdata (abfd
)->phdr
;
545 fprintf (f
, _("\nProgram Header:\n"));
546 c
= elf_elfheader (abfd
)->e_phnum
;
547 for (i
= 0; i
< c
; i
++, p
++)
554 case PT_NULL
: s
= "NULL"; break;
555 case PT_LOAD
: s
= "LOAD"; break;
556 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
557 case PT_INTERP
: s
= "INTERP"; break;
558 case PT_NOTE
: s
= "NOTE"; break;
559 case PT_SHLIB
: s
= "SHLIB"; break;
560 case PT_PHDR
: s
= "PHDR"; break;
561 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
563 fprintf (f
, "%8s off 0x", s
);
564 fprintf_vma (f
, p
->p_offset
);
565 fprintf (f
, " vaddr 0x");
566 fprintf_vma (f
, p
->p_vaddr
);
567 fprintf (f
, " paddr 0x");
568 fprintf_vma (f
, p
->p_paddr
);
569 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
570 fprintf (f
, " filesz 0x");
571 fprintf_vma (f
, p
->p_filesz
);
572 fprintf (f
, " memsz 0x");
573 fprintf_vma (f
, p
->p_memsz
);
574 fprintf (f
, " flags %c%c%c",
575 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
576 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
577 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
578 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
579 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
584 s
= bfd_get_section_by_name (abfd
, ".dynamic");
589 bfd_byte
*extdyn
, *extdynend
;
591 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
593 fprintf (f
, _("\nDynamic Section:\n"));
595 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
598 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
602 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
605 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
607 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
608 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
611 extdynend
= extdyn
+ s
->_raw_size
;
612 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
614 Elf_Internal_Dyn dyn
;
619 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
621 if (dyn
.d_tag
== DT_NULL
)
628 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
632 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
633 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
634 case DT_PLTGOT
: name
= "PLTGOT"; break;
635 case DT_HASH
: name
= "HASH"; break;
636 case DT_STRTAB
: name
= "STRTAB"; break;
637 case DT_SYMTAB
: name
= "SYMTAB"; break;
638 case DT_RELA
: name
= "RELA"; break;
639 case DT_RELASZ
: name
= "RELASZ"; break;
640 case DT_RELAENT
: name
= "RELAENT"; break;
641 case DT_STRSZ
: name
= "STRSZ"; break;
642 case DT_SYMENT
: name
= "SYMENT"; break;
643 case DT_INIT
: name
= "INIT"; break;
644 case DT_FINI
: name
= "FINI"; break;
645 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
646 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
647 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
648 case DT_REL
: name
= "REL"; break;
649 case DT_RELSZ
: name
= "RELSZ"; break;
650 case DT_RELENT
: name
= "RELENT"; break;
651 case DT_PLTREL
: name
= "PLTREL"; break;
652 case DT_DEBUG
: name
= "DEBUG"; break;
653 case DT_TEXTREL
: name
= "TEXTREL"; break;
654 case DT_JMPREL
: name
= "JMPREL"; break;
655 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
656 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
657 case DT_VERSYM
: name
= "VERSYM"; break;
658 case DT_VERDEF
: name
= "VERDEF"; break;
659 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
660 case DT_VERNEED
: name
= "VERNEED"; break;
661 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
664 fprintf (f
, " %-11s ", name
);
666 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
671 string
= bfd_elf_string_from_elf_section (abfd
, link
,
675 fprintf (f
, "%s", string
);
684 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
685 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
687 if (! _bfd_elf_slurp_version_tables (abfd
))
691 if (elf_dynverdef (abfd
) != 0)
693 Elf_Internal_Verdef
*t
;
695 fprintf (f
, _("\nVersion definitions:\n"));
696 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
698 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
699 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
700 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
702 Elf_Internal_Verdaux
*a
;
705 for (a
= t
->vd_auxptr
->vda_nextptr
;
708 fprintf (f
, "%s ", a
->vda_nodename
);
714 if (elf_dynverref (abfd
) != 0)
716 Elf_Internal_Verneed
*t
;
718 fprintf (f
, _("\nVersion References:\n"));
719 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
721 Elf_Internal_Vernaux
*a
;
723 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
724 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
725 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
726 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
738 /* Display ELF-specific fields of a symbol. */
741 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
745 bfd_print_symbol_type how
;
747 FILE *file
= (FILE *) filep
;
750 case bfd_print_symbol_name
:
751 fprintf (file
, "%s", symbol
->name
);
753 case bfd_print_symbol_more
:
754 fprintf (file
, "elf ");
755 fprintf_vma (file
, symbol
->value
);
756 fprintf (file
, " %lx", (long) symbol
->flags
);
758 case bfd_print_symbol_all
:
760 CONST
char *section_name
;
761 CONST
char *name
= NULL
;
762 struct elf_backend_data
*bed
;
764 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
766 bed
= get_elf_backend_data (abfd
);
767 if (bed
->elf_backend_print_symbol_all
)
768 name
= (*bed
->elf_backend_print_symbol_all
) (abfd
, filep
, symbol
);
773 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
776 fprintf (file
, " %s\t", section_name
);
777 /* Print the "other" value for a symbol. For common symbols,
778 we've already printed the size; now print the alignment.
779 For other symbols, we have no specified alignment, and
780 we've printed the address; now print the size. */
782 (bfd_is_com_section (symbol
->section
)
783 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
784 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
786 /* If we have version information, print it. */
787 if (elf_tdata (abfd
)->dynversym_section
!= 0
788 && (elf_tdata (abfd
)->dynverdef_section
!= 0
789 || elf_tdata (abfd
)->dynverref_section
!= 0))
792 const char *version_string
;
794 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
798 else if (vernum
== 1)
799 version_string
= "Base";
800 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
802 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
805 Elf_Internal_Verneed
*t
;
808 for (t
= elf_tdata (abfd
)->verref
;
812 Elf_Internal_Vernaux
*a
;
814 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
816 if (a
->vna_other
== vernum
)
818 version_string
= a
->vna_nodename
;
825 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
826 fprintf (file
, " %-11s", version_string
);
831 fprintf (file
, " (%s)", version_string
);
832 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
837 /* If the st_other field is not zero, print it. */
838 if (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
!= 0)
839 fprintf (file
, " 0x%02x",
841 ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
));
843 fprintf (file
, " %s", name
);
849 /* Create an entry in an ELF linker hash table. */
851 struct bfd_hash_entry
*
852 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
853 struct bfd_hash_entry
*entry
;
854 struct bfd_hash_table
*table
;
857 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
859 /* Allocate the structure if it has not already been allocated by a
861 if (ret
== (struct elf_link_hash_entry
*) NULL
)
862 ret
= ((struct elf_link_hash_entry
*)
863 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
864 if (ret
== (struct elf_link_hash_entry
*) NULL
)
865 return (struct bfd_hash_entry
*) ret
;
867 /* Call the allocation method of the superclass. */
868 ret
= ((struct elf_link_hash_entry
*)
869 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
871 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
873 /* Set local fields. */
877 ret
->dynstr_index
= 0;
879 ret
->got
.offset
= (bfd_vma
) -1;
880 ret
->plt
.offset
= (bfd_vma
) -1;
881 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
882 ret
->verinfo
.verdef
= NULL
;
883 ret
->vtable_entries_used
= NULL
;
884 ret
->vtable_entries_size
= 0;
885 ret
->vtable_parent
= NULL
;
886 ret
->type
= STT_NOTYPE
;
888 /* Assume that we have been called by a non-ELF symbol reader.
889 This flag is then reset by the code which reads an ELF input
890 file. This ensures that a symbol created by a non-ELF symbol
891 reader will have the flag set correctly. */
892 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
895 return (struct bfd_hash_entry
*) ret
;
898 /* Initialize an ELF linker hash table. */
901 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
902 struct elf_link_hash_table
*table
;
904 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
905 struct bfd_hash_table
*,
908 table
->dynamic_sections_created
= false;
909 table
->dynobj
= NULL
;
910 /* The first dynamic symbol is a dummy. */
911 table
->dynsymcount
= 1;
912 table
->dynstr
= NULL
;
913 table
->bucketcount
= 0;
914 table
->needed
= NULL
;
916 table
->stab_info
= NULL
;
917 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
920 /* Create an ELF linker hash table. */
922 struct bfd_link_hash_table
*
923 _bfd_elf_link_hash_table_create (abfd
)
926 struct elf_link_hash_table
*ret
;
928 ret
= ((struct elf_link_hash_table
*)
929 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
930 if (ret
== (struct elf_link_hash_table
*) NULL
)
933 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
935 bfd_release (abfd
, ret
);
942 /* This is a hook for the ELF emulation code in the generic linker to
943 tell the backend linker what file name to use for the DT_NEEDED
944 entry for a dynamic object. The generic linker passes name as an
945 empty string to indicate that no DT_NEEDED entry should be made. */
948 bfd_elf_set_dt_needed_name (abfd
, name
)
952 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
953 && bfd_get_format (abfd
) == bfd_object
)
954 elf_dt_name (abfd
) = name
;
957 /* Get the list of DT_NEEDED entries for a link. This is a hook for
958 the linker ELF emulation code. */
960 struct bfd_link_needed_list
*
961 bfd_elf_get_needed_list (abfd
, info
)
962 bfd
*abfd ATTRIBUTE_UNUSED
;
963 struct bfd_link_info
*info
;
965 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
967 return elf_hash_table (info
)->needed
;
970 /* Get the name actually used for a dynamic object for a link. This
971 is the SONAME entry if there is one. Otherwise, it is the string
972 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
975 bfd_elf_get_dt_soname (abfd
)
978 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
979 && bfd_get_format (abfd
) == bfd_object
)
980 return elf_dt_name (abfd
);
984 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
985 the ELF linker emulation code. */
988 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
990 struct bfd_link_needed_list
**pneeded
;
993 bfd_byte
*dynbuf
= NULL
;
996 bfd_byte
*extdyn
, *extdynend
;
998 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
1002 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1003 || bfd_get_format (abfd
) != bfd_object
)
1006 s
= bfd_get_section_by_name (abfd
, ".dynamic");
1007 if (s
== NULL
|| s
->_raw_size
== 0)
1010 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
1014 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1018 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1022 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1024 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1025 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1028 extdynend
= extdyn
+ s
->_raw_size
;
1029 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1031 Elf_Internal_Dyn dyn
;
1033 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1035 if (dyn
.d_tag
== DT_NULL
)
1038 if (dyn
.d_tag
== DT_NEEDED
)
1041 struct bfd_link_needed_list
*l
;
1043 string
= bfd_elf_string_from_elf_section (abfd
, link
,
1048 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof *l
);
1069 /* Allocate an ELF string table--force the first byte to be zero. */
1071 struct bfd_strtab_hash
*
1072 _bfd_elf_stringtab_init ()
1074 struct bfd_strtab_hash
*ret
;
1076 ret
= _bfd_stringtab_init ();
1081 loc
= _bfd_stringtab_add (ret
, "", true, false);
1082 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1083 if (loc
== (bfd_size_type
) -1)
1085 _bfd_stringtab_free (ret
);
1092 /* ELF .o/exec file reading */
1094 /* Create a new bfd section from an ELF section header. */
1097 bfd_section_from_shdr (abfd
, shindex
)
1099 unsigned int shindex
;
1101 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1102 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1103 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1106 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1108 switch (hdr
->sh_type
)
1111 /* Inactive section. Throw it away. */
1114 case SHT_PROGBITS
: /* Normal section with contents. */
1115 case SHT_DYNAMIC
: /* Dynamic linking information. */
1116 case SHT_NOBITS
: /* .bss section. */
1117 case SHT_HASH
: /* .hash section. */
1118 case SHT_NOTE
: /* .note section. */
1119 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1121 case SHT_SYMTAB
: /* A symbol table */
1122 if (elf_onesymtab (abfd
) == shindex
)
1125 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1126 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1127 elf_onesymtab (abfd
) = shindex
;
1128 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1129 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1130 abfd
->flags
|= HAS_SYMS
;
1132 /* Sometimes a shared object will map in the symbol table. If
1133 SHF_ALLOC is set, and this is a shared object, then we also
1134 treat this section as a BFD section. We can not base the
1135 decision purely on SHF_ALLOC, because that flag is sometimes
1136 set in a relocateable object file, which would confuse the
1138 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1139 && (abfd
->flags
& DYNAMIC
) != 0
1140 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1145 case SHT_DYNSYM
: /* A dynamic symbol table */
1146 if (elf_dynsymtab (abfd
) == shindex
)
1149 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1150 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1151 elf_dynsymtab (abfd
) = shindex
;
1152 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1153 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1154 abfd
->flags
|= HAS_SYMS
;
1156 /* Besides being a symbol table, we also treat this as a regular
1157 section, so that objcopy can handle it. */
1158 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1160 case SHT_STRTAB
: /* A string table */
1161 if (hdr
->bfd_section
!= NULL
)
1163 if (ehdr
->e_shstrndx
== shindex
)
1165 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1166 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1172 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
1174 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1175 if (hdr2
->sh_link
== shindex
)
1177 if (! bfd_section_from_shdr (abfd
, i
))
1179 if (elf_onesymtab (abfd
) == i
)
1181 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1182 elf_elfsections (abfd
)[shindex
] =
1183 &elf_tdata (abfd
)->strtab_hdr
;
1186 if (elf_dynsymtab (abfd
) == i
)
1188 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1189 elf_elfsections (abfd
)[shindex
] = hdr
=
1190 &elf_tdata (abfd
)->dynstrtab_hdr
;
1191 /* We also treat this as a regular section, so
1192 that objcopy can handle it. */
1195 #if 0 /* Not handling other string tables specially right now. */
1196 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1197 /* We have a strtab for some random other section. */
1198 newsect
= (asection
*) hdr2
->bfd_section
;
1201 hdr
->bfd_section
= newsect
;
1202 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1204 elf_elfsections (abfd
)[shindex
] = hdr2
;
1210 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1214 /* *These* do a lot of work -- but build no sections! */
1216 asection
*target_sect
;
1217 Elf_Internal_Shdr
*hdr2
;
1219 /* Check for a bogus link to avoid crashing. */
1220 if (hdr
->sh_link
>= ehdr
->e_shnum
)
1222 ((*_bfd_error_handler
)
1223 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1224 bfd_get_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1225 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1228 /* For some incomprehensible reason Oracle distributes
1229 libraries for Solaris in which some of the objects have
1230 bogus sh_link fields. It would be nice if we could just
1231 reject them, but, unfortunately, some people need to use
1232 them. We scan through the section headers; if we find only
1233 one suitable symbol table, we clobber the sh_link to point
1234 to it. I hope this doesn't break anything. */
1235 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1236 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1242 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1244 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1245 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1256 hdr
->sh_link
= found
;
1259 /* Get the symbol table. */
1260 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1261 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1264 /* If this reloc section does not use the main symbol table we
1265 don't treat it as a reloc section. BFD can't adequately
1266 represent such a section, so at least for now, we don't
1267 try. We just present it as a normal section. */
1268 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
1269 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1271 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1273 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1274 if (target_sect
== NULL
)
1277 if ((target_sect
->flags
& SEC_RELOC
) == 0
1278 || target_sect
->reloc_count
== 0)
1279 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1282 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1283 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1284 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1287 elf_elfsections (abfd
)[shindex
] = hdr2
;
1288 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1289 target_sect
->flags
|= SEC_RELOC
;
1290 target_sect
->relocation
= NULL
;
1291 target_sect
->rel_filepos
= hdr
->sh_offset
;
1292 /* In the section to which the relocations apply, mark whether
1293 its relocations are of the REL or RELA variety. */
1294 elf_section_data (target_sect
)->use_rela_p
1295 = (hdr
->sh_type
== SHT_RELA
);
1296 abfd
->flags
|= HAS_RELOC
;
1301 case SHT_GNU_verdef
:
1302 elf_dynverdef (abfd
) = shindex
;
1303 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1304 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1307 case SHT_GNU_versym
:
1308 elf_dynversym (abfd
) = shindex
;
1309 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1310 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1313 case SHT_GNU_verneed
:
1314 elf_dynverref (abfd
) = shindex
;
1315 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1316 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1323 /* Check for any processor-specific section types. */
1325 if (bed
->elf_backend_section_from_shdr
)
1326 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1334 /* Given an ELF section number, retrieve the corresponding BFD
1338 bfd_section_from_elf_index (abfd
, index
)
1342 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1343 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1345 return elf_elfsections (abfd
)[index
]->bfd_section
;
1349 _bfd_elf_new_section_hook (abfd
, sec
)
1353 struct bfd_elf_section_data
*sdata
;
1355 sdata
= (struct bfd_elf_section_data
*) bfd_zalloc (abfd
, sizeof (*sdata
));
1358 sec
->used_by_bfd
= (PTR
) sdata
;
1360 /* Indicate whether or not this section should use RELA relocations. */
1362 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1367 /* Create a new bfd section from an ELF program header.
1369 Since program segments have no names, we generate a synthetic name
1370 of the form segment<NUM>, where NUM is generally the index in the
1371 program header table. For segments that are split (see below) we
1372 generate the names segment<NUM>a and segment<NUM>b.
1374 Note that some program segments may have a file size that is different than
1375 (less than) the memory size. All this means is that at execution the
1376 system must allocate the amount of memory specified by the memory size,
1377 but only initialize it with the first "file size" bytes read from the
1378 file. This would occur for example, with program segments consisting
1379 of combined data+bss.
1381 To handle the above situation, this routine generates TWO bfd sections
1382 for the single program segment. The first has the length specified by
1383 the file size of the segment, and the second has the length specified
1384 by the difference between the two sizes. In effect, the segment is split
1385 into it's initialized and uninitialized parts.
1390 bfd_section_from_phdr (abfd
, hdr
, index
)
1392 Elf_Internal_Phdr
*hdr
;
1400 split
= ((hdr
->p_memsz
> 0)
1401 && (hdr
->p_filesz
> 0)
1402 && (hdr
->p_memsz
> hdr
->p_filesz
));
1403 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
1404 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1407 strcpy (name
, namebuf
);
1408 newsect
= bfd_make_section (abfd
, name
);
1409 if (newsect
== NULL
)
1411 newsect
->vma
= hdr
->p_vaddr
;
1412 newsect
->lma
= hdr
->p_paddr
;
1413 newsect
->_raw_size
= hdr
->p_filesz
;
1414 newsect
->filepos
= hdr
->p_offset
;
1415 newsect
->flags
|= SEC_HAS_CONTENTS
;
1416 if (hdr
->p_type
== PT_LOAD
)
1418 newsect
->flags
|= SEC_ALLOC
;
1419 newsect
->flags
|= SEC_LOAD
;
1420 if (hdr
->p_flags
& PF_X
)
1422 /* FIXME: all we known is that it has execute PERMISSION,
1424 newsect
->flags
|= SEC_CODE
;
1427 if (!(hdr
->p_flags
& PF_W
))
1429 newsect
->flags
|= SEC_READONLY
;
1434 sprintf (namebuf
, "segment%db", index
);
1435 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1438 strcpy (name
, namebuf
);
1439 newsect
= bfd_make_section (abfd
, name
);
1440 if (newsect
== NULL
)
1442 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1443 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1444 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1445 if (hdr
->p_type
== PT_LOAD
)
1447 newsect
->flags
|= SEC_ALLOC
;
1448 if (hdr
->p_flags
& PF_X
)
1449 newsect
->flags
|= SEC_CODE
;
1451 if (!(hdr
->p_flags
& PF_W
))
1452 newsect
->flags
|= SEC_READONLY
;
1458 /* Initialize REL_HDR, the section-header for new section, containing
1459 relocations against ASECT. If USE_RELA_P is true, we use RELA
1460 relocations; otherwise, we use REL relocations. */
1463 _bfd_elf_init_reloc_shdr (abfd
, rel_hdr
, asect
, use_rela_p
)
1465 Elf_Internal_Shdr
*rel_hdr
;
1470 struct elf_backend_data
*bed
;
1472 bed
= get_elf_backend_data (abfd
);
1473 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1476 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1478 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1480 if (rel_hdr
->sh_name
== (unsigned int) -1)
1482 rel_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1483 rel_hdr
->sh_entsize
= (use_rela_p
1484 ? bed
->s
->sizeof_rela
1485 : bed
->s
->sizeof_rel
);
1486 rel_hdr
->sh_addralign
= bed
->s
->file_align
;
1487 rel_hdr
->sh_flags
= 0;
1488 rel_hdr
->sh_addr
= 0;
1489 rel_hdr
->sh_size
= 0;
1490 rel_hdr
->sh_offset
= 0;
1495 /* Set up an ELF internal section header for a section. */
1499 elf_fake_sections (abfd
, asect
, failedptrarg
)
1504 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1505 boolean
*failedptr
= (boolean
*) failedptrarg
;
1506 Elf_Internal_Shdr
*this_hdr
;
1510 /* We already failed; just get out of the bfd_map_over_sections
1515 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1517 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1520 if (this_hdr
->sh_name
== (unsigned long) -1)
1526 this_hdr
->sh_flags
= 0;
1528 if ((asect
->flags
& SEC_ALLOC
) != 0
1529 || asect
->user_set_vma
)
1530 this_hdr
->sh_addr
= asect
->vma
;
1532 this_hdr
->sh_addr
= 0;
1534 this_hdr
->sh_offset
= 0;
1535 this_hdr
->sh_size
= asect
->_raw_size
;
1536 this_hdr
->sh_link
= 0;
1537 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1538 /* The sh_entsize and sh_info fields may have been set already by
1539 copy_private_section_data. */
1541 this_hdr
->bfd_section
= asect
;
1542 this_hdr
->contents
= NULL
;
1544 /* FIXME: This should not be based on section names. */
1545 if (strcmp (asect
->name
, ".dynstr") == 0)
1546 this_hdr
->sh_type
= SHT_STRTAB
;
1547 else if (strcmp (asect
->name
, ".hash") == 0)
1549 this_hdr
->sh_type
= SHT_HASH
;
1550 this_hdr
->sh_entsize
= bed
->s
->sizeof_hash_entry
;
1552 else if (strcmp (asect
->name
, ".dynsym") == 0)
1554 this_hdr
->sh_type
= SHT_DYNSYM
;
1555 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1557 else if (strcmp (asect
->name
, ".dynamic") == 0)
1559 this_hdr
->sh_type
= SHT_DYNAMIC
;
1560 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1562 else if (strncmp (asect
->name
, ".rela", 5) == 0
1563 && get_elf_backend_data (abfd
)->may_use_rela_p
)
1565 this_hdr
->sh_type
= SHT_RELA
;
1566 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1568 else if (strncmp (asect
->name
, ".rel", 4) == 0
1569 && get_elf_backend_data (abfd
)->may_use_rel_p
)
1571 this_hdr
->sh_type
= SHT_REL
;
1572 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1574 else if (strncmp (asect
->name
, ".note", 5) == 0)
1575 this_hdr
->sh_type
= SHT_NOTE
;
1576 else if (strncmp (asect
->name
, ".stab", 5) == 0
1577 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1578 this_hdr
->sh_type
= SHT_STRTAB
;
1579 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1581 this_hdr
->sh_type
= SHT_GNU_versym
;
1582 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1584 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1586 this_hdr
->sh_type
= SHT_GNU_verdef
;
1587 this_hdr
->sh_entsize
= 0;
1588 /* objcopy or strip will copy over sh_info, but may not set
1589 cverdefs. The linker will set cverdefs, but sh_info will be
1591 if (this_hdr
->sh_info
== 0)
1592 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1594 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
1595 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
1597 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1599 this_hdr
->sh_type
= SHT_GNU_verneed
;
1600 this_hdr
->sh_entsize
= 0;
1601 /* objcopy or strip will copy over sh_info, but may not set
1602 cverrefs. The linker will set cverrefs, but sh_info will be
1604 if (this_hdr
->sh_info
== 0)
1605 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1607 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
1608 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
1610 else if ((asect
->flags
& SEC_ALLOC
) != 0
1611 && (asect
->flags
& SEC_LOAD
) != 0)
1612 this_hdr
->sh_type
= SHT_PROGBITS
;
1613 else if ((asect
->flags
& SEC_ALLOC
) != 0
1614 && ((asect
->flags
& SEC_LOAD
) == 0))
1615 this_hdr
->sh_type
= SHT_NOBITS
;
1619 this_hdr
->sh_type
= SHT_PROGBITS
;
1622 if ((asect
->flags
& SEC_ALLOC
) != 0)
1623 this_hdr
->sh_flags
|= SHF_ALLOC
;
1624 if ((asect
->flags
& SEC_READONLY
) == 0)
1625 this_hdr
->sh_flags
|= SHF_WRITE
;
1626 if ((asect
->flags
& SEC_CODE
) != 0)
1627 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1629 /* Check for processor-specific section types. */
1630 if (bed
->elf_backend_fake_sections
)
1631 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1633 /* If the section has relocs, set up a section header for the
1634 SHT_REL[A] section. If two relocation sections are required for
1635 this section, it is up to the processor-specific back-end to
1636 create the other. */
1637 if ((asect
->flags
& SEC_RELOC
) != 0
1638 && !_bfd_elf_init_reloc_shdr (abfd
,
1639 &elf_section_data (asect
)->rel_hdr
,
1641 elf_section_data (asect
)->use_rela_p
))
1645 /* Assign all ELF section numbers. The dummy first section is handled here
1646 too. The link/info pointers for the standard section types are filled
1647 in here too, while we're at it. */
1650 assign_section_numbers (abfd
)
1653 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1655 unsigned int section_number
;
1656 Elf_Internal_Shdr
**i_shdrp
;
1657 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1661 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1663 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1665 d
->this_idx
= section_number
++;
1666 if ((sec
->flags
& SEC_RELOC
) == 0)
1669 d
->rel_idx
= section_number
++;
1672 d
->rel_idx2
= section_number
++;
1677 t
->shstrtab_section
= section_number
++;
1678 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1679 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1681 if (bfd_get_symcount (abfd
) > 0)
1683 t
->symtab_section
= section_number
++;
1684 t
->strtab_section
= section_number
++;
1687 elf_elfheader (abfd
)->e_shnum
= section_number
;
1689 /* Set up the list of section header pointers, in agreement with the
1691 i_shdrp
= ((Elf_Internal_Shdr
**)
1692 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1693 if (i_shdrp
== NULL
)
1696 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1697 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1698 if (i_shdrp
[0] == NULL
)
1700 bfd_release (abfd
, i_shdrp
);
1703 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1705 elf_elfsections (abfd
) = i_shdrp
;
1707 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1708 if (bfd_get_symcount (abfd
) > 0)
1710 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1711 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1712 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1714 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1716 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1720 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1721 if (d
->rel_idx
!= 0)
1722 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1723 if (d
->rel_idx2
!= 0)
1724 i_shdrp
[d
->rel_idx2
] = d
->rel_hdr2
;
1726 /* Fill in the sh_link and sh_info fields while we're at it. */
1728 /* sh_link of a reloc section is the section index of the symbol
1729 table. sh_info is the section index of the section to which
1730 the relocation entries apply. */
1731 if (d
->rel_idx
!= 0)
1733 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1734 d
->rel_hdr
.sh_info
= d
->this_idx
;
1736 if (d
->rel_idx2
!= 0)
1738 d
->rel_hdr2
->sh_link
= t
->symtab_section
;
1739 d
->rel_hdr2
->sh_info
= d
->this_idx
;
1742 switch (d
->this_hdr
.sh_type
)
1746 /* A reloc section which we are treating as a normal BFD
1747 section. sh_link is the section index of the symbol
1748 table. sh_info is the section index of the section to
1749 which the relocation entries apply. We assume that an
1750 allocated reloc section uses the dynamic symbol table.
1751 FIXME: How can we be sure? */
1752 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1754 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1756 /* We look up the section the relocs apply to by name. */
1758 if (d
->this_hdr
.sh_type
== SHT_REL
)
1762 s
= bfd_get_section_by_name (abfd
, name
);
1764 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1768 /* We assume that a section named .stab*str is a stabs
1769 string section. We look for a section with the same name
1770 but without the trailing ``str'', and set its sh_link
1771 field to point to this section. */
1772 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1773 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1778 len
= strlen (sec
->name
);
1779 alc
= (char *) bfd_malloc (len
- 2);
1782 strncpy (alc
, sec
->name
, len
- 3);
1783 alc
[len
- 3] = '\0';
1784 s
= bfd_get_section_by_name (abfd
, alc
);
1788 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1790 /* This is a .stab section. */
1791 elf_section_data (s
)->this_hdr
.sh_entsize
=
1792 4 + 2 * (bed
->s
->arch_size
/ 8);
1799 case SHT_GNU_verneed
:
1800 case SHT_GNU_verdef
:
1801 /* sh_link is the section header index of the string table
1802 used for the dynamic entries, or the symbol table, or the
1804 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1806 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1810 case SHT_GNU_versym
:
1811 /* sh_link is the section header index of the symbol table
1812 this hash table or version table is for. */
1813 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1815 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1823 /* Map symbol from it's internal number to the external number, moving
1824 all local symbols to be at the head of the list. */
1827 sym_is_global (abfd
, sym
)
1831 /* If the backend has a special mapping, use it. */
1832 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1833 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1836 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1837 || bfd_is_und_section (bfd_get_section (sym
))
1838 || bfd_is_com_section (bfd_get_section (sym
)));
1842 elf_map_symbols (abfd
)
1845 int symcount
= bfd_get_symcount (abfd
);
1846 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1847 asymbol
**sect_syms
;
1849 int num_globals
= 0;
1850 int num_locals2
= 0;
1851 int num_globals2
= 0;
1853 int num_sections
= 0;
1860 fprintf (stderr
, "elf_map_symbols\n");
1864 /* Add a section symbol for each BFD section. FIXME: Is this really
1866 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1868 if (max_index
< asect
->index
)
1869 max_index
= asect
->index
;
1873 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1874 if (sect_syms
== NULL
)
1876 elf_section_syms (abfd
) = sect_syms
;
1878 for (idx
= 0; idx
< symcount
; idx
++)
1882 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
1889 if (sec
->owner
!= NULL
)
1891 if (sec
->owner
!= abfd
)
1893 if (sec
->output_offset
!= 0)
1896 sec
= sec
->output_section
;
1898 /* Empty sections in the input files may have had a section
1899 symbol created for them. (See the comment near the end of
1900 _bfd_generic_link_output_symbols in linker.c). If the linker
1901 script discards such sections then we will reach this point.
1902 Since we know that we cannot avoid this case, we detect it
1903 and skip the abort and the assignment to the sect_syms array.
1904 To reproduce this particular case try running the linker
1905 testsuite test ld-scripts/weak.exp for an ELF port that uses
1906 the generic linker. */
1907 if (sec
->owner
== NULL
)
1910 BFD_ASSERT (sec
->owner
== abfd
);
1912 sect_syms
[sec
->index
] = syms
[idx
];
1917 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1919 if (sect_syms
[asect
->index
] != NULL
)
1922 sym
= bfd_make_empty_symbol (abfd
);
1925 sym
->the_bfd
= abfd
;
1926 sym
->name
= asect
->name
;
1928 /* Set the flags to 0 to indicate that this one was newly added. */
1930 sym
->section
= asect
;
1931 sect_syms
[asect
->index
] = sym
;
1935 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1936 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1940 /* Classify all of the symbols. */
1941 for (idx
= 0; idx
< symcount
; idx
++)
1943 if (!sym_is_global (abfd
, syms
[idx
]))
1948 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1950 if (sect_syms
[asect
->index
] != NULL
1951 && sect_syms
[asect
->index
]->flags
== 0)
1953 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1954 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1958 sect_syms
[asect
->index
]->flags
= 0;
1962 /* Now sort the symbols so the local symbols are first. */
1963 new_syms
= ((asymbol
**)
1965 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1966 if (new_syms
== NULL
)
1969 for (idx
= 0; idx
< symcount
; idx
++)
1971 asymbol
*sym
= syms
[idx
];
1974 if (!sym_is_global (abfd
, sym
))
1977 i
= num_locals
+ num_globals2
++;
1979 sym
->udata
.i
= i
+ 1;
1981 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1983 if (sect_syms
[asect
->index
] != NULL
1984 && sect_syms
[asect
->index
]->flags
== 0)
1986 asymbol
*sym
= sect_syms
[asect
->index
];
1989 sym
->flags
= BSF_SECTION_SYM
;
1990 if (!sym_is_global (abfd
, sym
))
1993 i
= num_locals
+ num_globals2
++;
1995 sym
->udata
.i
= i
+ 1;
1999 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
2001 elf_num_locals (abfd
) = num_locals
;
2002 elf_num_globals (abfd
) = num_globals
;
2006 /* Align to the maximum file alignment that could be required for any
2007 ELF data structure. */
2009 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
2010 static INLINE file_ptr
2011 align_file_position (off
, align
)
2015 return (off
+ align
- 1) & ~(align
- 1);
2018 /* Assign a file position to a section, optionally aligning to the
2019 required section alignment. */
2022 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
2023 Elf_Internal_Shdr
*i_shdrp
;
2031 al
= i_shdrp
->sh_addralign
;
2033 offset
= BFD_ALIGN (offset
, al
);
2035 i_shdrp
->sh_offset
= offset
;
2036 if (i_shdrp
->bfd_section
!= NULL
)
2037 i_shdrp
->bfd_section
->filepos
= offset
;
2038 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2039 offset
+= i_shdrp
->sh_size
;
2043 /* Compute the file positions we are going to put the sections at, and
2044 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2045 is not NULL, this is being called by the ELF backend linker. */
2048 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2050 struct bfd_link_info
*link_info
;
2052 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2054 struct bfd_strtab_hash
*strtab
;
2055 Elf_Internal_Shdr
*shstrtab_hdr
;
2057 if (abfd
->output_has_begun
)
2060 /* Do any elf backend specific processing first. */
2061 if (bed
->elf_backend_begin_write_processing
)
2062 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2064 if (! prep_headers (abfd
))
2067 /* Post process the headers if necessary. */
2068 if (bed
->elf_backend_post_process_headers
)
2069 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2072 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2076 if (!assign_section_numbers (abfd
))
2079 /* The backend linker builds symbol table information itself. */
2080 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2082 /* Non-zero if doing a relocatable link. */
2083 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2085 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2089 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2090 /* sh_name was set in prep_headers. */
2091 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2092 shstrtab_hdr
->sh_flags
= 0;
2093 shstrtab_hdr
->sh_addr
= 0;
2094 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
2095 shstrtab_hdr
->sh_entsize
= 0;
2096 shstrtab_hdr
->sh_link
= 0;
2097 shstrtab_hdr
->sh_info
= 0;
2098 /* sh_offset is set in assign_file_positions_except_relocs. */
2099 shstrtab_hdr
->sh_addralign
= 1;
2101 if (!assign_file_positions_except_relocs (abfd
))
2104 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2107 Elf_Internal_Shdr
*hdr
;
2109 off
= elf_tdata (abfd
)->next_file_pos
;
2111 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2112 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2114 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2115 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2117 elf_tdata (abfd
)->next_file_pos
= off
;
2119 /* Now that we know where the .strtab section goes, write it
2121 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2122 || ! _bfd_stringtab_emit (abfd
, strtab
))
2124 _bfd_stringtab_free (strtab
);
2127 abfd
->output_has_begun
= true;
2132 /* Create a mapping from a set of sections to a program segment. */
2134 static INLINE
struct elf_segment_map
*
2135 make_mapping (abfd
, sections
, from
, to
, phdr
)
2137 asection
**sections
;
2142 struct elf_segment_map
*m
;
2146 m
= ((struct elf_segment_map
*)
2148 (sizeof (struct elf_segment_map
)
2149 + (to
- from
- 1) * sizeof (asection
*))));
2153 m
->p_type
= PT_LOAD
;
2154 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2155 m
->sections
[i
- from
] = *hdrpp
;
2156 m
->count
= to
- from
;
2158 if (from
== 0 && phdr
)
2160 /* Include the headers in the first PT_LOAD segment. */
2161 m
->includes_filehdr
= 1;
2162 m
->includes_phdrs
= 1;
2168 /* Set up a mapping from BFD sections to program segments. */
2171 map_sections_to_segments (abfd
)
2174 asection
**sections
= NULL
;
2178 struct elf_segment_map
*mfirst
;
2179 struct elf_segment_map
**pm
;
2180 struct elf_segment_map
*m
;
2182 unsigned int phdr_index
;
2183 bfd_vma maxpagesize
;
2185 boolean phdr_in_segment
= true;
2189 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2192 if (bfd_count_sections (abfd
) == 0)
2195 /* Select the allocated sections, and sort them. */
2197 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2198 * sizeof (asection
*));
2199 if (sections
== NULL
)
2203 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2205 if ((s
->flags
& SEC_ALLOC
) != 0)
2211 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2214 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2216 /* Build the mapping. */
2221 /* If we have a .interp section, then create a PT_PHDR segment for
2222 the program headers and a PT_INTERP segment for the .interp
2224 s
= bfd_get_section_by_name (abfd
, ".interp");
2225 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2227 m
= ((struct elf_segment_map
*)
2228 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2232 m
->p_type
= PT_PHDR
;
2233 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2234 m
->p_flags
= PF_R
| PF_X
;
2235 m
->p_flags_valid
= 1;
2236 m
->includes_phdrs
= 1;
2241 m
= ((struct elf_segment_map
*)
2242 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2246 m
->p_type
= PT_INTERP
;
2254 /* Look through the sections. We put sections in the same program
2255 segment when the start of the second section can be placed within
2256 a few bytes of the end of the first section. */
2259 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2261 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2263 && (dynsec
->flags
& SEC_LOAD
) == 0)
2266 /* Deal with -Ttext or something similar such that the first section
2267 is not adjacent to the program headers. This is an
2268 approximation, since at this point we don't know exactly how many
2269 program headers we will need. */
2272 bfd_size_type phdr_size
;
2274 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2276 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2277 if ((abfd
->flags
& D_PAGED
) == 0
2278 || sections
[0]->lma
< phdr_size
2279 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2280 phdr_in_segment
= false;
2283 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2286 boolean new_segment
;
2290 /* See if this section and the last one will fit in the same
2293 if (last_hdr
== NULL
)
2295 /* If we don't have a segment yet, then we don't need a new
2296 one (we build the last one after this loop). */
2297 new_segment
= false;
2299 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2301 /* If this section has a different relation between the
2302 virtual address and the load address, then we need a new
2306 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2307 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2309 /* If putting this section in this segment would force us to
2310 skip a page in the segment, then we need a new segment. */
2313 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2314 && (hdr
->flags
& SEC_LOAD
) != 0)
2316 /* We don't want to put a loadable section after a
2317 nonloadable section in the same segment. */
2320 else if ((abfd
->flags
& D_PAGED
) == 0)
2322 /* If the file is not demand paged, which means that we
2323 don't require the sections to be correctly aligned in the
2324 file, then there is no other reason for a new segment. */
2325 new_segment
= false;
2328 && (hdr
->flags
& SEC_READONLY
) == 0
2329 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2332 /* We don't want to put a writable section in a read only
2333 segment, unless they are on the same page in memory
2334 anyhow. We already know that the last section does not
2335 bring us past the current section on the page, so the
2336 only case in which the new section is not on the same
2337 page as the previous section is when the previous section
2338 ends precisely on a page boundary. */
2343 /* Otherwise, we can use the same segment. */
2344 new_segment
= false;
2349 if ((hdr
->flags
& SEC_READONLY
) == 0)
2355 /* We need a new program segment. We must create a new program
2356 header holding all the sections from phdr_index until hdr. */
2358 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2365 if ((hdr
->flags
& SEC_READONLY
) == 0)
2372 phdr_in_segment
= false;
2375 /* Create a final PT_LOAD program segment. */
2376 if (last_hdr
!= NULL
)
2378 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2386 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2389 m
= ((struct elf_segment_map
*)
2390 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2394 m
->p_type
= PT_DYNAMIC
;
2396 m
->sections
[0] = dynsec
;
2402 /* For each loadable .note section, add a PT_NOTE segment. We don't
2403 use bfd_get_section_by_name, because if we link together
2404 nonloadable .note sections and loadable .note sections, we will
2405 generate two .note sections in the output file. FIXME: Using
2406 names for section types is bogus anyhow. */
2407 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2409 if ((s
->flags
& SEC_LOAD
) != 0
2410 && strncmp (s
->name
, ".note", 5) == 0)
2412 m
= ((struct elf_segment_map
*)
2413 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2417 m
->p_type
= PT_NOTE
;
2429 elf_tdata (abfd
)->segment_map
= mfirst
;
2433 if (sections
!= NULL
)
2438 /* Sort sections by address. */
2441 elf_sort_sections (arg1
, arg2
)
2445 const asection
*sec1
= *(const asection
**) arg1
;
2446 const asection
*sec2
= *(const asection
**) arg2
;
2448 /* Sort by LMA first, since this is the address used to
2449 place the section into a segment. */
2450 if (sec1
->lma
< sec2
->lma
)
2452 else if (sec1
->lma
> sec2
->lma
)
2455 /* Then sort by VMA. Normally the LMA and the VMA will be
2456 the same, and this will do nothing. */
2457 if (sec1
->vma
< sec2
->vma
)
2459 else if (sec1
->vma
> sec2
->vma
)
2462 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2464 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2469 return sec1
->target_index
- sec2
->target_index
;
2479 /* Sort by size, to put zero sized sections before others at the
2482 if (sec1
->_raw_size
< sec2
->_raw_size
)
2484 if (sec1
->_raw_size
> sec2
->_raw_size
)
2487 return sec1
->target_index
- sec2
->target_index
;
2490 /* Assign file positions to the sections based on the mapping from
2491 sections to segments. This function also sets up some fields in
2492 the file header, and writes out the program headers. */
2495 assign_file_positions_for_segments (abfd
)
2498 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2500 struct elf_segment_map
*m
;
2502 Elf_Internal_Phdr
*phdrs
;
2504 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2505 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2506 Elf_Internal_Phdr
*p
;
2508 if (elf_tdata (abfd
)->segment_map
== NULL
)
2510 if (! map_sections_to_segments (abfd
))
2514 if (bed
->elf_backend_modify_segment_map
)
2516 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2521 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2524 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2525 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2526 elf_elfheader (abfd
)->e_phnum
= count
;
2531 /* If we already counted the number of program segments, make sure
2532 that we allocated enough space. This happens when SIZEOF_HEADERS
2533 is used in a linker script. */
2534 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2535 if (alloc
!= 0 && count
> alloc
)
2537 ((*_bfd_error_handler
)
2538 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2539 bfd_get_filename (abfd
), alloc
, count
));
2540 bfd_set_error (bfd_error_bad_value
);
2547 phdrs
= ((Elf_Internal_Phdr
*)
2548 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2552 off
= bed
->s
->sizeof_ehdr
;
2553 off
+= alloc
* bed
->s
->sizeof_phdr
;
2560 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2567 /* If elf_segment_map is not from map_sections_to_segments, the
2568 sections may not be correctly ordered. */
2570 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2573 p
->p_type
= m
->p_type
;
2574 p
->p_flags
= m
->p_flags
;
2576 if (p
->p_type
== PT_LOAD
2578 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2580 if ((abfd
->flags
& D_PAGED
) != 0)
2581 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2584 bfd_size_type align
;
2587 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2589 bfd_size_type secalign
;
2591 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
2592 if (secalign
> align
)
2596 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
2603 p
->p_vaddr
= m
->sections
[0]->vma
;
2605 if (m
->p_paddr_valid
)
2606 p
->p_paddr
= m
->p_paddr
;
2607 else if (m
->count
== 0)
2610 p
->p_paddr
= m
->sections
[0]->lma
;
2612 if (p
->p_type
== PT_LOAD
2613 && (abfd
->flags
& D_PAGED
) != 0)
2614 p
->p_align
= bed
->maxpagesize
;
2615 else if (m
->count
== 0)
2616 p
->p_align
= bed
->s
->file_align
;
2624 if (m
->includes_filehdr
)
2626 if (! m
->p_flags_valid
)
2629 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2630 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2633 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2635 if (p
->p_vaddr
< (bfd_vma
) off
)
2637 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2638 bfd_get_filename (abfd
));
2639 bfd_set_error (bfd_error_bad_value
);
2644 if (! m
->p_paddr_valid
)
2647 if (p
->p_type
== PT_LOAD
)
2649 filehdr_vaddr
= p
->p_vaddr
;
2650 filehdr_paddr
= p
->p_paddr
;
2654 if (m
->includes_phdrs
)
2656 if (! m
->p_flags_valid
)
2659 if (m
->includes_filehdr
)
2661 if (p
->p_type
== PT_LOAD
)
2663 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2664 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2669 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2673 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2674 p
->p_vaddr
-= off
- p
->p_offset
;
2675 if (! m
->p_paddr_valid
)
2676 p
->p_paddr
-= off
- p
->p_offset
;
2679 if (p
->p_type
== PT_LOAD
)
2681 phdrs_vaddr
= p
->p_vaddr
;
2682 phdrs_paddr
= p
->p_paddr
;
2685 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
2688 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2689 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2692 if (p
->p_type
== PT_LOAD
2693 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
2695 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2701 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2702 p
->p_filesz
+= adjust
;
2703 p
->p_memsz
+= adjust
;
2709 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2713 bfd_size_type align
;
2717 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2719 /* The section may have artificial alignment forced by a
2720 link script. Notice this case by the gap between the
2721 cumulative phdr vma and the section's vma. */
2722 if (p
->p_vaddr
+ p
->p_memsz
< sec
->vma
)
2724 bfd_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
2726 p
->p_memsz
+= adjust
;
2729 if ((flags
& SEC_LOAD
) != 0)
2730 p
->p_filesz
+= adjust
;
2733 if (p
->p_type
== PT_LOAD
)
2735 bfd_signed_vma adjust
;
2737 if ((flags
& SEC_LOAD
) != 0)
2739 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2743 else if ((flags
& SEC_ALLOC
) != 0)
2745 /* The section VMA must equal the file position
2746 modulo the page size. FIXME: I'm not sure if
2747 this adjustment is really necessary. We used to
2748 not have the SEC_LOAD case just above, and then
2749 this was necessary, but now I'm not sure. */
2750 if ((abfd
->flags
& D_PAGED
) != 0)
2751 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2753 adjust
= (sec
->vma
- voff
) % align
;
2762 (* _bfd_error_handler
)
2763 (_("Error: First section in segment (%s) starts at 0x%x"),
2764 bfd_section_name (abfd
, sec
), sec
->lma
);
2765 (* _bfd_error_handler
)
2766 (_(" whereas segment starts at 0x%x"),
2771 p
->p_memsz
+= adjust
;
2774 if ((flags
& SEC_LOAD
) != 0)
2775 p
->p_filesz
+= adjust
;
2780 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2781 used in a linker script we may have a section with
2782 SEC_LOAD clear but which is supposed to have
2784 if ((flags
& SEC_LOAD
) != 0
2785 || (flags
& SEC_HAS_CONTENTS
) != 0)
2786 off
+= sec
->_raw_size
;
2788 if ((flags
& SEC_ALLOC
) != 0)
2789 voff
+= sec
->_raw_size
;
2792 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
2794 if (i
== 0) /* the actual "note" segment */
2795 { /* this one actually contains everything. */
2797 p
->p_filesz
= sec
->_raw_size
;
2798 off
+= sec
->_raw_size
;
2801 else /* fake sections -- don't need to be written */
2805 flags
= sec
->flags
= 0; /* no contents */
2812 p
->p_memsz
+= sec
->_raw_size
;
2814 if ((flags
& SEC_LOAD
) != 0)
2815 p
->p_filesz
+= sec
->_raw_size
;
2817 if (align
> p
->p_align
2818 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
2822 if (! m
->p_flags_valid
)
2825 if ((flags
& SEC_CODE
) != 0)
2827 if ((flags
& SEC_READONLY
) == 0)
2833 /* Now that we have set the section file positions, we can set up
2834 the file positions for the non PT_LOAD segments. */
2835 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2839 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2841 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2842 p
->p_offset
= m
->sections
[0]->filepos
;
2846 if (m
->includes_filehdr
)
2848 p
->p_vaddr
= filehdr_vaddr
;
2849 if (! m
->p_paddr_valid
)
2850 p
->p_paddr
= filehdr_paddr
;
2852 else if (m
->includes_phdrs
)
2854 p
->p_vaddr
= phdrs_vaddr
;
2855 if (! m
->p_paddr_valid
)
2856 p
->p_paddr
= phdrs_paddr
;
2861 /* Clear out any program headers we allocated but did not use. */
2862 for (; count
< alloc
; count
++, p
++)
2864 memset (p
, 0, sizeof *p
);
2865 p
->p_type
= PT_NULL
;
2868 elf_tdata (abfd
)->phdr
= phdrs
;
2870 elf_tdata (abfd
)->next_file_pos
= off
;
2872 /* Write out the program headers. */
2873 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2874 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2880 /* Get the size of the program header.
2882 If this is called by the linker before any of the section VMA's are set, it
2883 can't calculate the correct value for a strange memory layout. This only
2884 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2885 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2886 data segment (exclusive of .interp and .dynamic).
2888 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2889 will be two segments. */
2891 static bfd_size_type
2892 get_program_header_size (abfd
)
2897 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2899 /* We can't return a different result each time we're called. */
2900 if (elf_tdata (abfd
)->program_header_size
!= 0)
2901 return elf_tdata (abfd
)->program_header_size
;
2903 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2905 struct elf_segment_map
*m
;
2908 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2910 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2911 return elf_tdata (abfd
)->program_header_size
;
2914 /* Assume we will need exactly two PT_LOAD segments: one for text
2915 and one for data. */
2918 s
= bfd_get_section_by_name (abfd
, ".interp");
2919 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2921 /* If we have a loadable interpreter section, we need a
2922 PT_INTERP segment. In this case, assume we also need a
2923 PT_PHDR segment, although that may not be true for all
2928 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2930 /* We need a PT_DYNAMIC segment. */
2934 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2936 if ((s
->flags
& SEC_LOAD
) != 0
2937 && strncmp (s
->name
, ".note", 5) == 0)
2939 /* We need a PT_NOTE segment. */
2944 /* Let the backend count up any program headers it might need. */
2945 if (bed
->elf_backend_additional_program_headers
)
2949 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2955 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2956 return elf_tdata (abfd
)->program_header_size
;
2959 /* Work out the file positions of all the sections. This is called by
2960 _bfd_elf_compute_section_file_positions. All the section sizes and
2961 VMAs must be known before this is called.
2963 We do not consider reloc sections at this point, unless they form
2964 part of the loadable image. Reloc sections are assigned file
2965 positions in assign_file_positions_for_relocs, which is called by
2966 write_object_contents and final_link.
2968 We also don't set the positions of the .symtab and .strtab here. */
2971 assign_file_positions_except_relocs (abfd
)
2974 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2975 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2976 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2978 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2980 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2981 && bfd_get_format (abfd
) != bfd_core
)
2983 Elf_Internal_Shdr
**hdrpp
;
2986 /* Start after the ELF header. */
2987 off
= i_ehdrp
->e_ehsize
;
2989 /* We are not creating an executable, which means that we are
2990 not creating a program header, and that the actual order of
2991 the sections in the file is unimportant. */
2992 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2994 Elf_Internal_Shdr
*hdr
;
2997 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2999 hdr
->sh_offset
= -1;
3002 if (i
== tdata
->symtab_section
3003 || i
== tdata
->strtab_section
)
3005 hdr
->sh_offset
= -1;
3009 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3015 Elf_Internal_Shdr
**hdrpp
;
3017 /* Assign file positions for the loaded sections based on the
3018 assignment of sections to segments. */
3019 if (! assign_file_positions_for_segments (abfd
))
3022 /* Assign file positions for the other sections. */
3024 off
= elf_tdata (abfd
)->next_file_pos
;
3025 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
3027 Elf_Internal_Shdr
*hdr
;
3030 if (hdr
->bfd_section
!= NULL
3031 && hdr
->bfd_section
->filepos
!= 0)
3032 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
3033 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3035 ((*_bfd_error_handler
)
3036 (_("%s: warning: allocated section `%s' not in segment"),
3037 bfd_get_filename (abfd
),
3038 (hdr
->bfd_section
== NULL
3040 : hdr
->bfd_section
->name
)));
3041 if ((abfd
->flags
& D_PAGED
) != 0)
3042 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3044 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3045 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3048 else if (hdr
->sh_type
== SHT_REL
3049 || hdr
->sh_type
== SHT_RELA
3050 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3051 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3052 hdr
->sh_offset
= -1;
3054 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3058 /* Place the section headers. */
3059 off
= align_file_position (off
, bed
->s
->file_align
);
3060 i_ehdrp
->e_shoff
= off
;
3061 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3063 elf_tdata (abfd
)->next_file_pos
= off
;
3072 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3073 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3074 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3076 struct bfd_strtab_hash
*shstrtab
;
3077 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3079 i_ehdrp
= elf_elfheader (abfd
);
3080 i_shdrp
= elf_elfsections (abfd
);
3082 shstrtab
= _bfd_elf_stringtab_init ();
3083 if (shstrtab
== NULL
)
3086 elf_shstrtab (abfd
) = shstrtab
;
3088 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3089 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3090 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3091 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3093 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3094 i_ehdrp
->e_ident
[EI_DATA
] =
3095 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3096 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3098 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_SYSV
;
3099 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 0;
3101 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
3102 i_ehdrp
->e_ident
[count
] = 0;
3104 if ((abfd
->flags
& DYNAMIC
) != 0)
3105 i_ehdrp
->e_type
= ET_DYN
;
3106 else if ((abfd
->flags
& EXEC_P
) != 0)
3107 i_ehdrp
->e_type
= ET_EXEC
;
3108 else if (bfd_get_format (abfd
) == bfd_core
)
3109 i_ehdrp
->e_type
= ET_CORE
;
3111 i_ehdrp
->e_type
= ET_REL
;
3113 switch (bfd_get_arch (abfd
))
3115 case bfd_arch_unknown
:
3116 i_ehdrp
->e_machine
= EM_NONE
;
3118 case bfd_arch_sparc
:
3119 if (bed
->s
->arch_size
== 64)
3120 i_ehdrp
->e_machine
= EM_SPARCV9
;
3122 i_ehdrp
->e_machine
= EM_SPARC
;
3125 i_ehdrp
->e_machine
= EM_386
;
3128 i_ehdrp
->e_machine
= EM_68K
;
3131 i_ehdrp
->e_machine
= EM_88K
;
3134 i_ehdrp
->e_machine
= EM_860
;
3137 i_ehdrp
->e_machine
= EM_960
;
3139 case bfd_arch_mips
: /* MIPS Rxxxx */
3140 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
3143 i_ehdrp
->e_machine
= EM_PARISC
;
3145 case bfd_arch_powerpc
:
3146 i_ehdrp
->e_machine
= EM_PPC
;
3148 case bfd_arch_alpha
:
3149 i_ehdrp
->e_machine
= EM_ALPHA
;
3152 i_ehdrp
->e_machine
= EM_SH
;
3155 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
3158 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
3161 i_ehdrp
->e_machine
= EM_CYGNUS_FR30
;
3163 case bfd_arch_mcore
:
3164 i_ehdrp
->e_machine
= EM_MCORE
;
3167 switch (bfd_get_mach (abfd
))
3170 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
3174 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
3177 i_ehdrp
->e_machine
= EM_ARM
;
3180 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
3182 case bfd_arch_mn10200
:
3183 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
3185 case bfd_arch_mn10300
:
3186 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3189 i_ehdrp
->e_machine
= EM_PJ
;
3191 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3193 i_ehdrp
->e_machine
= EM_NONE
;
3195 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3196 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3198 /* no program header, for now. */
3199 i_ehdrp
->e_phoff
= 0;
3200 i_ehdrp
->e_phentsize
= 0;
3201 i_ehdrp
->e_phnum
= 0;
3203 /* each bfd section is section header entry */
3204 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3205 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3207 /* if we're building an executable, we'll need a program header table */
3208 if (abfd
->flags
& EXEC_P
)
3210 /* it all happens later */
3212 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3214 /* elf_build_phdrs() returns a (NULL-terminated) array of
3215 Elf_Internal_Phdrs */
3216 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3217 i_ehdrp
->e_phoff
= outbase
;
3218 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3223 i_ehdrp
->e_phentsize
= 0;
3225 i_ehdrp
->e_phoff
= 0;
3228 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3229 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3230 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3231 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3232 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3233 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3234 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3235 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3236 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3242 /* Assign file positions for all the reloc sections which are not part
3243 of the loadable file image. */
3246 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3251 Elf_Internal_Shdr
**shdrpp
;
3253 off
= elf_tdata (abfd
)->next_file_pos
;
3255 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3256 i
< elf_elfheader (abfd
)->e_shnum
;
3259 Elf_Internal_Shdr
*shdrp
;
3262 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3263 && shdrp
->sh_offset
== -1)
3264 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3267 elf_tdata (abfd
)->next_file_pos
= off
;
3271 _bfd_elf_write_object_contents (abfd
)
3274 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3275 Elf_Internal_Ehdr
*i_ehdrp
;
3276 Elf_Internal_Shdr
**i_shdrp
;
3280 if (! abfd
->output_has_begun
3281 && ! _bfd_elf_compute_section_file_positions
3282 (abfd
, (struct bfd_link_info
*) NULL
))
3285 i_shdrp
= elf_elfsections (abfd
);
3286 i_ehdrp
= elf_elfheader (abfd
);
3289 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3293 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3295 /* After writing the headers, we need to write the sections too... */
3296 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3298 if (bed
->elf_backend_section_processing
)
3299 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3300 if (i_shdrp
[count
]->contents
)
3302 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3303 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3305 != i_shdrp
[count
]->sh_size
))
3310 /* Write out the section header names. */
3311 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3312 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3315 if (bed
->elf_backend_final_write_processing
)
3316 (*bed
->elf_backend_final_write_processing
) (abfd
,
3317 elf_tdata (abfd
)->linker
);
3319 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3323 _bfd_elf_write_corefile_contents (abfd
)
3326 /* Hopefully this can be done just like an object file. */
3327 return _bfd_elf_write_object_contents (abfd
);
3329 /* given a section, search the header to find them... */
3331 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3335 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3336 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3338 Elf_Internal_Shdr
*hdr
;
3339 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3341 for (index
= 0; index
< maxindex
; index
++)
3343 hdr
= i_shdrp
[index
];
3344 if (hdr
->bfd_section
== asect
)
3348 if (bed
->elf_backend_section_from_bfd_section
)
3350 for (index
= 0; index
< maxindex
; index
++)
3354 hdr
= i_shdrp
[index
];
3356 if ((*bed
->elf_backend_section_from_bfd_section
)
3357 (abfd
, hdr
, asect
, &retval
))
3362 if (bfd_is_abs_section (asect
))
3364 if (bfd_is_com_section (asect
))
3366 if (bfd_is_und_section (asect
))
3369 bfd_set_error (bfd_error_nonrepresentable_section
);
3374 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3378 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3380 asymbol
**asym_ptr_ptr
;
3382 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3384 flagword flags
= asym_ptr
->flags
;
3386 /* When gas creates relocations against local labels, it creates its
3387 own symbol for the section, but does put the symbol into the
3388 symbol chain, so udata is 0. When the linker is generating
3389 relocatable output, this section symbol may be for one of the
3390 input sections rather than the output section. */
3391 if (asym_ptr
->udata
.i
== 0
3392 && (flags
& BSF_SECTION_SYM
)
3393 && asym_ptr
->section
)
3397 if (asym_ptr
->section
->output_section
!= NULL
)
3398 indx
= asym_ptr
->section
->output_section
->index
;
3400 indx
= asym_ptr
->section
->index
;
3401 if (elf_section_syms (abfd
)[indx
])
3402 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3405 idx
= asym_ptr
->udata
.i
;
3409 /* This case can occur when using --strip-symbol on a symbol
3410 which is used in a relocation entry. */
3411 (*_bfd_error_handler
)
3412 (_("%s: symbol `%s' required but not present"),
3413 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3414 bfd_set_error (bfd_error_no_symbols
);
3421 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3422 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3423 elf_symbol_flags (flags
));
3431 /* Copy private BFD data. This copies any program header information. */
3434 copy_private_bfd_data (ibfd
, obfd
)
3438 Elf_Internal_Ehdr
*iehdr
;
3439 struct elf_segment_map
*mfirst
;
3440 struct elf_segment_map
**pm
;
3441 struct elf_segment_map
*m
;
3442 Elf_Internal_Phdr
*p
;
3444 unsigned int num_segments
;
3445 boolean phdr_included
= false;
3447 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3448 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3451 if (elf_tdata (ibfd
)->phdr
== NULL
)
3454 iehdr
= elf_elfheader (ibfd
);
3459 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
3461 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3462 ((addr) >= (bottom) \
3463 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3464 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3466 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3468 #define IS_COREFILE_NOTE(p, s) \
3469 (p->p_type == PT_NOTE \
3470 && bfd_get_format (ibfd) == bfd_core \
3471 && s->vma == 0 && s->lma == 0 \
3472 && (bfd_vma) s->filepos >= p->p_offset \
3473 && (bfd_vma) s->filepos + s->_raw_size \
3474 <= p->p_offset + p->p_filesz)
3476 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3477 linker, which generates a PT_INTERP section with p_vaddr and
3478 p_memsz set to 0. */
3480 #define IS_SOLARIS_PT_INTERP(p, s) \
3482 && p->p_filesz > 0 \
3483 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3484 && s->_raw_size > 0 \
3485 && (bfd_vma) s->filepos >= p->p_offset \
3486 && ((bfd_vma) s->filepos + s->_raw_size \
3487 <= p->p_offset + p->p_filesz))
3489 /* Scan through the segments specified in the program header
3490 of the input BFD. */
3491 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< num_segments
; i
++, p
++)
3495 asection
**sections
;
3498 bfd_vma matching_lma
;
3499 bfd_vma suggested_lma
;
3502 /* For each section in the input BFD, decide if it should be
3503 included in the current segment. A section will be included
3504 if it is within the address space of the segment, and it is
3505 an allocated segment, and there is an output section
3506 associated with it. */
3508 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3509 if (s
->output_section
!= NULL
)
3511 if ((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3512 || IS_SOLARIS_PT_INTERP (p
, s
))
3513 && (s
->flags
& SEC_ALLOC
) != 0)
3515 else if (IS_COREFILE_NOTE (p
, s
))
3519 /* Allocate a segment map big enough to contain all of the
3520 sections we have selected. */
3521 m
= ((struct elf_segment_map
*)
3523 (sizeof (struct elf_segment_map
)
3524 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3528 /* Initialise the fields of the segment map. Default to
3529 using the physical address of the segment in the input BFD. */
3531 m
->p_type
= p
->p_type
;
3532 m
->p_flags
= p
->p_flags
;
3533 m
->p_flags_valid
= 1;
3534 m
->p_paddr
= p
->p_paddr
;
3535 m
->p_paddr_valid
= 1;
3537 /* Determine if this segment contains the ELF file header
3538 and if it contains the program headers themselves. */
3539 m
->includes_filehdr
= (p
->p_offset
== 0
3540 && p
->p_filesz
>= iehdr
->e_ehsize
);
3542 m
->includes_phdrs
= 0;
3544 if (! phdr_included
|| p
->p_type
!= PT_LOAD
)
3547 (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3548 && (p
->p_offset
+ p
->p_filesz
3549 >= ((bfd_vma
) iehdr
->e_phoff
3550 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3551 if (p
->p_type
== PT_LOAD
&& m
->includes_phdrs
)
3552 phdr_included
= true;
3557 /* Special segments, such as the PT_PHDR segment, may contain
3558 no sections, but ordinary, loadable segments should contain
3561 if (p
->p_type
== PT_LOAD
)
3563 (_("%s: warning: Empty loadable segment detected\n"),
3564 bfd_get_filename (ibfd
));
3573 /* Now scan the sections in the input BFD again and attempt
3574 to add their corresponding output sections to the segment map.
3575 The problem here is how to handle an output section which has
3576 been moved (ie had its LMA changed). There are four possibilities:
3578 1. None of the sections have been moved.
3579 In this case we can continue to use the segment LMA from the
3582 2. All of the sections have been moved by the same amount.
3583 In this case we can change the segment's LMA to match the LMA
3584 of the first section.
3586 3. Some of the sections have been moved, others have not.
3587 In this case those sections which have not been moved can be
3588 placed in the current segment which will have to have its size,
3589 and possibly its LMA changed, and a new segment or segments will
3590 have to be created to contain the other sections.
3592 4. The sections have been moved, but not be the same amount.
3593 In this case we can change the segment's LMA to match the LMA
3594 of the first section and we will have to create a new segment
3595 or segments to contain the other sections.
3597 In order to save time, we allocate an array to hold the section
3598 pointers that we are interested in. As these sections get assigned
3599 to a segment, they are removed from this array. */
3601 sections
= (asection
**) bfd_malloc (sizeof (asection
*) * csecs
);
3602 if (sections
== NULL
)
3605 /* Step One: Scan for segment vs section LMA conflicts.
3606 Also add the sections to the section array allocated above.
3607 Also add the sections to the current segment. In the common
3608 case, where the sections have not been moved, this means that
3609 we have completely filled the segment, and there is nothing
3613 matching_lma
= false;
3616 for (j
= 0, s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3618 os
= s
->output_section
;
3620 if ((((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3621 || IS_SOLARIS_PT_INTERP (p
, s
))
3622 && (s
->flags
& SEC_ALLOC
) != 0)
3623 || IS_COREFILE_NOTE (p
, s
))
3628 /* The Solaris native linker always sets p_paddr to 0.
3629 We try to catch that case here, and set it to the
3635 && (os
->vma
== (p
->p_vaddr
3636 + (m
->includes_filehdr
3639 + (m
->includes_phdrs
3640 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3642 m
->p_paddr
= p
->p_vaddr
;
3644 /* Match up the physical address of the segment with the
3645 LMA address of the output section. */
3646 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3647 || IS_COREFILE_NOTE (p
, s
))
3649 if (matching_lma
== 0)
3650 matching_lma
= os
->lma
;
3652 /* We assume that if the section fits within the segment
3653 that it does not overlap any other section within that
3655 m
->sections
[isec
++] = os
;
3657 else if (suggested_lma
== 0)
3658 suggested_lma
= os
->lma
;
3662 BFD_ASSERT (j
== csecs
);
3664 /* Step Two: Adjust the physical address of the current segment,
3668 /* All of the sections fitted within the segment as currently
3669 specified. This is the default case. Add the segment to
3670 the list of built segments and carry on to process the next
3671 program header in the input BFD. */
3679 else if (matching_lma
!= 0)
3681 /* At least one section fits inside the current segment.
3682 Keep it, but modify its physical address to match the
3683 LMA of the first section that fitted. */
3685 m
->p_paddr
= matching_lma
;
3689 /* None of the sections fitted inside the current segment.
3690 Change the current segment's physical address to match
3691 the LMA of the first section. */
3693 m
->p_paddr
= suggested_lma
;
3696 /* Step Three: Loop over the sections again, this time assigning
3697 those that fit to the current segment and remvoing them from the
3698 sections array; but making sure not to leave large gaps. Once all
3699 possible sections have been assigned to the current segment it is
3700 added to the list of built segments and if sections still remain
3701 to be assigned, a new segment is constructed before repeating
3709 /* Fill the current segment with sections that fit. */
3710 for (j
= 0; j
< csecs
; j
++)
3717 os
= s
->output_section
;
3719 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3720 || IS_COREFILE_NOTE (p
, s
))
3724 /* If the first section in a segment does not start at
3725 the beginning of the segment, then something is wrong. */
3726 if (os
->lma
!= m
->p_paddr
)
3731 asection
* prev_sec
;
3732 bfd_vma maxpagesize
;
3734 prev_sec
= m
->sections
[m
->count
- 1];
3735 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
3737 /* If the gap between the end of the previous section
3738 and the start of this section is more than maxpagesize
3739 then we need to start a new segment. */
3740 if (BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
, maxpagesize
)
3741 < BFD_ALIGN (os
->lma
, maxpagesize
))
3743 if (suggested_lma
== 0)
3744 suggested_lma
= os
->lma
;
3750 m
->sections
[m
->count
++] = os
;
3754 else if (suggested_lma
== 0)
3755 suggested_lma
= os
->lma
;
3758 BFD_ASSERT (m
->count
> 0);
3760 /* Add the current segment to the list of built segments. */
3766 /* We still have not allocated all of the sections to
3767 segments. Create a new segment here, initialise it
3768 and carry on looping. */
3770 m
= ((struct elf_segment_map
*)
3772 (sizeof (struct elf_segment_map
)
3773 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3777 /* Initialise the fields of the segment map. Set the physical
3778 physical address to the LMA of the first section that has
3779 not yet been assigned. */
3782 m
->p_type
= p
->p_type
;
3783 m
->p_flags
= p
->p_flags
;
3784 m
->p_flags_valid
= 1;
3785 m
->p_paddr
= suggested_lma
;
3786 m
->p_paddr_valid
= 1;
3787 m
->includes_filehdr
= 0;
3788 m
->includes_phdrs
= 0;
3791 while (isec
< csecs
);
3796 /* The Solaris linker creates program headers in which all the
3797 p_paddr fields are zero. When we try to objcopy or strip such a
3798 file, we get confused. Check for this case, and if we find it
3799 reset the p_paddr_valid fields. */
3800 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3801 if (m
->p_paddr
!= 0)
3805 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3806 m
->p_paddr_valid
= 0;
3809 elf_tdata (obfd
)->segment_map
= mfirst
;
3812 /* Final Step: Sort the segments into ascending order of physical address. */
3815 struct elf_segment_map
* prev
;
3818 for (m
= mfirst
->next
; m
!= NULL
; prev
= m
, m
= m
->next
)
3820 /* Yes I know - its a bubble sort....*/
3821 if (m
->next
!= NULL
&& (m
->next
->p_paddr
< m
->p_paddr
))
3823 /* swap m and m->next */
3824 prev
->next
= m
->next
;
3825 m
->next
= m
->next
->next
;
3826 prev
->next
->next
= m
;
3835 #undef IS_CONTAINED_BY
3836 #undef IS_SOLARIS_PT_INTERP
3837 #undef IS_COREFILE_NOTE
3841 /* Copy private section information. This copies over the entsize
3842 field, and sometimes the info field. */
3845 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3851 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3853 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3854 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3857 /* Copy over private BFD data if it has not already been copied.
3858 This must be done here, rather than in the copy_private_bfd_data
3859 entry point, because the latter is called after the section
3860 contents have been set, which means that the program headers have
3861 already been worked out. */
3862 if (elf_tdata (obfd
)->segment_map
== NULL
3863 && elf_tdata (ibfd
)->phdr
!= NULL
)
3867 /* Only set up the segments if there are no more SEC_ALLOC
3868 sections. FIXME: This won't do the right thing if objcopy is
3869 used to remove the last SEC_ALLOC section, since objcopy
3870 won't call this routine in that case. */
3871 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
3872 if ((s
->flags
& SEC_ALLOC
) != 0)
3876 if (! copy_private_bfd_data (ibfd
, obfd
))
3881 ihdr
= &elf_section_data (isec
)->this_hdr
;
3882 ohdr
= &elf_section_data (osec
)->this_hdr
;
3884 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3886 if (ihdr
->sh_type
== SHT_SYMTAB
3887 || ihdr
->sh_type
== SHT_DYNSYM
3888 || ihdr
->sh_type
== SHT_GNU_verneed
3889 || ihdr
->sh_type
== SHT_GNU_verdef
)
3890 ohdr
->sh_info
= ihdr
->sh_info
;
3892 elf_section_data (osec
)->use_rela_p
3893 = elf_section_data (isec
)->use_rela_p
;
3898 /* Copy private symbol information. If this symbol is in a section
3899 which we did not map into a BFD section, try to map the section
3900 index correctly. We use special macro definitions for the mapped
3901 section indices; these definitions are interpreted by the
3902 swap_out_syms function. */
3904 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3905 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3906 #define MAP_STRTAB (SHN_LORESERVE - 3)
3907 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3910 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3916 elf_symbol_type
*isym
, *osym
;
3918 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3919 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3922 isym
= elf_symbol_from (ibfd
, isymarg
);
3923 osym
= elf_symbol_from (obfd
, osymarg
);
3927 && bfd_is_abs_section (isym
->symbol
.section
))
3931 shndx
= isym
->internal_elf_sym
.st_shndx
;
3932 if (shndx
== elf_onesymtab (ibfd
))
3933 shndx
= MAP_ONESYMTAB
;
3934 else if (shndx
== elf_dynsymtab (ibfd
))
3935 shndx
= MAP_DYNSYMTAB
;
3936 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3938 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3939 shndx
= MAP_SHSTRTAB
;
3940 osym
->internal_elf_sym
.st_shndx
= shndx
;
3946 /* Swap out the symbols. */
3949 swap_out_syms (abfd
, sttp
, relocatable_p
)
3951 struct bfd_strtab_hash
**sttp
;
3954 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3956 if (!elf_map_symbols (abfd
))
3959 /* Dump out the symtabs. */
3961 int symcount
= bfd_get_symcount (abfd
);
3962 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3963 struct bfd_strtab_hash
*stt
;
3964 Elf_Internal_Shdr
*symtab_hdr
;
3965 Elf_Internal_Shdr
*symstrtab_hdr
;
3966 char *outbound_syms
;
3969 stt
= _bfd_elf_stringtab_init ();
3973 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3974 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3975 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3976 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3977 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3978 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3980 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3981 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3983 outbound_syms
= bfd_alloc (abfd
,
3984 (1 + symcount
) * bed
->s
->sizeof_sym
);
3985 if (outbound_syms
== NULL
)
3987 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3989 /* now generate the data (for "contents") */
3991 /* Fill in zeroth symbol and swap it out. */
3992 Elf_Internal_Sym sym
;
3998 sym
.st_shndx
= SHN_UNDEF
;
3999 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4000 outbound_syms
+= bed
->s
->sizeof_sym
;
4002 for (idx
= 0; idx
< symcount
; idx
++)
4004 Elf_Internal_Sym sym
;
4005 bfd_vma value
= syms
[idx
]->value
;
4006 elf_symbol_type
*type_ptr
;
4007 flagword flags
= syms
[idx
]->flags
;
4010 if (flags
& BSF_SECTION_SYM
)
4011 /* Section symbols have no names. */
4015 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
4018 if (sym
.st_name
== (unsigned long) -1)
4022 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
4024 if ((flags
& BSF_SECTION_SYM
) == 0
4025 && bfd_is_com_section (syms
[idx
]->section
))
4027 /* ELF common symbols put the alignment into the `value' field,
4028 and the size into the `size' field. This is backwards from
4029 how BFD handles it, so reverse it here. */
4030 sym
.st_size
= value
;
4031 if (type_ptr
== NULL
4032 || type_ptr
->internal_elf_sym
.st_value
== 0)
4033 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
4035 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
4036 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
4037 (abfd
, syms
[idx
]->section
);
4041 asection
*sec
= syms
[idx
]->section
;
4044 if (sec
->output_section
)
4046 value
+= sec
->output_offset
;
4047 sec
= sec
->output_section
;
4049 /* Don't add in the section vma for relocatable output. */
4050 if (! relocatable_p
)
4052 sym
.st_value
= value
;
4053 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4055 if (bfd_is_abs_section (sec
)
4057 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4059 /* This symbol is in a real ELF section which we did
4060 not create as a BFD section. Undo the mapping done
4061 by copy_private_symbol_data. */
4062 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
4066 shndx
= elf_onesymtab (abfd
);
4069 shndx
= elf_dynsymtab (abfd
);
4072 shndx
= elf_tdata (abfd
)->strtab_section
;
4075 shndx
= elf_tdata (abfd
)->shstrtab_section
;
4083 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
4089 /* Writing this would be a hell of a lot easier if
4090 we had some decent documentation on bfd, and
4091 knew what to expect of the library, and what to
4092 demand of applications. For example, it
4093 appears that `objcopy' might not set the
4094 section of a symbol to be a section that is
4095 actually in the output file. */
4096 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
4097 BFD_ASSERT (sec2
!= 0);
4098 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
4099 BFD_ASSERT (shndx
!= -1);
4103 sym
.st_shndx
= shndx
;
4106 if ((flags
& BSF_FUNCTION
) != 0)
4108 else if ((flags
& BSF_OBJECT
) != 0)
4113 /* Processor-specific types */
4114 if (bed
->elf_backend_get_symbol_type
)
4115 type
= (*bed
->elf_backend_get_symbol_type
) (&type_ptr
->internal_elf_sym
, type
);
4117 if (flags
& BSF_SECTION_SYM
)
4118 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4119 else if (bfd_is_com_section (syms
[idx
]->section
))
4120 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
4121 else if (bfd_is_und_section (syms
[idx
]->section
))
4122 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
4126 else if (flags
& BSF_FILE
)
4127 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4130 int bind
= STB_LOCAL
;
4132 if (flags
& BSF_LOCAL
)
4134 else if (flags
& BSF_WEAK
)
4136 else if (flags
& BSF_GLOBAL
)
4139 sym
.st_info
= ELF_ST_INFO (bind
, type
);
4142 if (type_ptr
!= NULL
)
4143 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
4147 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4148 outbound_syms
+= bed
->s
->sizeof_sym
;
4152 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
4153 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4155 symstrtab_hdr
->sh_flags
= 0;
4156 symstrtab_hdr
->sh_addr
= 0;
4157 symstrtab_hdr
->sh_entsize
= 0;
4158 symstrtab_hdr
->sh_link
= 0;
4159 symstrtab_hdr
->sh_info
= 0;
4160 symstrtab_hdr
->sh_addralign
= 1;
4166 /* Return the number of bytes required to hold the symtab vector.
4168 Note that we base it on the count plus 1, since we will null terminate
4169 the vector allocated based on this size. However, the ELF symbol table
4170 always has a dummy entry as symbol #0, so it ends up even. */
4173 _bfd_elf_get_symtab_upper_bound (abfd
)
4178 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4180 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4181 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4187 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
4192 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
4194 if (elf_dynsymtab (abfd
) == 0)
4196 bfd_set_error (bfd_error_invalid_operation
);
4200 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4201 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4207 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
4208 bfd
*abfd ATTRIBUTE_UNUSED
;
4211 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
4214 /* Canonicalize the relocs. */
4217 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4226 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
4232 tblptr
= section
->relocation
;
4233 for (i
= 0; i
< section
->reloc_count
; i
++)
4234 *relptr
++ = tblptr
++;
4238 return section
->reloc_count
;
4242 _bfd_elf_get_symtab (abfd
, alocation
)
4244 asymbol
**alocation
;
4246 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4247 (abfd
, alocation
, false);
4250 bfd_get_symcount (abfd
) = symcount
;
4255 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
4257 asymbol
**alocation
;
4259 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4260 (abfd
, alocation
, true);
4263 /* Return the size required for the dynamic reloc entries. Any
4264 section that was actually installed in the BFD, and has type
4265 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4266 considered to be a dynamic reloc section. */
4269 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
4275 if (elf_dynsymtab (abfd
) == 0)
4277 bfd_set_error (bfd_error_invalid_operation
);
4281 ret
= sizeof (arelent
*);
4282 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4283 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4284 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4285 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4286 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
4287 * sizeof (arelent
*));
4292 /* Canonicalize the dynamic relocation entries. Note that we return
4293 the dynamic relocations as a single block, although they are
4294 actually associated with particular sections; the interface, which
4295 was designed for SunOS style shared libraries, expects that there
4296 is only one set of dynamic relocs. Any section that was actually
4297 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4298 the dynamic symbol table, is considered to be a dynamic reloc
4302 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
4307 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
4311 if (elf_dynsymtab (abfd
) == 0)
4313 bfd_set_error (bfd_error_invalid_operation
);
4317 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
4319 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4321 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4322 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4323 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4328 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
4330 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
4332 for (i
= 0; i
< count
; i
++)
4343 /* Read in the version information. */
4346 _bfd_elf_slurp_version_tables (abfd
)
4349 bfd_byte
*contents
= NULL
;
4351 if (elf_dynverdef (abfd
) != 0)
4353 Elf_Internal_Shdr
*hdr
;
4354 Elf_External_Verdef
*everdef
;
4355 Elf_Internal_Verdef
*iverdef
;
4358 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
4360 elf_tdata (abfd
)->verdef
=
4361 ((Elf_Internal_Verdef
*)
4362 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
4363 if (elf_tdata (abfd
)->verdef
== NULL
)
4366 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
4368 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4369 if (contents
== NULL
)
4371 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4372 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4375 everdef
= (Elf_External_Verdef
*) contents
;
4376 iverdef
= elf_tdata (abfd
)->verdef
;
4377 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
4379 Elf_External_Verdaux
*everdaux
;
4380 Elf_Internal_Verdaux
*iverdaux
;
4383 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
4385 iverdef
->vd_bfd
= abfd
;
4387 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
4390 * sizeof (Elf_Internal_Verdaux
))));
4391 if (iverdef
->vd_auxptr
== NULL
)
4394 everdaux
= ((Elf_External_Verdaux
*)
4395 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
4396 iverdaux
= iverdef
->vd_auxptr
;
4397 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
4399 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
4401 iverdaux
->vda_nodename
=
4402 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4403 iverdaux
->vda_name
);
4404 if (iverdaux
->vda_nodename
== NULL
)
4407 if (j
+ 1 < iverdef
->vd_cnt
)
4408 iverdaux
->vda_nextptr
= iverdaux
+ 1;
4410 iverdaux
->vda_nextptr
= NULL
;
4412 everdaux
= ((Elf_External_Verdaux
*)
4413 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
4416 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
4418 if (i
+ 1 < hdr
->sh_info
)
4419 iverdef
->vd_nextdef
= iverdef
+ 1;
4421 iverdef
->vd_nextdef
= NULL
;
4423 everdef
= ((Elf_External_Verdef
*)
4424 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
4431 if (elf_dynverref (abfd
) != 0)
4433 Elf_Internal_Shdr
*hdr
;
4434 Elf_External_Verneed
*everneed
;
4435 Elf_Internal_Verneed
*iverneed
;
4438 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
4440 elf_tdata (abfd
)->verref
=
4441 ((Elf_Internal_Verneed
*)
4442 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
4443 if (elf_tdata (abfd
)->verref
== NULL
)
4446 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4448 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4449 if (contents
== NULL
)
4451 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4452 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4455 everneed
= (Elf_External_Verneed
*) contents
;
4456 iverneed
= elf_tdata (abfd
)->verref
;
4457 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4459 Elf_External_Vernaux
*evernaux
;
4460 Elf_Internal_Vernaux
*ivernaux
;
4463 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4465 iverneed
->vn_bfd
= abfd
;
4467 iverneed
->vn_filename
=
4468 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4470 if (iverneed
->vn_filename
== NULL
)
4473 iverneed
->vn_auxptr
=
4474 ((Elf_Internal_Vernaux
*)
4476 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4478 evernaux
= ((Elf_External_Vernaux
*)
4479 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4480 ivernaux
= iverneed
->vn_auxptr
;
4481 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4483 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4485 ivernaux
->vna_nodename
=
4486 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4487 ivernaux
->vna_name
);
4488 if (ivernaux
->vna_nodename
== NULL
)
4491 if (j
+ 1 < iverneed
->vn_cnt
)
4492 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4494 ivernaux
->vna_nextptr
= NULL
;
4496 evernaux
= ((Elf_External_Vernaux
*)
4497 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4500 if (i
+ 1 < hdr
->sh_info
)
4501 iverneed
->vn_nextref
= iverneed
+ 1;
4503 iverneed
->vn_nextref
= NULL
;
4505 everneed
= ((Elf_External_Verneed
*)
4506 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4516 if (contents
== NULL
)
4522 _bfd_elf_make_empty_symbol (abfd
)
4525 elf_symbol_type
*newsym
;
4527 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4532 newsym
->symbol
.the_bfd
= abfd
;
4533 return &newsym
->symbol
;
4538 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4539 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
4543 bfd_symbol_info (symbol
, ret
);
4546 /* Return whether a symbol name implies a local symbol. Most targets
4547 use this function for the is_local_label_name entry point, but some
4551 _bfd_elf_is_local_label_name (abfd
, name
)
4552 bfd
*abfd ATTRIBUTE_UNUSED
;
4555 /* Normal local symbols start with ``.L''. */
4556 if (name
[0] == '.' && name
[1] == 'L')
4559 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4560 DWARF debugging symbols starting with ``..''. */
4561 if (name
[0] == '.' && name
[1] == '.')
4564 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4565 emitting DWARF debugging output. I suspect this is actually a
4566 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4567 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4568 underscore to be emitted on some ELF targets). For ease of use,
4569 we treat such symbols as local. */
4570 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4577 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4578 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
4579 asymbol
*symbol ATTRIBUTE_UNUSED
;
4586 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4588 enum bfd_architecture arch
;
4589 unsigned long machine
;
4591 /* If this isn't the right architecture for this backend, and this
4592 isn't the generic backend, fail. */
4593 if (arch
!= get_elf_backend_data (abfd
)->arch
4594 && arch
!= bfd_arch_unknown
4595 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4598 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4601 /* Find the nearest line to a particular section and offset, for error
4605 _bfd_elf_find_nearest_line (abfd
,
4616 CONST
char **filename_ptr
;
4617 CONST
char **functionname_ptr
;
4618 unsigned int *line_ptr
;
4621 const char *filename
;
4626 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
4627 filename_ptr
, functionname_ptr
,
4631 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4632 filename_ptr
, functionname_ptr
,
4636 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4637 &found
, filename_ptr
,
4638 functionname_ptr
, line_ptr
,
4639 &elf_tdata (abfd
)->line_info
))
4644 if (symbols
== NULL
)
4651 for (p
= symbols
; *p
!= NULL
; p
++)
4655 q
= (elf_symbol_type
*) *p
;
4657 if (bfd_get_section (&q
->symbol
) != section
)
4660 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4665 filename
= bfd_asymbol_name (&q
->symbol
);
4669 if (q
->symbol
.section
== section
4670 && q
->symbol
.value
>= low_func
4671 && q
->symbol
.value
<= offset
)
4673 func
= (asymbol
*) q
;
4674 low_func
= q
->symbol
.value
;
4683 *filename_ptr
= filename
;
4684 *functionname_ptr
= bfd_asymbol_name (func
);
4690 _bfd_elf_sizeof_headers (abfd
, reloc
)
4696 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4698 ret
+= get_program_header_size (abfd
);
4703 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4708 bfd_size_type count
;
4710 Elf_Internal_Shdr
*hdr
;
4712 if (! abfd
->output_has_begun
4713 && ! _bfd_elf_compute_section_file_positions
4714 (abfd
, (struct bfd_link_info
*) NULL
))
4717 hdr
= &elf_section_data (section
)->this_hdr
;
4719 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4721 if (bfd_write (location
, 1, count
, abfd
) != count
)
4728 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4729 bfd
*abfd ATTRIBUTE_UNUSED
;
4730 arelent
*cache_ptr ATTRIBUTE_UNUSED
;
4731 Elf_Internal_Rela
*dst ATTRIBUTE_UNUSED
;
4738 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4741 Elf_Internal_Rel
*dst
;
4747 /* Try to convert a non-ELF reloc into an ELF one. */
4750 _bfd_elf_validate_reloc (abfd
, areloc
)
4754 /* Check whether we really have an ELF howto. */
4756 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4758 bfd_reloc_code_real_type code
;
4759 reloc_howto_type
*howto
;
4761 /* Alien reloc: Try to determine its type to replace it with an
4762 equivalent ELF reloc. */
4764 if (areloc
->howto
->pc_relative
)
4766 switch (areloc
->howto
->bitsize
)
4769 code
= BFD_RELOC_8_PCREL
;
4772 code
= BFD_RELOC_12_PCREL
;
4775 code
= BFD_RELOC_16_PCREL
;
4778 code
= BFD_RELOC_24_PCREL
;
4781 code
= BFD_RELOC_32_PCREL
;
4784 code
= BFD_RELOC_64_PCREL
;
4790 howto
= bfd_reloc_type_lookup (abfd
, code
);
4792 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4794 if (howto
->pcrel_offset
)
4795 areloc
->addend
+= areloc
->address
;
4797 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4802 switch (areloc
->howto
->bitsize
)
4808 code
= BFD_RELOC_14
;
4811 code
= BFD_RELOC_16
;
4814 code
= BFD_RELOC_26
;
4817 code
= BFD_RELOC_32
;
4820 code
= BFD_RELOC_64
;
4826 howto
= bfd_reloc_type_lookup (abfd
, code
);
4830 areloc
->howto
= howto
;
4838 (*_bfd_error_handler
)
4839 (_("%s: unsupported relocation type %s"),
4840 bfd_get_filename (abfd
), areloc
->howto
->name
);
4841 bfd_set_error (bfd_error_bad_value
);
4846 _bfd_elf_close_and_cleanup (abfd
)
4849 if (bfd_get_format (abfd
) == bfd_object
)
4851 if (elf_shstrtab (abfd
) != NULL
)
4852 _bfd_stringtab_free (elf_shstrtab (abfd
));
4855 return _bfd_generic_close_and_cleanup (abfd
);
4858 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
4859 in the relocation's offset. Thus we cannot allow any sort of sanity
4860 range-checking to interfere. There is nothing else to do in processing
4863 bfd_reloc_status_type
4864 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
4865 bfd
*abfd ATTRIBUTE_UNUSED
;
4866 arelent
*re ATTRIBUTE_UNUSED
;
4867 struct symbol_cache_entry
*symbol ATTRIBUTE_UNUSED
;
4868 PTR data ATTRIBUTE_UNUSED
;
4869 asection
*is ATTRIBUTE_UNUSED
;
4870 bfd
*obfd ATTRIBUTE_UNUSED
;
4871 char **errmsg ATTRIBUTE_UNUSED
;
4873 return bfd_reloc_ok
;
4877 /* Elf core file support. Much of this only works on native
4878 toolchains, since we rely on knowing the
4879 machine-dependent procfs structure in order to pick
4880 out details about the corefile. */
4882 #ifdef HAVE_SYS_PROCFS_H
4883 # include <sys/procfs.h>
4887 /* Define offsetof for those systems which lack it. */
4890 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
4894 /* FIXME: this is kinda wrong, but it's what gdb wants. */
4897 elfcore_make_pid (abfd
)
4900 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
4901 + (elf_tdata (abfd
)->core_pid
));
4905 /* If there isn't a section called NAME, make one, using
4906 data from SECT. Note, this function will generate a
4907 reference to NAME, so you shouldn't deallocate or
4911 elfcore_maybe_make_sect (abfd
, name
, sect
)
4918 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
4921 sect2
= bfd_make_section (abfd
, name
);
4925 sect2
->_raw_size
= sect
->_raw_size
;
4926 sect2
->filepos
= sect
->filepos
;
4927 sect2
->flags
= sect
->flags
;
4928 sect2
->alignment_power
= sect
->alignment_power
;
4933 /* prstatus_t exists on:
4935 linux 2.[01] + glibc
4939 #if defined (HAVE_PRSTATUS_T)
4941 elfcore_grok_prstatus (abfd
, note
)
4943 Elf_Internal_Note
* note
;
4950 if (note
->descsz
!= sizeof (prstat
))
4953 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
4955 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
4956 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
4958 /* pr_who exists on:
4961 pr_who doesn't exist on:
4964 #if defined (HAVE_PRSTATUS_T_PR_WHO)
4965 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
4968 /* Make a ".reg/999" section. */
4970 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
4971 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
4976 sect
= bfd_make_section (abfd
, name
);
4979 sect
->_raw_size
= sizeof (prstat
.pr_reg
);
4980 sect
->filepos
= note
->descpos
+ offsetof (prstatus_t
, pr_reg
);
4981 sect
->flags
= SEC_HAS_CONTENTS
;
4982 sect
->alignment_power
= 2;
4984 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
4989 #endif /* defined (HAVE_PRSTATUS_T) */
4992 /* There isn't a consistent prfpregset_t across platforms,
4993 but it doesn't matter, because we don't have to pick this
4994 data structure apart. */
4997 elfcore_grok_prfpreg (abfd
, note
)
4999 Elf_Internal_Note
* note
;
5005 /* Make a ".reg2/999" section. */
5007 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
5008 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5013 sect
= bfd_make_section (abfd
, name
);
5016 sect
->_raw_size
= note
->descsz
;
5017 sect
->filepos
= note
->descpos
;
5018 sect
->flags
= SEC_HAS_CONTENTS
;
5019 sect
->alignment_power
= 2;
5021 if (! elfcore_maybe_make_sect (abfd
, ".reg2", sect
))
5027 #if defined (HAVE_PRPSINFO_T)
5028 # define elfcore_psinfo_t prpsinfo_t
5031 #if defined (HAVE_PSINFO_T)
5032 # define elfcore_psinfo_t psinfo_t
5036 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5038 /* return a malloc'ed copy of a string at START which is at
5039 most MAX bytes long, possibly without a terminating '\0'.
5040 the copy will always have a terminating '\0'. */
5043 elfcore_strndup (abfd
, start
, max
)
5049 char* end
= memchr (start
, '\0', max
);
5057 dup
= bfd_alloc (abfd
, len
+ 1);
5061 memcpy (dup
, start
, len
);
5068 elfcore_grok_psinfo (abfd
, note
)
5070 Elf_Internal_Note
* note
;
5072 elfcore_psinfo_t psinfo
;
5074 if (note
->descsz
!= sizeof (elfcore_psinfo_t
))
5077 memcpy (&psinfo
, note
->descdata
, note
->descsz
);
5079 elf_tdata (abfd
)->core_program
5080 = elfcore_strndup (abfd
, psinfo
.pr_fname
, sizeof (psinfo
.pr_fname
));
5082 elf_tdata (abfd
)->core_command
5083 = elfcore_strndup (abfd
, psinfo
.pr_psargs
, sizeof (psinfo
.pr_psargs
));
5085 /* Note that for some reason, a spurious space is tacked
5086 onto the end of the args in some (at least one anyway)
5087 implementations, so strip it off if it exists. */
5090 char* command
= elf_tdata (abfd
)->core_command
;
5091 int n
= strlen (command
);
5093 if (0 < n
&& command
[n
- 1] == ' ')
5094 command
[n
- 1] = '\0';
5099 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5102 #if defined (HAVE_PSTATUS_T)
5104 elfcore_grok_pstatus (abfd
, note
)
5106 Elf_Internal_Note
* note
;
5110 if (note
->descsz
!= sizeof (pstat
))
5113 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
5115 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
5117 /* Could grab some more details from the "representative"
5118 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5119 NT_LWPSTATUS note, presumably. */
5123 #endif /* defined (HAVE_PSTATUS_T) */
5126 #if defined (HAVE_LWPSTATUS_T)
5128 elfcore_grok_lwpstatus (abfd
, note
)
5130 Elf_Internal_Note
* note
;
5132 lwpstatus_t lwpstat
;
5137 if (note
->descsz
!= sizeof (lwpstat
))
5140 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
5142 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
5143 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
5145 /* Make a ".reg/999" section. */
5147 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
5148 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5153 sect
= bfd_make_section (abfd
, name
);
5157 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5158 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
5159 sect
->filepos
= note
->descpos
5160 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
5163 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5164 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
5165 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
5168 sect
->flags
= SEC_HAS_CONTENTS
;
5169 sect
->alignment_power
= 2;
5171 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5174 /* Make a ".reg2/999" section */
5176 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
5177 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5182 sect
= bfd_make_section (abfd
, name
);
5186 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5187 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
5188 sect
->filepos
= note
->descpos
5189 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
5192 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5193 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
5194 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
5197 sect
->flags
= SEC_HAS_CONTENTS
;
5198 sect
->alignment_power
= 2;
5200 if (!elfcore_maybe_make_sect (abfd
, ".reg2", sect
))
5205 #endif /* defined (HAVE_LWPSTATUS_T) */
5210 elfcore_grok_note (abfd
, note
)
5212 Elf_Internal_Note
* note
;
5219 #if defined (HAVE_PRSTATUS_T)
5221 return elfcore_grok_prstatus (abfd
, note
);
5224 #if defined (HAVE_PSTATUS_T)
5226 return elfcore_grok_pstatus (abfd
, note
);
5229 #if defined (HAVE_LWPSTATUS_T)
5231 return elfcore_grok_lwpstatus (abfd
, note
);
5234 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
5235 return elfcore_grok_prfpreg (abfd
, note
);
5237 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5240 return elfcore_grok_psinfo (abfd
, note
);
5247 elfcore_read_notes (abfd
, offset
, size
)
5258 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
5261 buf
= bfd_malloc ((size_t) size
);
5265 if (bfd_read (buf
, size
, 1, abfd
) != size
)
5273 while (p
< buf
+ size
)
5275 /* FIXME: bad alignment assumption. */
5276 Elf_External_Note
* xnp
= (Elf_External_Note
*) p
;
5277 Elf_Internal_Note in
;
5279 in
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->type
);
5281 in
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->namesz
);
5282 in
.namedata
= xnp
->name
;
5284 in
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->descsz
);
5285 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
5286 in
.descpos
= offset
+ (in
.descdata
- buf
);
5288 if (! elfcore_grok_note (abfd
, &in
))
5291 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
5301 _bfd_elfcore_section_from_phdr (abfd
, phdr
, sec_num
)
5303 Elf_Internal_Phdr
* phdr
;
5306 if (! bfd_section_from_phdr (abfd
, phdr
, sec_num
))
5309 if (phdr
->p_type
== PT_NOTE
5310 && ! elfcore_read_notes (abfd
, phdr
->p_offset
, phdr
->p_filesz
))