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 CONST
unsigned char *name
;
211 while ((ch
= *name
++) != '\0')
214 if ((g
= (h
& 0xf0000000)) != 0)
217 /* The ELF ABI says `h &= ~g', but this is equivalent in
218 this case and on some machines one insn instead of two. */
225 /* Read a specified number of bytes at a specified offset in an ELF
226 file, into a newly allocated buffer, and return a pointer to the
230 elf_read (abfd
, offset
, size
)
237 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
239 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
241 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
243 if (bfd_get_error () != bfd_error_system_call
)
244 bfd_set_error (bfd_error_file_truncated
);
251 bfd_elf_mkobject (abfd
)
254 /* this just does initialization */
255 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
256 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
257 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
258 if (elf_tdata (abfd
) == 0)
260 /* since everything is done at close time, do we need any
267 bfd_elf_mkcorefile (abfd
)
270 /* I think this can be done just like an object file. */
271 return bfd_elf_mkobject (abfd
);
275 bfd_elf_get_str_section (abfd
, shindex
)
277 unsigned int shindex
;
279 Elf_Internal_Shdr
**i_shdrp
;
280 char *shstrtab
= NULL
;
282 unsigned int shstrtabsize
;
284 i_shdrp
= elf_elfsections (abfd
);
285 if (i_shdrp
== 0 || i_shdrp
[shindex
] == 0)
288 shstrtab
= (char *) i_shdrp
[shindex
]->contents
;
289 if (shstrtab
== NULL
)
291 /* No cached one, attempt to read, and cache what we read. */
292 offset
= i_shdrp
[shindex
]->sh_offset
;
293 shstrtabsize
= i_shdrp
[shindex
]->sh_size
;
294 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
295 i_shdrp
[shindex
]->contents
= (PTR
) shstrtab
;
301 bfd_elf_string_from_elf_section (abfd
, shindex
, strindex
)
303 unsigned int shindex
;
304 unsigned int strindex
;
306 Elf_Internal_Shdr
*hdr
;
311 hdr
= elf_elfsections (abfd
)[shindex
];
313 if (hdr
->contents
== NULL
314 && bfd_elf_get_str_section (abfd
, shindex
) == NULL
)
317 if (strindex
>= hdr
->sh_size
)
319 (*_bfd_error_handler
)
320 (_("%s: invalid string offset %u >= %lu for section `%s'"),
321 bfd_get_filename (abfd
), strindex
, (unsigned long) hdr
->sh_size
,
322 ((shindex
== elf_elfheader(abfd
)->e_shstrndx
323 && strindex
== hdr
->sh_name
)
325 : elf_string_from_elf_strtab (abfd
, hdr
->sh_name
)));
329 return ((char *) hdr
->contents
) + strindex
;
332 /* Make a BFD section from an ELF section. We store a pointer to the
333 BFD section in the bfd_section field of the header. */
336 _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
)
338 Elf_Internal_Shdr
*hdr
;
344 if (hdr
->bfd_section
!= NULL
)
346 BFD_ASSERT (strcmp (name
,
347 bfd_get_section_name (abfd
, hdr
->bfd_section
)) == 0);
351 newsect
= bfd_make_section_anyway (abfd
, name
);
355 newsect
->filepos
= hdr
->sh_offset
;
357 if (! bfd_set_section_vma (abfd
, newsect
, hdr
->sh_addr
)
358 || ! bfd_set_section_size (abfd
, newsect
, hdr
->sh_size
)
359 || ! bfd_set_section_alignment (abfd
, newsect
,
360 bfd_log2 (hdr
->sh_addralign
)))
363 flags
= SEC_NO_FLAGS
;
364 if (hdr
->sh_type
!= SHT_NOBITS
)
365 flags
|= SEC_HAS_CONTENTS
;
366 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
369 if (hdr
->sh_type
!= SHT_NOBITS
)
372 if ((hdr
->sh_flags
& SHF_WRITE
) == 0)
373 flags
|= SEC_READONLY
;
374 if ((hdr
->sh_flags
& SHF_EXECINSTR
) != 0)
376 else if ((flags
& SEC_LOAD
) != 0)
379 /* The debugging sections appear to be recognized only by name, not
381 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
382 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
383 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
384 flags
|= SEC_DEBUGGING
;
386 /* As a GNU extension, if the name begins with .gnu.linkonce, we
387 only link a single copy of the section. This is used to support
388 g++. g++ will emit each template expansion in its own section.
389 The symbols will be defined as weak, so that multiple definitions
390 are permitted. The GNU linker extension is to actually discard
391 all but one of the sections. */
392 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
393 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
395 if (! bfd_set_section_flags (abfd
, newsect
, flags
))
398 if ((flags
& SEC_ALLOC
) != 0)
400 Elf_Internal_Phdr
*phdr
;
403 /* Look through the phdrs to see if we need to adjust the lma.
404 If all the p_paddr fields are zero, we ignore them, since
405 some ELF linkers produce such output. */
406 phdr
= elf_tdata (abfd
)->phdr
;
407 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
409 if (phdr
->p_paddr
!= 0)
412 if (i
< elf_elfheader (abfd
)->e_phnum
)
414 phdr
= elf_tdata (abfd
)->phdr
;
415 for (i
= 0; i
< elf_elfheader (abfd
)->e_phnum
; i
++, phdr
++)
417 if (phdr
->p_type
== PT_LOAD
418 && phdr
->p_vaddr
!= phdr
->p_paddr
419 && phdr
->p_vaddr
<= hdr
->sh_addr
420 && (phdr
->p_vaddr
+ phdr
->p_memsz
421 >= hdr
->sh_addr
+ hdr
->sh_size
)
422 && ((flags
& SEC_LOAD
) == 0
423 || (phdr
->p_offset
<= (bfd_vma
) hdr
->sh_offset
424 && (phdr
->p_offset
+ phdr
->p_filesz
425 >= hdr
->sh_offset
+ hdr
->sh_size
))))
427 newsect
->lma
+= phdr
->p_paddr
- phdr
->p_vaddr
;
434 hdr
->bfd_section
= newsect
;
435 elf_section_data (newsect
)->this_hdr
= *hdr
;
445 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
448 Helper functions for GDB to locate the string tables.
449 Since BFD hides string tables from callers, GDB needs to use an
450 internal hook to find them. Sun's .stabstr, in particular,
451 isn't even pointed to by the .stab section, so ordinary
452 mechanisms wouldn't work to find it, even if we had some.
455 struct elf_internal_shdr
*
456 bfd_elf_find_section (abfd
, name
)
460 Elf_Internal_Shdr
**i_shdrp
;
465 i_shdrp
= elf_elfsections (abfd
);
468 shstrtab
= bfd_elf_get_str_section
469 (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
470 if (shstrtab
!= NULL
)
472 max
= elf_elfheader (abfd
)->e_shnum
;
473 for (i
= 1; i
< max
; i
++)
474 if (!strcmp (&shstrtab
[i_shdrp
[i
]->sh_name
], name
))
481 const char *const bfd_elf_section_type_names
[] = {
482 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
483 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
484 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
487 /* ELF relocs are against symbols. If we are producing relocateable
488 output, and the reloc is against an external symbol, and nothing
489 has given us any additional addend, the resulting reloc will also
490 be against the same symbol. In such a case, we don't want to
491 change anything about the way the reloc is handled, since it will
492 all be done at final link time. Rather than put special case code
493 into bfd_perform_relocation, all the reloc types use this howto
494 function. It just short circuits the reloc if producing
495 relocateable output against an external symbol. */
498 bfd_reloc_status_type
499 bfd_elf_generic_reloc (abfd
,
507 arelent
*reloc_entry
;
510 asection
*input_section
;
512 char **error_message
;
514 if (output_bfd
!= (bfd
*) NULL
515 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
516 && (! reloc_entry
->howto
->partial_inplace
517 || reloc_entry
->addend
== 0))
519 reloc_entry
->address
+= input_section
->output_offset
;
523 return bfd_reloc_continue
;
526 /* Print out the program headers. */
529 _bfd_elf_print_private_bfd_data (abfd
, farg
)
533 FILE *f
= (FILE *) farg
;
534 Elf_Internal_Phdr
*p
;
536 bfd_byte
*dynbuf
= NULL
;
538 p
= elf_tdata (abfd
)->phdr
;
543 fprintf (f
, _("\nProgram Header:\n"));
544 c
= elf_elfheader (abfd
)->e_phnum
;
545 for (i
= 0; i
< c
; i
++, p
++)
552 case PT_NULL
: s
= "NULL"; break;
553 case PT_LOAD
: s
= "LOAD"; break;
554 case PT_DYNAMIC
: s
= "DYNAMIC"; break;
555 case PT_INTERP
: s
= "INTERP"; break;
556 case PT_NOTE
: s
= "NOTE"; break;
557 case PT_SHLIB
: s
= "SHLIB"; break;
558 case PT_PHDR
: s
= "PHDR"; break;
559 default: sprintf (buf
, "0x%lx", p
->p_type
); s
= buf
; break;
561 fprintf (f
, "%8s off 0x", s
);
562 fprintf_vma (f
, p
->p_offset
);
563 fprintf (f
, " vaddr 0x");
564 fprintf_vma (f
, p
->p_vaddr
);
565 fprintf (f
, " paddr 0x");
566 fprintf_vma (f
, p
->p_paddr
);
567 fprintf (f
, " align 2**%u\n", bfd_log2 (p
->p_align
));
568 fprintf (f
, " filesz 0x");
569 fprintf_vma (f
, p
->p_filesz
);
570 fprintf (f
, " memsz 0x");
571 fprintf_vma (f
, p
->p_memsz
);
572 fprintf (f
, " flags %c%c%c",
573 (p
->p_flags
& PF_R
) != 0 ? 'r' : '-',
574 (p
->p_flags
& PF_W
) != 0 ? 'w' : '-',
575 (p
->p_flags
& PF_X
) != 0 ? 'x' : '-');
576 if ((p
->p_flags
&~ (PF_R
| PF_W
| PF_X
)) != 0)
577 fprintf (f
, " %lx", p
->p_flags
&~ (PF_R
| PF_W
| PF_X
));
582 s
= bfd_get_section_by_name (abfd
, ".dynamic");
587 bfd_byte
*extdyn
, *extdynend
;
589 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
591 fprintf (f
, _("\nDynamic Section:\n"));
593 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
596 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
600 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
603 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
605 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
606 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
609 extdynend
= extdyn
+ s
->_raw_size
;
610 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
612 Elf_Internal_Dyn dyn
;
617 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
619 if (dyn
.d_tag
== DT_NULL
)
626 sprintf (ab
, "0x%lx", (unsigned long) dyn
.d_tag
);
630 case DT_NEEDED
: name
= "NEEDED"; stringp
= true; break;
631 case DT_PLTRELSZ
: name
= "PLTRELSZ"; break;
632 case DT_PLTGOT
: name
= "PLTGOT"; break;
633 case DT_HASH
: name
= "HASH"; break;
634 case DT_STRTAB
: name
= "STRTAB"; break;
635 case DT_SYMTAB
: name
= "SYMTAB"; break;
636 case DT_RELA
: name
= "RELA"; break;
637 case DT_RELASZ
: name
= "RELASZ"; break;
638 case DT_RELAENT
: name
= "RELAENT"; break;
639 case DT_STRSZ
: name
= "STRSZ"; break;
640 case DT_SYMENT
: name
= "SYMENT"; break;
641 case DT_INIT
: name
= "INIT"; break;
642 case DT_FINI
: name
= "FINI"; break;
643 case DT_SONAME
: name
= "SONAME"; stringp
= true; break;
644 case DT_RPATH
: name
= "RPATH"; stringp
= true; break;
645 case DT_SYMBOLIC
: name
= "SYMBOLIC"; break;
646 case DT_REL
: name
= "REL"; break;
647 case DT_RELSZ
: name
= "RELSZ"; break;
648 case DT_RELENT
: name
= "RELENT"; break;
649 case DT_PLTREL
: name
= "PLTREL"; break;
650 case DT_DEBUG
: name
= "DEBUG"; break;
651 case DT_TEXTREL
: name
= "TEXTREL"; break;
652 case DT_JMPREL
: name
= "JMPREL"; break;
653 case DT_AUXILIARY
: name
= "AUXILIARY"; stringp
= true; break;
654 case DT_FILTER
: name
= "FILTER"; stringp
= true; break;
655 case DT_VERSYM
: name
= "VERSYM"; break;
656 case DT_VERDEF
: name
= "VERDEF"; break;
657 case DT_VERDEFNUM
: name
= "VERDEFNUM"; break;
658 case DT_VERNEED
: name
= "VERNEED"; break;
659 case DT_VERNEEDNUM
: name
= "VERNEEDNUM"; break;
662 fprintf (f
, " %-11s ", name
);
664 fprintf (f
, "0x%lx", (unsigned long) dyn
.d_un
.d_val
);
669 string
= bfd_elf_string_from_elf_section (abfd
, link
,
673 fprintf (f
, "%s", string
);
682 if ((elf_dynverdef (abfd
) != 0 && elf_tdata (abfd
)->verdef
== NULL
)
683 || (elf_dynverref (abfd
) != 0 && elf_tdata (abfd
)->verref
== NULL
))
685 if (! _bfd_elf_slurp_version_tables (abfd
))
689 if (elf_dynverdef (abfd
) != 0)
691 Elf_Internal_Verdef
*t
;
693 fprintf (f
, _("\nVersion definitions:\n"));
694 for (t
= elf_tdata (abfd
)->verdef
; t
!= NULL
; t
= t
->vd_nextdef
)
696 fprintf (f
, "%d 0x%2.2x 0x%8.8lx %s\n", t
->vd_ndx
,
697 t
->vd_flags
, t
->vd_hash
, t
->vd_nodename
);
698 if (t
->vd_auxptr
->vda_nextptr
!= NULL
)
700 Elf_Internal_Verdaux
*a
;
703 for (a
= t
->vd_auxptr
->vda_nextptr
;
706 fprintf (f
, "%s ", a
->vda_nodename
);
712 if (elf_dynverref (abfd
) != 0)
714 Elf_Internal_Verneed
*t
;
716 fprintf (f
, _("\nVersion References:\n"));
717 for (t
= elf_tdata (abfd
)->verref
; t
!= NULL
; t
= t
->vn_nextref
)
719 Elf_Internal_Vernaux
*a
;
721 fprintf (f
, _(" required from %s:\n"), t
->vn_filename
);
722 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
723 fprintf (f
, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a
->vna_hash
,
724 a
->vna_flags
, a
->vna_other
, a
->vna_nodename
);
736 /* Display ELF-specific fields of a symbol. */
739 bfd_elf_print_symbol (abfd
, filep
, symbol
, how
)
743 bfd_print_symbol_type how
;
745 FILE *file
= (FILE *) filep
;
748 case bfd_print_symbol_name
:
749 fprintf (file
, "%s", symbol
->name
);
751 case bfd_print_symbol_more
:
752 fprintf (file
, "elf ");
753 fprintf_vma (file
, symbol
->value
);
754 fprintf (file
, " %lx", (long) symbol
->flags
);
756 case bfd_print_symbol_all
:
758 CONST
char *section_name
;
759 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
760 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
761 fprintf (file
, " %s\t", section_name
);
762 /* Print the "other" value for a symbol. For common symbols,
763 we've already printed the size; now print the alignment.
764 For other symbols, we have no specified alignment, and
765 we've printed the address; now print the size. */
767 (bfd_is_com_section (symbol
->section
)
768 ? ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_value
769 : ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_size
));
771 /* If we have version information, print it. */
772 if (elf_tdata (abfd
)->dynversym_section
!= 0
773 && (elf_tdata (abfd
)->dynverdef_section
!= 0
774 || elf_tdata (abfd
)->dynverref_section
!= 0))
777 const char *version_string
;
779 vernum
= ((elf_symbol_type
*) symbol
)->version
& VERSYM_VERSION
;
783 else if (vernum
== 1)
784 version_string
= "Base";
785 else if (vernum
<= elf_tdata (abfd
)->cverdefs
)
787 elf_tdata (abfd
)->verdef
[vernum
- 1].vd_nodename
;
790 Elf_Internal_Verneed
*t
;
793 for (t
= elf_tdata (abfd
)->verref
;
797 Elf_Internal_Vernaux
*a
;
799 for (a
= t
->vn_auxptr
; a
!= NULL
; a
= a
->vna_nextptr
)
801 if (a
->vna_other
== vernum
)
803 version_string
= a
->vna_nodename
;
810 if ((((elf_symbol_type
*) symbol
)->version
& VERSYM_HIDDEN
) == 0)
811 fprintf (file
, " %-11s", version_string
);
816 fprintf (file
, " (%s)", version_string
);
817 for (i
= 10 - strlen (version_string
); i
> 0; --i
)
822 /* If the st_other field is not zero, print it. */
823 if (((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
!= 0)
824 fprintf (file
, " 0x%02x",
826 ((elf_symbol_type
*) symbol
)->internal_elf_sym
.st_other
));
828 fprintf (file
, " %s", symbol
->name
);
834 /* Create an entry in an ELF linker hash table. */
836 struct bfd_hash_entry
*
837 _bfd_elf_link_hash_newfunc (entry
, table
, string
)
838 struct bfd_hash_entry
*entry
;
839 struct bfd_hash_table
*table
;
842 struct elf_link_hash_entry
*ret
= (struct elf_link_hash_entry
*) entry
;
844 /* Allocate the structure if it has not already been allocated by a
846 if (ret
== (struct elf_link_hash_entry
*) NULL
)
847 ret
= ((struct elf_link_hash_entry
*)
848 bfd_hash_allocate (table
, sizeof (struct elf_link_hash_entry
)));
849 if (ret
== (struct elf_link_hash_entry
*) NULL
)
850 return (struct bfd_hash_entry
*) ret
;
852 /* Call the allocation method of the superclass. */
853 ret
= ((struct elf_link_hash_entry
*)
854 _bfd_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
856 if (ret
!= (struct elf_link_hash_entry
*) NULL
)
858 /* Set local fields. */
862 ret
->dynstr_index
= 0;
864 ret
->got
.offset
= (bfd_vma
) -1;
865 ret
->plt
.offset
= (bfd_vma
) -1;
866 ret
->linker_section_pointer
= (elf_linker_section_pointers_t
*)0;
867 ret
->verinfo
.verdef
= NULL
;
868 ret
->vtable_entries_used
= NULL
;
869 ret
->vtable_entries_size
= 0;
870 ret
->vtable_parent
= NULL
;
871 ret
->type
= STT_NOTYPE
;
873 /* Assume that we have been called by a non-ELF symbol reader.
874 This flag is then reset by the code which reads an ELF input
875 file. This ensures that a symbol created by a non-ELF symbol
876 reader will have the flag set correctly. */
877 ret
->elf_link_hash_flags
= ELF_LINK_NON_ELF
;
880 return (struct bfd_hash_entry
*) ret
;
883 /* Initialize an ELF linker hash table. */
886 _bfd_elf_link_hash_table_init (table
, abfd
, newfunc
)
887 struct elf_link_hash_table
*table
;
889 struct bfd_hash_entry
*(*newfunc
) PARAMS ((struct bfd_hash_entry
*,
890 struct bfd_hash_table
*,
893 table
->dynamic_sections_created
= false;
894 table
->dynobj
= NULL
;
895 /* The first dynamic symbol is a dummy. */
896 table
->dynsymcount
= 1;
897 table
->dynstr
= NULL
;
898 table
->bucketcount
= 0;
899 table
->needed
= NULL
;
901 table
->stab_info
= NULL
;
902 return _bfd_link_hash_table_init (&table
->root
, abfd
, newfunc
);
905 /* Create an ELF linker hash table. */
907 struct bfd_link_hash_table
*
908 _bfd_elf_link_hash_table_create (abfd
)
911 struct elf_link_hash_table
*ret
;
913 ret
= ((struct elf_link_hash_table
*)
914 bfd_alloc (abfd
, sizeof (struct elf_link_hash_table
)));
915 if (ret
== (struct elf_link_hash_table
*) NULL
)
918 if (! _bfd_elf_link_hash_table_init (ret
, abfd
, _bfd_elf_link_hash_newfunc
))
920 bfd_release (abfd
, ret
);
927 /* This is a hook for the ELF emulation code in the generic linker to
928 tell the backend linker what file name to use for the DT_NEEDED
929 entry for a dynamic object. The generic linker passes name as an
930 empty string to indicate that no DT_NEEDED entry should be made. */
933 bfd_elf_set_dt_needed_name (abfd
, name
)
937 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
938 && bfd_get_format (abfd
) == bfd_object
)
939 elf_dt_name (abfd
) = name
;
942 /* Get the list of DT_NEEDED entries for a link. This is a hook for
943 the linker ELF emulation code. */
945 struct bfd_link_needed_list
*
946 bfd_elf_get_needed_list (abfd
, info
)
948 struct bfd_link_info
*info
;
950 if (info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
952 return elf_hash_table (info
)->needed
;
955 /* Get the name actually used for a dynamic object for a link. This
956 is the SONAME entry if there is one. Otherwise, it is the string
957 passed to bfd_elf_set_dt_needed_name, or it is the filename. */
960 bfd_elf_get_dt_soname (abfd
)
963 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
964 && bfd_get_format (abfd
) == bfd_object
)
965 return elf_dt_name (abfd
);
969 /* Get the list of DT_NEEDED entries from a BFD. This is a hook for
970 the ELF linker emulation code. */
973 bfd_elf_get_bfd_needed_list (abfd
, pneeded
)
975 struct bfd_link_needed_list
**pneeded
;
978 bfd_byte
*dynbuf
= NULL
;
981 bfd_byte
*extdyn
, *extdynend
;
983 void (*swap_dyn_in
) PARAMS ((bfd
*, const PTR
, Elf_Internal_Dyn
*));
987 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
988 || bfd_get_format (abfd
) != bfd_object
)
991 s
= bfd_get_section_by_name (abfd
, ".dynamic");
992 if (s
== NULL
|| s
->_raw_size
== 0)
995 dynbuf
= (bfd_byte
*) bfd_malloc (s
->_raw_size
);
999 if (! bfd_get_section_contents (abfd
, s
, (PTR
) dynbuf
, (file_ptr
) 0,
1003 elfsec
= _bfd_elf_section_from_bfd_section (abfd
, s
);
1007 link
= elf_elfsections (abfd
)[elfsec
]->sh_link
;
1009 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
1010 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
1013 extdynend
= extdyn
+ s
->_raw_size
;
1014 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
1016 Elf_Internal_Dyn dyn
;
1018 (*swap_dyn_in
) (abfd
, (PTR
) extdyn
, &dyn
);
1020 if (dyn
.d_tag
== DT_NULL
)
1023 if (dyn
.d_tag
== DT_NEEDED
)
1026 struct bfd_link_needed_list
*l
;
1028 string
= bfd_elf_string_from_elf_section (abfd
, link
,
1033 l
= (struct bfd_link_needed_list
*) bfd_alloc (abfd
, sizeof *l
);
1054 /* Allocate an ELF string table--force the first byte to be zero. */
1056 struct bfd_strtab_hash
*
1057 _bfd_elf_stringtab_init ()
1059 struct bfd_strtab_hash
*ret
;
1061 ret
= _bfd_stringtab_init ();
1066 loc
= _bfd_stringtab_add (ret
, "", true, false);
1067 BFD_ASSERT (loc
== 0 || loc
== (bfd_size_type
) -1);
1068 if (loc
== (bfd_size_type
) -1)
1070 _bfd_stringtab_free (ret
);
1077 /* ELF .o/exec file reading */
1079 /* Create a new bfd section from an ELF section header. */
1082 bfd_section_from_shdr (abfd
, shindex
)
1084 unsigned int shindex
;
1086 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
1087 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
1088 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1091 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
1093 switch (hdr
->sh_type
)
1096 /* Inactive section. Throw it away. */
1099 case SHT_PROGBITS
: /* Normal section with contents. */
1100 case SHT_DYNAMIC
: /* Dynamic linking information. */
1101 case SHT_NOBITS
: /* .bss section. */
1102 case SHT_HASH
: /* .hash section. */
1103 case SHT_NOTE
: /* .note section. */
1104 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1106 case SHT_SYMTAB
: /* A symbol table */
1107 if (elf_onesymtab (abfd
) == shindex
)
1110 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1111 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
1112 elf_onesymtab (abfd
) = shindex
;
1113 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
1114 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1115 abfd
->flags
|= HAS_SYMS
;
1117 /* Sometimes a shared object will map in the symbol table. If
1118 SHF_ALLOC is set, and this is a shared object, then we also
1119 treat this section as a BFD section. We can not base the
1120 decision purely on SHF_ALLOC, because that flag is sometimes
1121 set in a relocateable object file, which would confuse the
1123 if ((hdr
->sh_flags
& SHF_ALLOC
) != 0
1124 && (abfd
->flags
& DYNAMIC
) != 0
1125 && ! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1130 case SHT_DYNSYM
: /* A dynamic symbol table */
1131 if (elf_dynsymtab (abfd
) == shindex
)
1134 BFD_ASSERT (hdr
->sh_entsize
== bed
->s
->sizeof_sym
);
1135 BFD_ASSERT (elf_dynsymtab (abfd
) == 0);
1136 elf_dynsymtab (abfd
) = shindex
;
1137 elf_tdata (abfd
)->dynsymtab_hdr
= *hdr
;
1138 elf_elfsections (abfd
)[shindex
] = hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1139 abfd
->flags
|= HAS_SYMS
;
1141 /* Besides being a symbol table, we also treat this as a regular
1142 section, so that objcopy can handle it. */
1143 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1145 case SHT_STRTAB
: /* A string table */
1146 if (hdr
->bfd_section
!= NULL
)
1148 if (ehdr
->e_shstrndx
== shindex
)
1150 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
1151 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
1157 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
1159 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
1160 if (hdr2
->sh_link
== shindex
)
1162 if (! bfd_section_from_shdr (abfd
, i
))
1164 if (elf_onesymtab (abfd
) == i
)
1166 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
1167 elf_elfsections (abfd
)[shindex
] =
1168 &elf_tdata (abfd
)->strtab_hdr
;
1171 if (elf_dynsymtab (abfd
) == i
)
1173 elf_tdata (abfd
)->dynstrtab_hdr
= *hdr
;
1174 elf_elfsections (abfd
)[shindex
] = hdr
=
1175 &elf_tdata (abfd
)->dynstrtab_hdr
;
1176 /* We also treat this as a regular section, so
1177 that objcopy can handle it. */
1180 #if 0 /* Not handling other string tables specially right now. */
1181 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
1182 /* We have a strtab for some random other section. */
1183 newsect
= (asection
*) hdr2
->bfd_section
;
1186 hdr
->bfd_section
= newsect
;
1187 hdr2
= &elf_section_data (newsect
)->str_hdr
;
1189 elf_elfsections (abfd
)[shindex
] = hdr2
;
1195 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1199 /* *These* do a lot of work -- but build no sections! */
1201 asection
*target_sect
;
1202 Elf_Internal_Shdr
*hdr2
;
1204 /* Check for a bogus link to avoid crashing. */
1205 if (hdr
->sh_link
>= ehdr
->e_shnum
)
1207 ((*_bfd_error_handler
)
1208 (_("%s: invalid link %lu for reloc section %s (index %u)"),
1209 bfd_get_filename (abfd
), hdr
->sh_link
, name
, shindex
));
1210 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1213 /* For some incomprehensible reason Oracle distributes
1214 libraries for Solaris in which some of the objects have
1215 bogus sh_link fields. It would be nice if we could just
1216 reject them, but, unfortunately, some people need to use
1217 them. We scan through the section headers; if we find only
1218 one suitable symbol table, we clobber the sh_link to point
1219 to it. I hope this doesn't break anything. */
1220 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_SYMTAB
1221 && elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
!= SHT_DYNSYM
)
1227 for (scan
= 1; scan
< ehdr
->e_shnum
; scan
++)
1229 if (elf_elfsections (abfd
)[scan
]->sh_type
== SHT_SYMTAB
1230 || elf_elfsections (abfd
)[scan
]->sh_type
== SHT_DYNSYM
)
1241 hdr
->sh_link
= found
;
1244 /* Get the symbol table. */
1245 if (elf_elfsections (abfd
)[hdr
->sh_link
]->sh_type
== SHT_SYMTAB
1246 && ! bfd_section_from_shdr (abfd
, hdr
->sh_link
))
1249 /* If this reloc section does not use the main symbol table we
1250 don't treat it as a reloc section. BFD can't adequately
1251 represent such a section, so at least for now, we don't
1252 try. We just present it as a normal section. */
1253 if (hdr
->sh_link
!= elf_onesymtab (abfd
))
1254 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1256 if (! bfd_section_from_shdr (abfd
, hdr
->sh_info
))
1258 target_sect
= bfd_section_from_elf_index (abfd
, hdr
->sh_info
);
1259 if (target_sect
== NULL
)
1262 if ((target_sect
->flags
& SEC_RELOC
) == 0
1263 || target_sect
->reloc_count
== 0)
1264 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
1267 BFD_ASSERT (elf_section_data (target_sect
)->rel_hdr2
== NULL
);
1268 hdr2
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, sizeof (*hdr2
));
1269 elf_section_data (target_sect
)->rel_hdr2
= hdr2
;
1272 elf_elfsections (abfd
)[shindex
] = hdr2
;
1273 target_sect
->reloc_count
+= hdr
->sh_size
/ hdr
->sh_entsize
;
1274 target_sect
->flags
|= SEC_RELOC
;
1275 target_sect
->relocation
= NULL
;
1276 target_sect
->rel_filepos
= hdr
->sh_offset
;
1277 /* In the section to which the relocations apply, mark whether
1278 its relocations are of the REL or RELA variety. */
1279 elf_section_data (target_sect
)->use_rela_p
1280 = (hdr
->sh_type
== SHT_RELA
);
1281 abfd
->flags
|= HAS_RELOC
;
1286 case SHT_GNU_verdef
:
1287 elf_dynverdef (abfd
) = shindex
;
1288 elf_tdata (abfd
)->dynverdef_hdr
= *hdr
;
1289 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1292 case SHT_GNU_versym
:
1293 elf_dynversym (abfd
) = shindex
;
1294 elf_tdata (abfd
)->dynversym_hdr
= *hdr
;
1295 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1298 case SHT_GNU_verneed
:
1299 elf_dynverref (abfd
) = shindex
;
1300 elf_tdata (abfd
)->dynverref_hdr
= *hdr
;
1301 return _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
);
1308 /* Check for any processor-specific section types. */
1310 if (bed
->elf_backend_section_from_shdr
)
1311 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
1319 /* Given an ELF section number, retrieve the corresponding BFD
1323 bfd_section_from_elf_index (abfd
, index
)
1327 BFD_ASSERT (index
> 0 && index
< SHN_LORESERVE
);
1328 if (index
>= elf_elfheader (abfd
)->e_shnum
)
1330 return elf_elfsections (abfd
)[index
]->bfd_section
;
1334 _bfd_elf_new_section_hook (abfd
, sec
)
1338 struct bfd_elf_section_data
*sdata
;
1340 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
1343 sec
->used_by_bfd
= (PTR
) sdata
;
1344 memset (sdata
, 0, sizeof (*sdata
));
1346 /* Indicate whether or not this section should use RELA relocations. */
1348 = get_elf_backend_data (abfd
)->default_use_rela_p
;
1353 /* Create a new bfd section from an ELF program header.
1355 Since program segments have no names, we generate a synthetic name
1356 of the form segment<NUM>, where NUM is generally the index in the
1357 program header table. For segments that are split (see below) we
1358 generate the names segment<NUM>a and segment<NUM>b.
1360 Note that some program segments may have a file size that is different than
1361 (less than) the memory size. All this means is that at execution the
1362 system must allocate the amount of memory specified by the memory size,
1363 but only initialize it with the first "file size" bytes read from the
1364 file. This would occur for example, with program segments consisting
1365 of combined data+bss.
1367 To handle the above situation, this routine generates TWO bfd sections
1368 for the single program segment. The first has the length specified by
1369 the file size of the segment, and the second has the length specified
1370 by the difference between the two sizes. In effect, the segment is split
1371 into it's initialized and uninitialized parts.
1376 bfd_section_from_phdr (abfd
, hdr
, index
)
1378 Elf_Internal_Phdr
*hdr
;
1386 split
= ((hdr
->p_memsz
> 0)
1387 && (hdr
->p_filesz
> 0)
1388 && (hdr
->p_memsz
> hdr
->p_filesz
));
1389 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
1390 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1393 strcpy (name
, namebuf
);
1394 newsect
= bfd_make_section (abfd
, name
);
1395 if (newsect
== NULL
)
1397 newsect
->vma
= hdr
->p_vaddr
;
1398 newsect
->lma
= hdr
->p_paddr
;
1399 newsect
->_raw_size
= hdr
->p_filesz
;
1400 newsect
->filepos
= hdr
->p_offset
;
1401 newsect
->flags
|= SEC_HAS_CONTENTS
;
1402 if (hdr
->p_type
== PT_LOAD
)
1404 newsect
->flags
|= SEC_ALLOC
;
1405 newsect
->flags
|= SEC_LOAD
;
1406 if (hdr
->p_flags
& PF_X
)
1408 /* FIXME: all we known is that it has execute PERMISSION,
1410 newsect
->flags
|= SEC_CODE
;
1413 if (!(hdr
->p_flags
& PF_W
))
1415 newsect
->flags
|= SEC_READONLY
;
1420 sprintf (namebuf
, "segment%db", index
);
1421 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
1424 strcpy (name
, namebuf
);
1425 newsect
= bfd_make_section (abfd
, name
);
1426 if (newsect
== NULL
)
1428 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
1429 newsect
->lma
= hdr
->p_paddr
+ hdr
->p_filesz
;
1430 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
1431 if (hdr
->p_type
== PT_LOAD
)
1433 newsect
->flags
|= SEC_ALLOC
;
1434 if (hdr
->p_flags
& PF_X
)
1435 newsect
->flags
|= SEC_CODE
;
1437 if (!(hdr
->p_flags
& PF_W
))
1438 newsect
->flags
|= SEC_READONLY
;
1444 /* Set up an ELF internal section header for a section. */
1448 elf_fake_sections (abfd
, asect
, failedptrarg
)
1453 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1454 boolean
*failedptr
= (boolean
*) failedptrarg
;
1455 Elf_Internal_Shdr
*this_hdr
;
1459 /* We already failed; just get out of the bfd_map_over_sections
1464 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1466 this_hdr
->sh_name
= (unsigned long) _bfd_stringtab_add (elf_shstrtab (abfd
),
1469 if (this_hdr
->sh_name
== (unsigned long) -1)
1475 this_hdr
->sh_flags
= 0;
1477 if ((asect
->flags
& SEC_ALLOC
) != 0
1478 || asect
->user_set_vma
)
1479 this_hdr
->sh_addr
= asect
->vma
;
1481 this_hdr
->sh_addr
= 0;
1483 this_hdr
->sh_offset
= 0;
1484 this_hdr
->sh_size
= asect
->_raw_size
;
1485 this_hdr
->sh_link
= 0;
1486 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1487 /* The sh_entsize and sh_info fields may have been set already by
1488 copy_private_section_data. */
1490 this_hdr
->bfd_section
= asect
;
1491 this_hdr
->contents
= NULL
;
1493 /* FIXME: This should not be based on section names. */
1494 if (strcmp (asect
->name
, ".dynstr") == 0)
1495 this_hdr
->sh_type
= SHT_STRTAB
;
1496 else if (strcmp (asect
->name
, ".hash") == 0)
1498 this_hdr
->sh_type
= SHT_HASH
;
1499 this_hdr
->sh_entsize
= bed
->s
->arch_size
/ 8;
1501 else if (strcmp (asect
->name
, ".dynsym") == 0)
1503 this_hdr
->sh_type
= SHT_DYNSYM
;
1504 this_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
1506 else if (strcmp (asect
->name
, ".dynamic") == 0)
1508 this_hdr
->sh_type
= SHT_DYNAMIC
;
1509 this_hdr
->sh_entsize
= bed
->s
->sizeof_dyn
;
1511 else if (strncmp (asect
->name
, ".rela", 5) == 0
1512 && get_elf_backend_data (abfd
)->may_use_rela_p
)
1514 this_hdr
->sh_type
= SHT_RELA
;
1515 this_hdr
->sh_entsize
= bed
->s
->sizeof_rela
;
1517 else if (strncmp (asect
->name
, ".rel", 4) == 0
1518 && get_elf_backend_data (abfd
)->may_use_rel_p
)
1520 this_hdr
->sh_type
= SHT_REL
;
1521 this_hdr
->sh_entsize
= bed
->s
->sizeof_rel
;
1523 else if (strncmp (asect
->name
, ".note", 5) == 0)
1524 this_hdr
->sh_type
= SHT_NOTE
;
1525 else if (strncmp (asect
->name
, ".stab", 5) == 0
1526 && strcmp (asect
->name
+ strlen (asect
->name
) - 3, "str") == 0)
1527 this_hdr
->sh_type
= SHT_STRTAB
;
1528 else if (strcmp (asect
->name
, ".gnu.version") == 0)
1530 this_hdr
->sh_type
= SHT_GNU_versym
;
1531 this_hdr
->sh_entsize
= sizeof (Elf_External_Versym
);
1533 else if (strcmp (asect
->name
, ".gnu.version_d") == 0)
1535 this_hdr
->sh_type
= SHT_GNU_verdef
;
1536 this_hdr
->sh_entsize
= 0;
1537 /* objcopy or strip will copy over sh_info, but may not set
1538 cverdefs. The linker will set cverdefs, but sh_info will be
1540 if (this_hdr
->sh_info
== 0)
1541 this_hdr
->sh_info
= elf_tdata (abfd
)->cverdefs
;
1543 BFD_ASSERT (elf_tdata (abfd
)->cverdefs
== 0
1544 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverdefs
);
1546 else if (strcmp (asect
->name
, ".gnu.version_r") == 0)
1548 this_hdr
->sh_type
= SHT_GNU_verneed
;
1549 this_hdr
->sh_entsize
= 0;
1550 /* objcopy or strip will copy over sh_info, but may not set
1551 cverrefs. The linker will set cverrefs, but sh_info will be
1553 if (this_hdr
->sh_info
== 0)
1554 this_hdr
->sh_info
= elf_tdata (abfd
)->cverrefs
;
1556 BFD_ASSERT (elf_tdata (abfd
)->cverrefs
== 0
1557 || this_hdr
->sh_info
== elf_tdata (abfd
)->cverrefs
);
1559 else if ((asect
->flags
& SEC_ALLOC
) != 0
1560 && (asect
->flags
& SEC_LOAD
) != 0)
1561 this_hdr
->sh_type
= SHT_PROGBITS
;
1562 else if ((asect
->flags
& SEC_ALLOC
) != 0
1563 && ((asect
->flags
& SEC_LOAD
) == 0))
1564 this_hdr
->sh_type
= SHT_NOBITS
;
1568 this_hdr
->sh_type
= SHT_PROGBITS
;
1571 if ((asect
->flags
& SEC_ALLOC
) != 0)
1572 this_hdr
->sh_flags
|= SHF_ALLOC
;
1573 if ((asect
->flags
& SEC_READONLY
) == 0)
1574 this_hdr
->sh_flags
|= SHF_WRITE
;
1575 if ((asect
->flags
& SEC_CODE
) != 0)
1576 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1578 /* Check for processor-specific section types. */
1579 if (bed
->elf_backend_fake_sections
)
1580 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1582 /* If the section has relocs, set up a section header for the
1583 SHT_REL[A] section. */
1584 if ((asect
->flags
& SEC_RELOC
) != 0)
1586 Elf_Internal_Shdr
*rela_hdr
;
1587 int use_rela_p
= elf_section_data (asect
)->use_rela_p
;
1590 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1591 name
= bfd_alloc (abfd
, sizeof ".rela" + strlen (asect
->name
));
1597 sprintf (name
, "%s%s", use_rela_p
? ".rela" : ".rel", asect
->name
);
1599 (unsigned int) _bfd_stringtab_add (elf_shstrtab (abfd
), name
,
1601 if (rela_hdr
->sh_name
== (unsigned int) -1)
1606 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1607 rela_hdr
->sh_entsize
= (use_rela_p
1608 ? bed
->s
->sizeof_rela
1609 : bed
->s
->sizeof_rel
);
1610 rela_hdr
->sh_addralign
= bed
->s
->file_align
;
1611 rela_hdr
->sh_flags
= 0;
1612 rela_hdr
->sh_addr
= 0;
1613 rela_hdr
->sh_size
= 0;
1614 rela_hdr
->sh_offset
= 0;
1618 /* Assign all ELF section numbers. The dummy first section is handled here
1619 too. The link/info pointers for the standard section types are filled
1620 in here too, while we're at it. */
1623 assign_section_numbers (abfd
)
1626 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1628 unsigned int section_number
;
1629 Elf_Internal_Shdr
**i_shdrp
;
1630 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1634 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1636 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1638 d
->this_idx
= section_number
++;
1639 if ((sec
->flags
& SEC_RELOC
) == 0)
1642 d
->rel_idx
= section_number
++;
1645 t
->shstrtab_section
= section_number
++;
1646 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1647 t
->shstrtab_hdr
.sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
1649 if (bfd_get_symcount (abfd
) > 0)
1651 t
->symtab_section
= section_number
++;
1652 t
->strtab_section
= section_number
++;
1655 elf_elfheader (abfd
)->e_shnum
= section_number
;
1657 /* Set up the list of section header pointers, in agreement with the
1659 i_shdrp
= ((Elf_Internal_Shdr
**)
1660 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*)));
1661 if (i_shdrp
== NULL
)
1664 i_shdrp
[0] = ((Elf_Internal_Shdr
*)
1665 bfd_alloc (abfd
, sizeof (Elf_Internal_Shdr
)));
1666 if (i_shdrp
[0] == NULL
)
1668 bfd_release (abfd
, i_shdrp
);
1671 memset (i_shdrp
[0], 0, sizeof (Elf_Internal_Shdr
));
1673 elf_elfsections (abfd
) = i_shdrp
;
1675 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1676 if (bfd_get_symcount (abfd
) > 0)
1678 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1679 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1680 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1682 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1684 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1688 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1689 if (d
->rel_idx
!= 0)
1690 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1692 /* Fill in the sh_link and sh_info fields while we're at it. */
1694 /* sh_link of a reloc section is the section index of the symbol
1695 table. sh_info is the section index of the section to which
1696 the relocation entries apply. */
1697 if (d
->rel_idx
!= 0)
1699 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1700 d
->rel_hdr
.sh_info
= d
->this_idx
;
1703 switch (d
->this_hdr
.sh_type
)
1707 /* A reloc section which we are treating as a normal BFD
1708 section. sh_link is the section index of the symbol
1709 table. sh_info is the section index of the section to
1710 which the relocation entries apply. We assume that an
1711 allocated reloc section uses the dynamic symbol table.
1712 FIXME: How can we be sure? */
1713 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1715 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1717 /* We look up the section the relocs apply to by name. */
1719 if (d
->this_hdr
.sh_type
== SHT_REL
)
1723 s
= bfd_get_section_by_name (abfd
, name
);
1725 d
->this_hdr
.sh_info
= elf_section_data (s
)->this_idx
;
1729 /* We assume that a section named .stab*str is a stabs
1730 string section. We look for a section with the same name
1731 but without the trailing ``str'', and set its sh_link
1732 field to point to this section. */
1733 if (strncmp (sec
->name
, ".stab", sizeof ".stab" - 1) == 0
1734 && strcmp (sec
->name
+ strlen (sec
->name
) - 3, "str") == 0)
1739 len
= strlen (sec
->name
);
1740 alc
= (char *) bfd_malloc (len
- 2);
1743 strncpy (alc
, sec
->name
, len
- 3);
1744 alc
[len
- 3] = '\0';
1745 s
= bfd_get_section_by_name (abfd
, alc
);
1749 elf_section_data (s
)->this_hdr
.sh_link
= d
->this_idx
;
1751 /* This is a .stab section. */
1752 elf_section_data (s
)->this_hdr
.sh_entsize
=
1753 4 + 2 * (bed
->s
->arch_size
/ 8);
1760 case SHT_GNU_verneed
:
1761 case SHT_GNU_verdef
:
1762 /* sh_link is the section header index of the string table
1763 used for the dynamic entries, or the symbol table, or the
1765 s
= bfd_get_section_by_name (abfd
, ".dynstr");
1767 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1771 case SHT_GNU_versym
:
1772 /* sh_link is the section header index of the symbol table
1773 this hash table or version table is for. */
1774 s
= bfd_get_section_by_name (abfd
, ".dynsym");
1776 d
->this_hdr
.sh_link
= elf_section_data (s
)->this_idx
;
1784 /* Map symbol from it's internal number to the external number, moving
1785 all local symbols to be at the head of the list. */
1788 sym_is_global (abfd
, sym
)
1792 /* If the backend has a special mapping, use it. */
1793 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1794 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1797 return ((sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
1798 || bfd_is_und_section (bfd_get_section (sym
))
1799 || bfd_is_com_section (bfd_get_section (sym
)));
1803 elf_map_symbols (abfd
)
1806 int symcount
= bfd_get_symcount (abfd
);
1807 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1808 asymbol
**sect_syms
;
1810 int num_globals
= 0;
1811 int num_locals2
= 0;
1812 int num_globals2
= 0;
1814 int num_sections
= 0;
1821 fprintf (stderr
, "elf_map_symbols\n");
1825 /* Add a section symbol for each BFD section. FIXME: Is this really
1827 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1829 if (max_index
< asect
->index
)
1830 max_index
= asect
->index
;
1834 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1835 if (sect_syms
== NULL
)
1837 elf_section_syms (abfd
) = sect_syms
;
1839 for (idx
= 0; idx
< symcount
; idx
++)
1843 if ((sym
->flags
& BSF_SECTION_SYM
) != 0
1850 if (sec
->owner
!= NULL
)
1852 if (sec
->owner
!= abfd
)
1854 if (sec
->output_offset
!= 0)
1857 sec
= sec
->output_section
;
1859 /* Empty sections in the input files may have had a section
1860 symbol created for them. (See the comment near the end of
1861 _bfd_generic_link_output_symbols in linker.c). If the linker
1862 script discards such sections then we will reach this point.
1863 Since we know that we cannot avoid this case, we detect it
1864 and skip the abort and the assignment to the sect_syms array.
1865 To reproduce this particular case try running the linker
1866 testsuite test ld-scripts/weak.exp for an ELF port that uses
1867 the generic linker. */
1868 if (sec
->owner
== NULL
)
1871 BFD_ASSERT (sec
->owner
== abfd
);
1873 sect_syms
[sec
->index
] = syms
[idx
];
1878 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1880 if (sect_syms
[asect
->index
] != NULL
)
1883 sym
= bfd_make_empty_symbol (abfd
);
1886 sym
->the_bfd
= abfd
;
1887 sym
->name
= asect
->name
;
1889 /* Set the flags to 0 to indicate that this one was newly added. */
1891 sym
->section
= asect
;
1892 sect_syms
[asect
->index
] = sym
;
1896 _("creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n"),
1897 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1901 /* Classify all of the symbols. */
1902 for (idx
= 0; idx
< symcount
; idx
++)
1904 if (!sym_is_global (abfd
, syms
[idx
]))
1909 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1911 if (sect_syms
[asect
->index
] != NULL
1912 && sect_syms
[asect
->index
]->flags
== 0)
1914 sect_syms
[asect
->index
]->flags
= BSF_SECTION_SYM
;
1915 if (!sym_is_global (abfd
, sect_syms
[asect
->index
]))
1919 sect_syms
[asect
->index
]->flags
= 0;
1923 /* Now sort the symbols so the local symbols are first. */
1924 new_syms
= ((asymbol
**)
1926 (num_locals
+ num_globals
) * sizeof (asymbol
*)));
1927 if (new_syms
== NULL
)
1930 for (idx
= 0; idx
< symcount
; idx
++)
1932 asymbol
*sym
= syms
[idx
];
1935 if (!sym_is_global (abfd
, sym
))
1938 i
= num_locals
+ num_globals2
++;
1940 sym
->udata
.i
= i
+ 1;
1942 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1944 if (sect_syms
[asect
->index
] != NULL
1945 && sect_syms
[asect
->index
]->flags
== 0)
1947 asymbol
*sym
= sect_syms
[asect
->index
];
1950 sym
->flags
= BSF_SECTION_SYM
;
1951 if (!sym_is_global (abfd
, sym
))
1954 i
= num_locals
+ num_globals2
++;
1956 sym
->udata
.i
= i
+ 1;
1960 bfd_set_symtab (abfd
, new_syms
, num_locals
+ num_globals
);
1962 elf_num_locals (abfd
) = num_locals
;
1963 elf_num_globals (abfd
) = num_globals
;
1967 /* Align to the maximum file alignment that could be required for any
1968 ELF data structure. */
1970 static INLINE file_ptr align_file_position
PARAMS ((file_ptr
, int));
1971 static INLINE file_ptr
1972 align_file_position (off
, align
)
1976 return (off
+ align
- 1) & ~(align
- 1);
1979 /* Assign a file position to a section, optionally aligning to the
1980 required section alignment. */
1983 _bfd_elf_assign_file_position_for_section (i_shdrp
, offset
, align
)
1984 Elf_Internal_Shdr
*i_shdrp
;
1992 al
= i_shdrp
->sh_addralign
;
1994 offset
= BFD_ALIGN (offset
, al
);
1996 i_shdrp
->sh_offset
= offset
;
1997 if (i_shdrp
->bfd_section
!= NULL
)
1998 i_shdrp
->bfd_section
->filepos
= offset
;
1999 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
2000 offset
+= i_shdrp
->sh_size
;
2004 /* Compute the file positions we are going to put the sections at, and
2005 otherwise prepare to begin writing out the ELF file. If LINK_INFO
2006 is not NULL, this is being called by the ELF backend linker. */
2009 _bfd_elf_compute_section_file_positions (abfd
, link_info
)
2011 struct bfd_link_info
*link_info
;
2013 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2015 struct bfd_strtab_hash
*strtab
;
2016 Elf_Internal_Shdr
*shstrtab_hdr
;
2018 if (abfd
->output_has_begun
)
2021 /* Do any elf backend specific processing first. */
2022 if (bed
->elf_backend_begin_write_processing
)
2023 (*bed
->elf_backend_begin_write_processing
) (abfd
, link_info
);
2025 if (! prep_headers (abfd
))
2028 /* Post process the headers if necessary. */
2029 if (bed
->elf_backend_post_process_headers
)
2030 (*bed
->elf_backend_post_process_headers
) (abfd
, link_info
);
2033 bfd_map_over_sections (abfd
, elf_fake_sections
, &failed
);
2037 if (!assign_section_numbers (abfd
))
2040 /* The backend linker builds symbol table information itself. */
2041 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2043 /* Non-zero if doing a relocatable link. */
2044 int relocatable_p
= ! (abfd
->flags
& (EXEC_P
| DYNAMIC
));
2046 if (! swap_out_syms (abfd
, &strtab
, relocatable_p
))
2050 shstrtab_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2051 /* sh_name was set in prep_headers. */
2052 shstrtab_hdr
->sh_type
= SHT_STRTAB
;
2053 shstrtab_hdr
->sh_flags
= 0;
2054 shstrtab_hdr
->sh_addr
= 0;
2055 shstrtab_hdr
->sh_size
= _bfd_stringtab_size (elf_shstrtab (abfd
));
2056 shstrtab_hdr
->sh_entsize
= 0;
2057 shstrtab_hdr
->sh_link
= 0;
2058 shstrtab_hdr
->sh_info
= 0;
2059 /* sh_offset is set in assign_file_positions_except_relocs. */
2060 shstrtab_hdr
->sh_addralign
= 1;
2062 if (!assign_file_positions_except_relocs (abfd
))
2065 if (link_info
== NULL
&& bfd_get_symcount (abfd
) > 0)
2068 Elf_Internal_Shdr
*hdr
;
2070 off
= elf_tdata (abfd
)->next_file_pos
;
2072 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2073 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2075 hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2076 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2078 elf_tdata (abfd
)->next_file_pos
= off
;
2080 /* Now that we know where the .strtab section goes, write it
2082 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
2083 || ! _bfd_stringtab_emit (abfd
, strtab
))
2085 _bfd_stringtab_free (strtab
);
2088 abfd
->output_has_begun
= true;
2093 /* Create a mapping from a set of sections to a program segment. */
2095 static INLINE
struct elf_segment_map
*
2096 make_mapping (abfd
, sections
, from
, to
, phdr
)
2098 asection
**sections
;
2103 struct elf_segment_map
*m
;
2107 m
= ((struct elf_segment_map
*)
2109 (sizeof (struct elf_segment_map
)
2110 + (to
- from
- 1) * sizeof (asection
*))));
2114 m
->p_type
= PT_LOAD
;
2115 for (i
= from
, hdrpp
= sections
+ from
; i
< to
; i
++, hdrpp
++)
2116 m
->sections
[i
- from
] = *hdrpp
;
2117 m
->count
= to
- from
;
2119 if (from
== 0 && phdr
)
2121 /* Include the headers in the first PT_LOAD segment. */
2122 m
->includes_filehdr
= 1;
2123 m
->includes_phdrs
= 1;
2129 /* Set up a mapping from BFD sections to program segments. */
2132 map_sections_to_segments (abfd
)
2135 asection
**sections
= NULL
;
2139 struct elf_segment_map
*mfirst
;
2140 struct elf_segment_map
**pm
;
2141 struct elf_segment_map
*m
;
2143 unsigned int phdr_index
;
2144 bfd_vma maxpagesize
;
2146 boolean phdr_in_segment
= true;
2150 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2153 if (bfd_count_sections (abfd
) == 0)
2156 /* Select the allocated sections, and sort them. */
2158 sections
= (asection
**) bfd_malloc (bfd_count_sections (abfd
)
2159 * sizeof (asection
*));
2160 if (sections
== NULL
)
2164 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2166 if ((s
->flags
& SEC_ALLOC
) != 0)
2172 BFD_ASSERT (i
<= bfd_count_sections (abfd
));
2175 qsort (sections
, (size_t) count
, sizeof (asection
*), elf_sort_sections
);
2177 /* Build the mapping. */
2182 /* If we have a .interp section, then create a PT_PHDR segment for
2183 the program headers and a PT_INTERP segment for the .interp
2185 s
= bfd_get_section_by_name (abfd
, ".interp");
2186 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2188 m
= ((struct elf_segment_map
*)
2189 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2193 m
->p_type
= PT_PHDR
;
2194 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
2195 m
->p_flags
= PF_R
| PF_X
;
2196 m
->p_flags_valid
= 1;
2197 m
->includes_phdrs
= 1;
2202 m
= ((struct elf_segment_map
*)
2203 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2207 m
->p_type
= PT_INTERP
;
2215 /* Look through the sections. We put sections in the same program
2216 segment when the start of the second section can be placed within
2217 a few bytes of the end of the first section. */
2220 maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
2222 dynsec
= bfd_get_section_by_name (abfd
, ".dynamic");
2224 && (dynsec
->flags
& SEC_LOAD
) == 0)
2227 /* Deal with -Ttext or something similar such that the first section
2228 is not adjacent to the program headers. This is an
2229 approximation, since at this point we don't know exactly how many
2230 program headers we will need. */
2233 bfd_size_type phdr_size
;
2235 phdr_size
= elf_tdata (abfd
)->program_header_size
;
2237 phdr_size
= get_elf_backend_data (abfd
)->s
->sizeof_phdr
;
2238 if ((abfd
->flags
& D_PAGED
) == 0
2239 || sections
[0]->lma
< phdr_size
2240 || sections
[0]->lma
% maxpagesize
< phdr_size
% maxpagesize
)
2241 phdr_in_segment
= false;
2244 for (i
= 0, hdrpp
= sections
; i
< count
; i
++, hdrpp
++)
2247 boolean new_segment
;
2251 /* See if this section and the last one will fit in the same
2254 if (last_hdr
== NULL
)
2256 /* If we don't have a segment yet, then we don't need a new
2257 one (we build the last one after this loop). */
2258 new_segment
= false;
2260 else if (last_hdr
->lma
- last_hdr
->vma
!= hdr
->lma
- hdr
->vma
)
2262 /* If this section has a different relation between the
2263 virtual address and the load address, then we need a new
2267 else if (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2268 < BFD_ALIGN (hdr
->lma
, maxpagesize
))
2270 /* If putting this section in this segment would force us to
2271 skip a page in the segment, then we need a new segment. */
2274 else if ((last_hdr
->flags
& SEC_LOAD
) == 0
2275 && (hdr
->flags
& SEC_LOAD
) != 0)
2277 /* We don't want to put a loadable section after a
2278 nonloadable section in the same segment. */
2281 else if ((abfd
->flags
& D_PAGED
) == 0)
2283 /* If the file is not demand paged, which means that we
2284 don't require the sections to be correctly aligned in the
2285 file, then there is no other reason for a new segment. */
2286 new_segment
= false;
2289 && (hdr
->flags
& SEC_READONLY
) == 0
2290 && (BFD_ALIGN (last_hdr
->lma
+ last_hdr
->_raw_size
, maxpagesize
)
2293 /* We don't want to put a writable section in a read only
2294 segment, unless they are on the same page in memory
2295 anyhow. We already know that the last section does not
2296 bring us past the current section on the page, so the
2297 only case in which the new section is not on the same
2298 page as the previous section is when the previous section
2299 ends precisely on a page boundary. */
2304 /* Otherwise, we can use the same segment. */
2305 new_segment
= false;
2310 if ((hdr
->flags
& SEC_READONLY
) == 0)
2316 /* We need a new program segment. We must create a new program
2317 header holding all the sections from phdr_index until hdr. */
2319 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2326 if ((hdr
->flags
& SEC_READONLY
) == 0)
2333 phdr_in_segment
= false;
2336 /* Create a final PT_LOAD program segment. */
2337 if (last_hdr
!= NULL
)
2339 m
= make_mapping (abfd
, sections
, phdr_index
, i
, phdr_in_segment
);
2347 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
2350 m
= ((struct elf_segment_map
*)
2351 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2355 m
->p_type
= PT_DYNAMIC
;
2357 m
->sections
[0] = dynsec
;
2363 /* For each loadable .note section, add a PT_NOTE segment. We don't
2364 use bfd_get_section_by_name, because if we link together
2365 nonloadable .note sections and loadable .note sections, we will
2366 generate two .note sections in the output file. FIXME: Using
2367 names for section types is bogus anyhow. */
2368 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2370 if ((s
->flags
& SEC_LOAD
) != 0
2371 && strncmp (s
->name
, ".note", 5) == 0)
2373 m
= ((struct elf_segment_map
*)
2374 bfd_zalloc (abfd
, sizeof (struct elf_segment_map
)));
2378 m
->p_type
= PT_NOTE
;
2390 elf_tdata (abfd
)->segment_map
= mfirst
;
2394 if (sections
!= NULL
)
2399 /* Sort sections by address. */
2402 elf_sort_sections (arg1
, arg2
)
2406 const asection
*sec1
= *(const asection
**) arg1
;
2407 const asection
*sec2
= *(const asection
**) arg2
;
2409 /* Sort by LMA first, since this is the address used to
2410 place the section into a segment. */
2411 if (sec1
->lma
< sec2
->lma
)
2413 else if (sec1
->lma
> sec2
->lma
)
2416 /* Then sort by VMA. Normally the LMA and the VMA will be
2417 the same, and this will do nothing. */
2418 if (sec1
->vma
< sec2
->vma
)
2420 else if (sec1
->vma
> sec2
->vma
)
2423 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
2425 #define TOEND(x) (((x)->flags & SEC_LOAD) == 0)
2430 return sec1
->target_index
- sec2
->target_index
;
2440 /* Sort by size, to put zero sized sections before others at the
2443 if (sec1
->_raw_size
< sec2
->_raw_size
)
2445 if (sec1
->_raw_size
> sec2
->_raw_size
)
2448 return sec1
->target_index
- sec2
->target_index
;
2451 /* Assign file positions to the sections based on the mapping from
2452 sections to segments. This function also sets up some fields in
2453 the file header, and writes out the program headers. */
2456 assign_file_positions_for_segments (abfd
)
2459 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2461 struct elf_segment_map
*m
;
2463 Elf_Internal_Phdr
*phdrs
;
2465 bfd_vma filehdr_vaddr
, filehdr_paddr
;
2466 bfd_vma phdrs_vaddr
, phdrs_paddr
;
2467 Elf_Internal_Phdr
*p
;
2469 if (elf_tdata (abfd
)->segment_map
== NULL
)
2471 if (! map_sections_to_segments (abfd
))
2475 if (bed
->elf_backend_modify_segment_map
)
2477 if (! (*bed
->elf_backend_modify_segment_map
) (abfd
))
2482 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2485 elf_elfheader (abfd
)->e_phoff
= bed
->s
->sizeof_ehdr
;
2486 elf_elfheader (abfd
)->e_phentsize
= bed
->s
->sizeof_phdr
;
2487 elf_elfheader (abfd
)->e_phnum
= count
;
2492 /* If we already counted the number of program segments, make sure
2493 that we allocated enough space. This happens when SIZEOF_HEADERS
2494 is used in a linker script. */
2495 alloc
= elf_tdata (abfd
)->program_header_size
/ bed
->s
->sizeof_phdr
;
2496 if (alloc
!= 0 && count
> alloc
)
2498 ((*_bfd_error_handler
)
2499 (_("%s: Not enough room for program headers (allocated %u, need %u)"),
2500 bfd_get_filename (abfd
), alloc
, count
));
2501 bfd_set_error (bfd_error_bad_value
);
2508 phdrs
= ((Elf_Internal_Phdr
*)
2509 bfd_alloc (abfd
, alloc
* sizeof (Elf_Internal_Phdr
)));
2513 off
= bed
->s
->sizeof_ehdr
;
2514 off
+= alloc
* bed
->s
->sizeof_phdr
;
2521 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2528 /* If elf_segment_map is not from map_sections_to_segments, the
2529 sections may not be correctly ordered. */
2531 qsort (m
->sections
, (size_t) m
->count
, sizeof (asection
*),
2534 p
->p_type
= m
->p_type
;
2536 if (m
->p_flags_valid
)
2537 p
->p_flags
= m
->p_flags
;
2541 if (p
->p_type
== PT_LOAD
2543 && (m
->sections
[0]->flags
& SEC_ALLOC
) != 0)
2545 if ((abfd
->flags
& D_PAGED
) != 0)
2546 off
+= (m
->sections
[0]->vma
- off
) % bed
->maxpagesize
;
2549 bfd_size_type align
;
2552 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2554 bfd_size_type secalign
;
2556 secalign
= bfd_get_section_alignment (abfd
, *secpp
);
2557 if (secalign
> align
)
2561 off
+= (m
->sections
[0]->vma
- off
) % (1 << align
);
2568 p
->p_vaddr
= m
->sections
[0]->vma
;
2570 if (m
->p_paddr_valid
)
2571 p
->p_paddr
= m
->p_paddr
;
2572 else if (m
->count
== 0)
2575 p
->p_paddr
= m
->sections
[0]->lma
;
2577 if (p
->p_type
== PT_LOAD
2578 && (abfd
->flags
& D_PAGED
) != 0)
2579 p
->p_align
= bed
->maxpagesize
;
2580 else if (m
->count
== 0)
2581 p
->p_align
= bed
->s
->file_align
;
2589 if (m
->includes_filehdr
)
2591 if (! m
->p_flags_valid
)
2594 p
->p_filesz
= bed
->s
->sizeof_ehdr
;
2595 p
->p_memsz
= bed
->s
->sizeof_ehdr
;
2598 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2600 if (p
->p_vaddr
< (bfd_vma
) off
)
2602 _bfd_error_handler (_("%s: Not enough room for program headers, try linking with -N"),
2603 bfd_get_filename (abfd
));
2604 bfd_set_error (bfd_error_bad_value
);
2609 if (! m
->p_paddr_valid
)
2612 if (p
->p_type
== PT_LOAD
)
2614 filehdr_vaddr
= p
->p_vaddr
;
2615 filehdr_paddr
= p
->p_paddr
;
2619 if (m
->includes_phdrs
)
2621 if (! m
->p_flags_valid
)
2624 if (m
->includes_filehdr
)
2626 if (p
->p_type
== PT_LOAD
)
2628 phdrs_vaddr
= p
->p_vaddr
+ bed
->s
->sizeof_ehdr
;
2629 phdrs_paddr
= p
->p_paddr
+ bed
->s
->sizeof_ehdr
;
2634 p
->p_offset
= bed
->s
->sizeof_ehdr
;
2638 BFD_ASSERT (p
->p_type
== PT_LOAD
);
2639 p
->p_vaddr
-= off
- p
->p_offset
;
2640 if (! m
->p_paddr_valid
)
2641 p
->p_paddr
-= off
- p
->p_offset
;
2644 if (p
->p_type
== PT_LOAD
)
2646 phdrs_vaddr
= p
->p_vaddr
;
2647 phdrs_paddr
= p
->p_paddr
;
2650 phdrs_vaddr
= bed
->maxpagesize
+ bed
->s
->sizeof_ehdr
;
2653 p
->p_filesz
+= alloc
* bed
->s
->sizeof_phdr
;
2654 p
->p_memsz
+= alloc
* bed
->s
->sizeof_phdr
;
2657 if (p
->p_type
== PT_LOAD
2658 || (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
))
2660 if (! m
->includes_filehdr
&& ! m
->includes_phdrs
)
2666 adjust
= off
- (p
->p_offset
+ p
->p_filesz
);
2667 p
->p_filesz
+= adjust
;
2668 p
->p_memsz
+= adjust
;
2674 for (i
= 0, secpp
= m
->sections
; i
< m
->count
; i
++, secpp
++)
2678 bfd_size_type align
;
2682 align
= 1 << bfd_get_section_alignment (abfd
, sec
);
2684 /* The section may have artificial alignment forced by a
2685 link script. Notice this case by the gap between the
2686 cumulative phdr vma and the section's vma. */
2687 if (p
->p_vaddr
+ p
->p_memsz
< sec
->vma
)
2689 bfd_vma adjust
= sec
->vma
- (p
->p_vaddr
+ p
->p_memsz
);
2691 p
->p_memsz
+= adjust
;
2694 if ((flags
& SEC_LOAD
) != 0)
2695 p
->p_filesz
+= adjust
;
2698 if (p
->p_type
== PT_LOAD
)
2700 bfd_signed_vma adjust
;
2702 if ((flags
& SEC_LOAD
) != 0)
2704 adjust
= sec
->lma
- (p
->p_paddr
+ p
->p_memsz
);
2708 else if ((flags
& SEC_ALLOC
) != 0)
2710 /* The section VMA must equal the file position
2711 modulo the page size. FIXME: I'm not sure if
2712 this adjustment is really necessary. We used to
2713 not have the SEC_LOAD case just above, and then
2714 this was necessary, but now I'm not sure. */
2715 if ((abfd
->flags
& D_PAGED
) != 0)
2716 adjust
= (sec
->vma
- voff
) % bed
->maxpagesize
;
2718 adjust
= (sec
->vma
- voff
) % align
;
2727 (* _bfd_error_handler
)
2728 (_("Error: First section in segment (%s) starts at 0x%x"),
2729 bfd_section_name (abfd
, sec
), sec
->lma
);
2730 (* _bfd_error_handler
)
2731 (_(" whereas segment starts at 0x%x"),
2736 p
->p_memsz
+= adjust
;
2739 if ((flags
& SEC_LOAD
) != 0)
2740 p
->p_filesz
+= adjust
;
2745 /* We check SEC_HAS_CONTENTS here because if NOLOAD is
2746 used in a linker script we may have a section with
2747 SEC_LOAD clear but which is supposed to have
2749 if ((flags
& SEC_LOAD
) != 0
2750 || (flags
& SEC_HAS_CONTENTS
) != 0)
2751 off
+= sec
->_raw_size
;
2753 if ((flags
& SEC_ALLOC
) != 0)
2754 voff
+= sec
->_raw_size
;
2757 if (p
->p_type
== PT_NOTE
&& bfd_get_format (abfd
) == bfd_core
)
2759 if (i
== 0) /* the actual "note" segment */
2760 { /* this one actually contains everything. */
2762 p
->p_filesz
= sec
->_raw_size
;
2763 off
+= sec
->_raw_size
;
2766 else /* fake sections -- don't need to be written */
2770 flags
= sec
->flags
= 0; /* no contents */
2777 p
->p_memsz
+= sec
->_raw_size
;
2779 if ((flags
& SEC_LOAD
) != 0)
2780 p
->p_filesz
+= sec
->_raw_size
;
2782 if (align
> p
->p_align
2783 && (p
->p_type
!= PT_LOAD
|| (abfd
->flags
& D_PAGED
) == 0))
2787 if (! m
->p_flags_valid
)
2790 if ((flags
& SEC_CODE
) != 0)
2792 if ((flags
& SEC_READONLY
) == 0)
2798 /* Now that we have set the section file positions, we can set up
2799 the file positions for the non PT_LOAD segments. */
2800 for (m
= elf_tdata (abfd
)->segment_map
, p
= phdrs
;
2804 if (p
->p_type
!= PT_LOAD
&& m
->count
> 0)
2806 BFD_ASSERT (! m
->includes_filehdr
&& ! m
->includes_phdrs
);
2807 p
->p_offset
= m
->sections
[0]->filepos
;
2811 if (m
->includes_filehdr
)
2813 p
->p_vaddr
= filehdr_vaddr
;
2814 if (! m
->p_paddr_valid
)
2815 p
->p_paddr
= filehdr_paddr
;
2817 else if (m
->includes_phdrs
)
2819 p
->p_vaddr
= phdrs_vaddr
;
2820 if (! m
->p_paddr_valid
)
2821 p
->p_paddr
= phdrs_paddr
;
2826 /* Clear out any program headers we allocated but did not use. */
2827 for (; count
< alloc
; count
++, p
++)
2829 memset (p
, 0, sizeof *p
);
2830 p
->p_type
= PT_NULL
;
2833 elf_tdata (abfd
)->phdr
= phdrs
;
2835 elf_tdata (abfd
)->next_file_pos
= off
;
2837 /* Write out the program headers. */
2838 if (bfd_seek (abfd
, bed
->s
->sizeof_ehdr
, SEEK_SET
) != 0
2839 || bed
->s
->write_out_phdrs (abfd
, phdrs
, alloc
) != 0)
2845 /* Get the size of the program header.
2847 If this is called by the linker before any of the section VMA's are set, it
2848 can't calculate the correct value for a strange memory layout. This only
2849 happens when SIZEOF_HEADERS is used in a linker script. In this case,
2850 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
2851 data segment (exclusive of .interp and .dynamic).
2853 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
2854 will be two segments. */
2856 static bfd_size_type
2857 get_program_header_size (abfd
)
2862 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2864 /* We can't return a different result each time we're called. */
2865 if (elf_tdata (abfd
)->program_header_size
!= 0)
2866 return elf_tdata (abfd
)->program_header_size
;
2868 if (elf_tdata (abfd
)->segment_map
!= NULL
)
2870 struct elf_segment_map
*m
;
2873 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2875 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2876 return elf_tdata (abfd
)->program_header_size
;
2879 /* Assume we will need exactly two PT_LOAD segments: one for text
2880 and one for data. */
2883 s
= bfd_get_section_by_name (abfd
, ".interp");
2884 if (s
!= NULL
&& (s
->flags
& SEC_LOAD
) != 0)
2886 /* If we have a loadable interpreter section, we need a
2887 PT_INTERP segment. In this case, assume we also need a
2888 PT_PHDR segment, although that may not be true for all
2893 if (bfd_get_section_by_name (abfd
, ".dynamic") != NULL
)
2895 /* We need a PT_DYNAMIC segment. */
2899 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2901 if ((s
->flags
& SEC_LOAD
) != 0
2902 && strncmp (s
->name
, ".note", 5) == 0)
2904 /* We need a PT_NOTE segment. */
2909 /* Let the backend count up any program headers it might need. */
2910 if (bed
->elf_backend_additional_program_headers
)
2914 a
= (*bed
->elf_backend_additional_program_headers
) (abfd
);
2920 elf_tdata (abfd
)->program_header_size
= segs
* bed
->s
->sizeof_phdr
;
2921 return elf_tdata (abfd
)->program_header_size
;
2924 /* Work out the file positions of all the sections. This is called by
2925 _bfd_elf_compute_section_file_positions. All the section sizes and
2926 VMAs must be known before this is called.
2928 We do not consider reloc sections at this point, unless they form
2929 part of the loadable image. Reloc sections are assigned file
2930 positions in assign_file_positions_for_relocs, which is called by
2931 write_object_contents and final_link.
2933 We also don't set the positions of the .symtab and .strtab here. */
2936 assign_file_positions_except_relocs (abfd
)
2939 struct elf_obj_tdata
* const tdata
= elf_tdata (abfd
);
2940 Elf_Internal_Ehdr
* const i_ehdrp
= elf_elfheader (abfd
);
2941 Elf_Internal_Shdr
** const i_shdrpp
= elf_elfsections (abfd
);
2943 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2945 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0
2946 && bfd_get_format (abfd
) != bfd_core
)
2948 Elf_Internal_Shdr
**hdrpp
;
2951 /* Start after the ELF header. */
2952 off
= i_ehdrp
->e_ehsize
;
2954 /* We are not creating an executable, which means that we are
2955 not creating a program header, and that the actual order of
2956 the sections in the file is unimportant. */
2957 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2959 Elf_Internal_Shdr
*hdr
;
2962 if (hdr
->sh_type
== SHT_REL
|| hdr
->sh_type
== SHT_RELA
)
2964 hdr
->sh_offset
= -1;
2967 if (i
== tdata
->symtab_section
2968 || i
== tdata
->strtab_section
)
2970 hdr
->sh_offset
= -1;
2974 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
2980 Elf_Internal_Shdr
**hdrpp
;
2982 /* Assign file positions for the loaded sections based on the
2983 assignment of sections to segments. */
2984 if (! assign_file_positions_for_segments (abfd
))
2987 /* Assign file positions for the other sections. */
2989 off
= elf_tdata (abfd
)->next_file_pos
;
2990 for (i
= 1, hdrpp
= i_shdrpp
+ 1; i
< i_ehdrp
->e_shnum
; i
++, hdrpp
++)
2992 Elf_Internal_Shdr
*hdr
;
2995 if (hdr
->bfd_section
!= NULL
2996 && hdr
->bfd_section
->filepos
!= 0)
2997 hdr
->sh_offset
= hdr
->bfd_section
->filepos
;
2998 else if ((hdr
->sh_flags
& SHF_ALLOC
) != 0)
3000 ((*_bfd_error_handler
)
3001 (_("%s: warning: allocated section `%s' not in segment"),
3002 bfd_get_filename (abfd
),
3003 (hdr
->bfd_section
== NULL
3005 : hdr
->bfd_section
->name
)));
3006 if ((abfd
->flags
& D_PAGED
) != 0)
3007 off
+= (hdr
->sh_addr
- off
) % bed
->maxpagesize
;
3009 off
+= (hdr
->sh_addr
- off
) % hdr
->sh_addralign
;
3010 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
,
3013 else if (hdr
->sh_type
== SHT_REL
3014 || hdr
->sh_type
== SHT_RELA
3015 || hdr
== i_shdrpp
[tdata
->symtab_section
]
3016 || hdr
== i_shdrpp
[tdata
->strtab_section
])
3017 hdr
->sh_offset
= -1;
3019 off
= _bfd_elf_assign_file_position_for_section (hdr
, off
, true);
3023 /* Place the section headers. */
3024 off
= align_file_position (off
, bed
->s
->file_align
);
3025 i_ehdrp
->e_shoff
= off
;
3026 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
3028 elf_tdata (abfd
)->next_file_pos
= off
;
3037 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3038 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
3039 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
3041 struct bfd_strtab_hash
*shstrtab
;
3042 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3044 i_ehdrp
= elf_elfheader (abfd
);
3045 i_shdrp
= elf_elfsections (abfd
);
3047 shstrtab
= _bfd_elf_stringtab_init ();
3048 if (shstrtab
== NULL
)
3051 elf_shstrtab (abfd
) = shstrtab
;
3053 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
3054 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
3055 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
3056 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
3058 i_ehdrp
->e_ident
[EI_CLASS
] = bed
->s
->elfclass
;
3059 i_ehdrp
->e_ident
[EI_DATA
] =
3060 bfd_big_endian (abfd
) ? ELFDATA2MSB
: ELFDATA2LSB
;
3061 i_ehdrp
->e_ident
[EI_VERSION
] = bed
->s
->ev_current
;
3063 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_SYSV
;
3064 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 0;
3066 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
3067 i_ehdrp
->e_ident
[count
] = 0;
3069 if ((abfd
->flags
& DYNAMIC
) != 0)
3070 i_ehdrp
->e_type
= ET_DYN
;
3071 else if ((abfd
->flags
& EXEC_P
) != 0)
3072 i_ehdrp
->e_type
= ET_EXEC
;
3073 else if (bfd_get_format (abfd
) == bfd_core
)
3074 i_ehdrp
->e_type
= ET_CORE
;
3076 i_ehdrp
->e_type
= ET_REL
;
3078 switch (bfd_get_arch (abfd
))
3080 case bfd_arch_unknown
:
3081 i_ehdrp
->e_machine
= EM_NONE
;
3083 case bfd_arch_sparc
:
3084 if (bed
->s
->arch_size
== 64)
3085 i_ehdrp
->e_machine
= EM_SPARCV9
;
3087 i_ehdrp
->e_machine
= EM_SPARC
;
3090 i_ehdrp
->e_machine
= EM_386
;
3093 i_ehdrp
->e_machine
= EM_68K
;
3096 i_ehdrp
->e_machine
= EM_88K
;
3099 i_ehdrp
->e_machine
= EM_860
;
3102 i_ehdrp
->e_machine
= EM_960
;
3104 case bfd_arch_mips
: /* MIPS Rxxxx */
3105 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
3108 i_ehdrp
->e_machine
= EM_PARISC
;
3110 case bfd_arch_powerpc
:
3111 i_ehdrp
->e_machine
= EM_PPC
;
3113 case bfd_arch_alpha
:
3114 i_ehdrp
->e_machine
= EM_ALPHA
;
3117 i_ehdrp
->e_machine
= EM_SH
;
3120 i_ehdrp
->e_machine
= EM_CYGNUS_D10V
;
3123 i_ehdrp
->e_machine
= EM_CYGNUS_D30V
;
3126 i_ehdrp
->e_machine
= EM_CYGNUS_FR30
;
3128 case bfd_arch_mcore
:
3129 i_ehdrp
->e_machine
= EM_MCORE
;
3132 switch (bfd_get_mach (abfd
))
3135 case 0: i_ehdrp
->e_machine
= EM_CYGNUS_V850
; break;
3139 i_ehdrp
->e_machine
= EM_CYGNUS_ARC
;
3142 i_ehdrp
->e_machine
= EM_ARM
;
3145 i_ehdrp
->e_machine
= EM_CYGNUS_M32R
;
3147 case bfd_arch_mn10200
:
3148 i_ehdrp
->e_machine
= EM_CYGNUS_MN10200
;
3150 case bfd_arch_mn10300
:
3151 i_ehdrp
->e_machine
= EM_CYGNUS_MN10300
;
3153 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
3155 i_ehdrp
->e_machine
= EM_NONE
;
3157 i_ehdrp
->e_version
= bed
->s
->ev_current
;
3158 i_ehdrp
->e_ehsize
= bed
->s
->sizeof_ehdr
;
3160 /* no program header, for now. */
3161 i_ehdrp
->e_phoff
= 0;
3162 i_ehdrp
->e_phentsize
= 0;
3163 i_ehdrp
->e_phnum
= 0;
3165 /* each bfd section is section header entry */
3166 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
3167 i_ehdrp
->e_shentsize
= bed
->s
->sizeof_shdr
;
3169 /* if we're building an executable, we'll need a program header table */
3170 if (abfd
->flags
& EXEC_P
)
3172 /* it all happens later */
3174 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
3176 /* elf_build_phdrs() returns a (NULL-terminated) array of
3177 Elf_Internal_Phdrs */
3178 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
3179 i_ehdrp
->e_phoff
= outbase
;
3180 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
3185 i_ehdrp
->e_phentsize
= 0;
3187 i_ehdrp
->e_phoff
= 0;
3190 elf_tdata (abfd
)->symtab_hdr
.sh_name
=
3191 (unsigned int) _bfd_stringtab_add (shstrtab
, ".symtab", true, false);
3192 elf_tdata (abfd
)->strtab_hdr
.sh_name
=
3193 (unsigned int) _bfd_stringtab_add (shstrtab
, ".strtab", true, false);
3194 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
=
3195 (unsigned int) _bfd_stringtab_add (shstrtab
, ".shstrtab", true, false);
3196 if (elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3197 || elf_tdata (abfd
)->symtab_hdr
.sh_name
== (unsigned int) -1
3198 || elf_tdata (abfd
)->shstrtab_hdr
.sh_name
== (unsigned int) -1)
3204 /* Assign file positions for all the reloc sections which are not part
3205 of the loadable file image. */
3208 _bfd_elf_assign_file_positions_for_relocs (abfd
)
3213 Elf_Internal_Shdr
**shdrpp
;
3215 off
= elf_tdata (abfd
)->next_file_pos
;
3217 for (i
= 1, shdrpp
= elf_elfsections (abfd
) + 1;
3218 i
< elf_elfheader (abfd
)->e_shnum
;
3221 Elf_Internal_Shdr
*shdrp
;
3224 if ((shdrp
->sh_type
== SHT_REL
|| shdrp
->sh_type
== SHT_RELA
)
3225 && shdrp
->sh_offset
== -1)
3226 off
= _bfd_elf_assign_file_position_for_section (shdrp
, off
, true);
3229 elf_tdata (abfd
)->next_file_pos
= off
;
3233 _bfd_elf_write_object_contents (abfd
)
3236 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3237 Elf_Internal_Ehdr
*i_ehdrp
;
3238 Elf_Internal_Shdr
**i_shdrp
;
3242 if (! abfd
->output_has_begun
3243 && ! _bfd_elf_compute_section_file_positions
3244 (abfd
, (struct bfd_link_info
*) NULL
))
3247 i_shdrp
= elf_elfsections (abfd
);
3248 i_ehdrp
= elf_elfheader (abfd
);
3251 bfd_map_over_sections (abfd
, bed
->s
->write_relocs
, &failed
);
3255 _bfd_elf_assign_file_positions_for_relocs (abfd
);
3257 /* After writing the headers, we need to write the sections too... */
3258 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
3260 if (bed
->elf_backend_section_processing
)
3261 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
3262 if (i_shdrp
[count
]->contents
)
3264 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
3265 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
3267 != i_shdrp
[count
]->sh_size
))
3272 /* Write out the section header names. */
3273 if (bfd_seek (abfd
, elf_tdata (abfd
)->shstrtab_hdr
.sh_offset
, SEEK_SET
) != 0
3274 || ! _bfd_stringtab_emit (abfd
, elf_shstrtab (abfd
)))
3277 if (bed
->elf_backend_final_write_processing
)
3278 (*bed
->elf_backend_final_write_processing
) (abfd
,
3279 elf_tdata (abfd
)->linker
);
3281 return bed
->s
->write_shdrs_and_ehdr (abfd
);
3285 _bfd_elf_write_corefile_contents (abfd
)
3288 /* Hopefully this can be done just like an object file. */
3289 return _bfd_elf_write_object_contents (abfd
);
3291 /* given a section, search the header to find them... */
3293 _bfd_elf_section_from_bfd_section (abfd
, asect
)
3297 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3298 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
3300 Elf_Internal_Shdr
*hdr
;
3301 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
3303 for (index
= 0; index
< maxindex
; index
++)
3305 hdr
= i_shdrp
[index
];
3306 if (hdr
->bfd_section
== asect
)
3310 if (bed
->elf_backend_section_from_bfd_section
)
3312 for (index
= 0; index
< maxindex
; index
++)
3316 hdr
= i_shdrp
[index
];
3318 if ((*bed
->elf_backend_section_from_bfd_section
)
3319 (abfd
, hdr
, asect
, &retval
))
3324 if (bfd_is_abs_section (asect
))
3326 if (bfd_is_com_section (asect
))
3328 if (bfd_is_und_section (asect
))
3331 bfd_set_error (bfd_error_nonrepresentable_section
);
3336 /* Given a BFD symbol, return the index in the ELF symbol table, or -1
3340 _bfd_elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
3342 asymbol
**asym_ptr_ptr
;
3344 asymbol
*asym_ptr
= *asym_ptr_ptr
;
3346 flagword flags
= asym_ptr
->flags
;
3348 /* When gas creates relocations against local labels, it creates its
3349 own symbol for the section, but does put the symbol into the
3350 symbol chain, so udata is 0. When the linker is generating
3351 relocatable output, this section symbol may be for one of the
3352 input sections rather than the output section. */
3353 if (asym_ptr
->udata
.i
== 0
3354 && (flags
& BSF_SECTION_SYM
)
3355 && asym_ptr
->section
)
3359 if (asym_ptr
->section
->output_section
!= NULL
)
3360 indx
= asym_ptr
->section
->output_section
->index
;
3362 indx
= asym_ptr
->section
->index
;
3363 if (elf_section_syms (abfd
)[indx
])
3364 asym_ptr
->udata
.i
= elf_section_syms (abfd
)[indx
]->udata
.i
;
3367 idx
= asym_ptr
->udata
.i
;
3371 /* This case can occur when using --strip-symbol on a symbol
3372 which is used in a relocation entry. */
3373 (*_bfd_error_handler
)
3374 (_("%s: symbol `%s' required but not present"),
3375 bfd_get_filename (abfd
), bfd_asymbol_name (asym_ptr
));
3376 bfd_set_error (bfd_error_no_symbols
);
3383 _("elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n"),
3384 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
,
3385 elf_symbol_flags (flags
));
3393 /* Copy private BFD data. This copies any program header information. */
3396 copy_private_bfd_data (ibfd
, obfd
)
3400 Elf_Internal_Ehdr
*iehdr
;
3401 struct elf_segment_map
*mfirst
;
3402 struct elf_segment_map
**pm
;
3403 struct elf_segment_map
*m
;
3404 Elf_Internal_Phdr
*p
;
3406 unsigned int num_segments
;
3407 boolean phdr_included
= false;
3409 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3410 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3413 if (elf_tdata (ibfd
)->phdr
== NULL
)
3416 iehdr
= elf_elfheader (ibfd
);
3421 num_segments
= elf_elfheader (ibfd
)->e_phnum
;
3423 #define IS_CONTAINED_BY(addr, len, bottom, phdr) \
3424 ((addr) >= (bottom) \
3425 && ( ((addr) + (len)) <= ((bottom) + (phdr)->p_memsz) \
3426 || ((addr) + (len)) <= ((bottom) + (phdr)->p_filesz)))
3428 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
3430 #define IS_COREFILE_NOTE(p, s) \
3431 (p->p_type == PT_NOTE \
3432 && bfd_get_format (ibfd) == bfd_core \
3433 && s->vma == 0 && s->lma == 0 \
3434 && (bfd_vma) s->filepos >= p->p_offset \
3435 && (bfd_vma) s->filepos + s->_raw_size \
3436 <= p->p_offset + p->p_filesz)
3438 /* The complicated case when p_vaddr is 0 is to handle the Solaris
3439 linker, which generates a PT_INTERP section with p_vaddr and
3440 p_memsz set to 0. */
3442 #define IS_SOLARIS_PT_INTERP(p, s) \
3444 && p->p_filesz > 0 \
3445 && (s->flags & SEC_HAS_CONTENTS) != 0 \
3446 && s->_raw_size > 0 \
3447 && (bfd_vma) s->filepos >= p->p_offset \
3448 && ((bfd_vma) s->filepos + s->_raw_size \
3449 <= p->p_offset + p->p_filesz))
3451 /* Scan through the segments specified in the program header
3452 of the input BFD. */
3453 for (i
= 0, p
= elf_tdata (ibfd
)->phdr
; i
< num_segments
; i
++, p
++)
3457 asection
**sections
;
3460 bfd_vma matching_lma
;
3461 bfd_vma suggested_lma
;
3464 /* For each section in the input BFD, decide if it should be
3465 included in the current segment. A section will be included
3466 if it is within the address space of the segment, and it is
3467 an allocated segment, and there is an output section
3468 associated with it. */
3470 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3471 if (s
->output_section
!= NULL
)
3473 if ((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3474 || IS_SOLARIS_PT_INTERP (p
, s
))
3475 && (s
->flags
& SEC_ALLOC
) != 0)
3477 else if (IS_COREFILE_NOTE (p
, s
))
3481 /* Allocate a segment map big enough to contain all of the
3482 sections we have selected. */
3483 m
= ((struct elf_segment_map
*)
3485 (sizeof (struct elf_segment_map
)
3486 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3490 /* Initialise the fields of the segment map. Default to
3491 using the physical address of the segment in the input BFD. */
3493 m
->p_type
= p
->p_type
;
3494 m
->p_flags
= p
->p_flags
;
3495 m
->p_flags_valid
= 1;
3496 m
->p_paddr
= p
->p_paddr
;
3497 m
->p_paddr_valid
= 1;
3499 /* Determine if this segment contains the ELF file header
3500 and if it contains the program headers themselves. */
3501 m
->includes_filehdr
= (p
->p_offset
== 0
3502 && p
->p_filesz
>= iehdr
->e_ehsize
);
3504 m
->includes_phdrs
= 0;
3506 if (! phdr_included
|| p
->p_type
!= PT_LOAD
)
3509 (p
->p_offset
<= (bfd_vma
) iehdr
->e_phoff
3510 && (p
->p_offset
+ p
->p_filesz
3511 >= ((bfd_vma
) iehdr
->e_phoff
3512 + iehdr
->e_phnum
* iehdr
->e_phentsize
)));
3513 if (p
->p_type
== PT_LOAD
&& m
->includes_phdrs
)
3514 phdr_included
= true;
3519 /* Special segments, such as the PT_PHDR segment, may contain
3520 no sections, but ordinary, loadable segments should contain
3523 if (p
->p_type
== PT_LOAD
)
3525 (_("%s: warning: Empty loadable segment detected\n"),
3526 bfd_get_filename (ibfd
));
3535 /* Now scan the sections in the input BFD again and attempt
3536 to add their corresponding output sections to the segment map.
3537 The problem here is how to handle an output section which has
3538 been moved (ie had its LMA changed). There are four possibilities:
3540 1. None of the sections have been moved.
3541 In this case we can continue to use the segment LMA from the
3544 2. All of the sections have been moved by the same amount.
3545 In this case we can change the segment's LMA to match the LMA
3546 of the first section.
3548 3. Some of the sections have been moved, others have not.
3549 In this case those sections which have not been moved can be
3550 placed in the current segment which will have to have its size,
3551 and possibly its LMA changed, and a new segment or segments will
3552 have to be created to contain the other sections.
3554 4. The sections have been moved, but not be the same amount.
3555 In this case we can change the segment's LMA to match the LMA
3556 of the first section and we will have to create a new segment
3557 or segments to contain the other sections.
3559 In order to save time, we allocate an array to hold the section
3560 pointers that we are interested in. As these sections get assigned
3561 to a segment, they are removed from this array. */
3563 sections
= (asection
**) bfd_malloc (sizeof (asection
*) * csecs
);
3564 if (sections
== NULL
)
3567 /* Step One: Scan for segment vs section LMA conflicts.
3568 Also add the sections to the section array allocated above.
3569 Also add the sections to the current segment. In the common
3570 case, where the sections have not been moved, this means that
3571 we have completely filled the segment, and there is nothing
3575 matching_lma
= false;
3578 for (j
= 0, s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
3580 os
= s
->output_section
;
3582 if ((((IS_CONTAINED_BY (s
->vma
, s
->_raw_size
, p
->p_vaddr
, p
)
3583 || IS_SOLARIS_PT_INTERP (p
, s
))
3584 && (s
->flags
& SEC_ALLOC
) != 0)
3585 || IS_COREFILE_NOTE (p
, s
))
3590 /* The Solaris native linker always sets p_paddr to 0.
3591 We try to catch that case here, and set it to the
3597 && (os
->vma
== (p
->p_vaddr
3598 + (m
->includes_filehdr
3601 + (m
->includes_phdrs
3602 ? iehdr
->e_phnum
* iehdr
->e_phentsize
3604 m
->p_paddr
= p
->p_vaddr
;
3606 /* Match up the physical address of the segment with the
3607 LMA address of the output section. */
3608 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3609 || IS_COREFILE_NOTE (p
, s
))
3611 if (matching_lma
== 0)
3612 matching_lma
= os
->lma
;
3614 /* We assume that if the section fits within the segment
3615 that it does not overlap any other section within that
3617 m
->sections
[isec
++] = os
;
3619 else if (suggested_lma
== 0)
3620 suggested_lma
= os
->lma
;
3624 BFD_ASSERT (j
== csecs
);
3626 /* Step Two: Adjust the physical address of the current segment,
3630 /* All of the sections fitted within the segment as currently
3631 specified. This is the default case. Add the segment to
3632 the list of built segments and carry on to process the next
3633 program header in the input BFD. */
3641 else if (matching_lma
!= 0)
3643 /* At least one section fits inside the current segment.
3644 Keep it, but modify its physical address to match the
3645 LMA of the first section that fitted. */
3647 m
->p_paddr
= matching_lma
;
3651 /* None of the sections fitted inside the current segment.
3652 Change the current segment's physical address to match
3653 the LMA of the first section. */
3655 m
->p_paddr
= suggested_lma
;
3658 /* Step Three: Loop over the sections again, this time assigning
3659 those that fit to the current segment and remvoing them from the
3660 sections array; but making sure not to leave large gaps. Once all
3661 possible sections have been assigned to the current segment it is
3662 added to the list of built segments and if sections still remain
3663 to be assigned, a new segment is constructed before repeating
3671 /* Fill the current segment with sections that fit. */
3672 for (j
= 0; j
< csecs
; j
++)
3679 os
= s
->output_section
;
3681 if (IS_CONTAINED_BY (os
->lma
, os
->_raw_size
, m
->p_paddr
, p
)
3682 || IS_COREFILE_NOTE (p
, s
))
3686 /* If the first section in a segment does not start at
3687 the beginning of the segment, then something is wrong. */
3688 if (os
->lma
!= m
->p_paddr
)
3693 asection
* prev_sec
;
3694 bfd_vma maxpagesize
;
3696 prev_sec
= m
->sections
[m
->count
- 1];
3697 maxpagesize
= get_elf_backend_data (obfd
)->maxpagesize
;
3699 /* If the gap between the end of the previous section
3700 and the start of this section is more than maxpagesize
3701 then we need to start a new segment. */
3702 if (BFD_ALIGN (prev_sec
->lma
+ prev_sec
->_raw_size
, maxpagesize
)
3703 < BFD_ALIGN (os
->lma
, maxpagesize
))
3705 if (suggested_lma
== 0)
3706 suggested_lma
= os
->lma
;
3712 m
->sections
[m
->count
++] = os
;
3716 else if (suggested_lma
== 0)
3717 suggested_lma
= os
->lma
;
3720 BFD_ASSERT (m
->count
> 0);
3722 /* Add the current segment to the list of built segments. */
3728 /* We still have not allocated all of the sections to
3729 segments. Create a new segment here, initialise it
3730 and carry on looping. */
3732 m
= ((struct elf_segment_map
*)
3734 (sizeof (struct elf_segment_map
)
3735 + ((size_t) csecs
- 1) * sizeof (asection
*))));
3739 /* Initialise the fields of the segment map. Set the physical
3740 physical address to the LMA of the first section that has
3741 not yet been assigned. */
3744 m
->p_type
= p
->p_type
;
3745 m
->p_flags
= p
->p_flags
;
3746 m
->p_flags_valid
= 1;
3747 m
->p_paddr
= suggested_lma
;
3748 m
->p_paddr_valid
= 1;
3749 m
->includes_filehdr
= 0;
3750 m
->includes_phdrs
= 0;
3753 while (isec
< csecs
);
3758 /* The Solaris linker creates program headers in which all the
3759 p_paddr fields are zero. When we try to objcopy or strip such a
3760 file, we get confused. Check for this case, and if we find it
3761 reset the p_paddr_valid fields. */
3762 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3763 if (m
->p_paddr
!= 0)
3767 for (m
= mfirst
; m
!= NULL
; m
= m
->next
)
3768 m
->p_paddr_valid
= 0;
3771 elf_tdata (obfd
)->segment_map
= mfirst
;
3774 /* Final Step: Sort the segments into ascending order of physical address. */
3777 struct elf_segment_map
* prev
;
3780 for (m
= mfirst
->next
; m
!= NULL
; prev
= m
, m
= m
->next
)
3782 /* Yes I know - its a bubble sort....*/
3783 if (m
->next
!= NULL
&& (m
->next
->p_paddr
< m
->p_paddr
))
3785 /* swap m and m->next */
3786 prev
->next
= m
->next
;
3787 m
->next
= m
->next
->next
;
3788 prev
->next
->next
= m
;
3797 #undef IS_CONTAINED_BY
3798 #undef IS_SOLARIS_PT_INTERP
3799 #undef IS_COREFILE_NOTE
3803 /* Copy private section information. This copies over the entsize
3804 field, and sometimes the info field. */
3807 _bfd_elf_copy_private_section_data (ibfd
, isec
, obfd
, osec
)
3813 Elf_Internal_Shdr
*ihdr
, *ohdr
;
3815 if (ibfd
->xvec
->flavour
!= bfd_target_elf_flavour
3816 || obfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
3819 /* Copy over private BFD data if it has not already been copied.
3820 This must be done here, rather than in the copy_private_bfd_data
3821 entry point, because the latter is called after the section
3822 contents have been set, which means that the program headers have
3823 already been worked out. */
3824 if (elf_tdata (obfd
)->segment_map
== NULL
3825 && elf_tdata (ibfd
)->phdr
!= NULL
)
3829 /* Only set up the segments if there are no more SEC_ALLOC
3830 sections. FIXME: This won't do the right thing if objcopy is
3831 used to remove the last SEC_ALLOC section, since objcopy
3832 won't call this routine in that case. */
3833 for (s
= isec
->next
; s
!= NULL
; s
= s
->next
)
3834 if ((s
->flags
& SEC_ALLOC
) != 0)
3838 if (! copy_private_bfd_data (ibfd
, obfd
))
3843 ihdr
= &elf_section_data (isec
)->this_hdr
;
3844 ohdr
= &elf_section_data (osec
)->this_hdr
;
3846 ohdr
->sh_entsize
= ihdr
->sh_entsize
;
3848 if (ihdr
->sh_type
== SHT_SYMTAB
3849 || ihdr
->sh_type
== SHT_DYNSYM
3850 || ihdr
->sh_type
== SHT_GNU_verneed
3851 || ihdr
->sh_type
== SHT_GNU_verdef
)
3852 ohdr
->sh_info
= ihdr
->sh_info
;
3854 elf_section_data (osec
)->use_rela_p
3855 = elf_section_data (isec
)->use_rela_p
;
3860 /* Copy private symbol information. If this symbol is in a section
3861 which we did not map into a BFD section, try to map the section
3862 index correctly. We use special macro definitions for the mapped
3863 section indices; these definitions are interpreted by the
3864 swap_out_syms function. */
3866 #define MAP_ONESYMTAB (SHN_LORESERVE - 1)
3867 #define MAP_DYNSYMTAB (SHN_LORESERVE - 2)
3868 #define MAP_STRTAB (SHN_LORESERVE - 3)
3869 #define MAP_SHSTRTAB (SHN_LORESERVE - 4)
3872 _bfd_elf_copy_private_symbol_data (ibfd
, isymarg
, obfd
, osymarg
)
3878 elf_symbol_type
*isym
, *osym
;
3880 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3881 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3884 isym
= elf_symbol_from (ibfd
, isymarg
);
3885 osym
= elf_symbol_from (obfd
, osymarg
);
3889 && bfd_is_abs_section (isym
->symbol
.section
))
3893 shndx
= isym
->internal_elf_sym
.st_shndx
;
3894 if (shndx
== elf_onesymtab (ibfd
))
3895 shndx
= MAP_ONESYMTAB
;
3896 else if (shndx
== elf_dynsymtab (ibfd
))
3897 shndx
= MAP_DYNSYMTAB
;
3898 else if (shndx
== elf_tdata (ibfd
)->strtab_section
)
3900 else if (shndx
== elf_tdata (ibfd
)->shstrtab_section
)
3901 shndx
= MAP_SHSTRTAB
;
3902 osym
->internal_elf_sym
.st_shndx
= shndx
;
3908 /* Swap out the symbols. */
3911 swap_out_syms (abfd
, sttp
, relocatable_p
)
3913 struct bfd_strtab_hash
**sttp
;
3916 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3918 if (!elf_map_symbols (abfd
))
3921 /* Dump out the symtabs. */
3923 int symcount
= bfd_get_symcount (abfd
);
3924 asymbol
**syms
= bfd_get_outsymbols (abfd
);
3925 struct bfd_strtab_hash
*stt
;
3926 Elf_Internal_Shdr
*symtab_hdr
;
3927 Elf_Internal_Shdr
*symstrtab_hdr
;
3928 char *outbound_syms
;
3931 stt
= _bfd_elf_stringtab_init ();
3935 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3936 symtab_hdr
->sh_type
= SHT_SYMTAB
;
3937 symtab_hdr
->sh_entsize
= bed
->s
->sizeof_sym
;
3938 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
3939 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
3940 symtab_hdr
->sh_addralign
= bed
->s
->file_align
;
3942 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
3943 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
3945 outbound_syms
= bfd_alloc (abfd
,
3946 (1 + symcount
) * bed
->s
->sizeof_sym
);
3947 if (outbound_syms
== NULL
)
3949 symtab_hdr
->contents
= (PTR
) outbound_syms
;
3951 /* now generate the data (for "contents") */
3953 /* Fill in zeroth symbol and swap it out. */
3954 Elf_Internal_Sym sym
;
3960 sym
.st_shndx
= SHN_UNDEF
;
3961 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
3962 outbound_syms
+= bed
->s
->sizeof_sym
;
3964 for (idx
= 0; idx
< symcount
; idx
++)
3966 Elf_Internal_Sym sym
;
3967 bfd_vma value
= syms
[idx
]->value
;
3968 elf_symbol_type
*type_ptr
;
3969 flagword flags
= syms
[idx
]->flags
;
3972 if (flags
& BSF_SECTION_SYM
)
3973 /* Section symbols have no names. */
3977 sym
.st_name
= (unsigned long) _bfd_stringtab_add (stt
,
3980 if (sym
.st_name
== (unsigned long) -1)
3984 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
3986 if ((flags
& BSF_SECTION_SYM
) == 0
3987 && bfd_is_com_section (syms
[idx
]->section
))
3989 /* ELF common symbols put the alignment into the `value' field,
3990 and the size into the `size' field. This is backwards from
3991 how BFD handles it, so reverse it here. */
3992 sym
.st_size
= value
;
3993 if (type_ptr
== NULL
3994 || type_ptr
->internal_elf_sym
.st_value
== 0)
3995 sym
.st_value
= value
>= 16 ? 16 : (1 << bfd_log2 (value
));
3997 sym
.st_value
= type_ptr
->internal_elf_sym
.st_value
;
3998 sym
.st_shndx
= _bfd_elf_section_from_bfd_section
3999 (abfd
, syms
[idx
]->section
);
4003 asection
*sec
= syms
[idx
]->section
;
4006 if (sec
->output_section
)
4008 value
+= sec
->output_offset
;
4009 sec
= sec
->output_section
;
4011 /* Don't add in the section vma for relocatable output. */
4012 if (! relocatable_p
)
4014 sym
.st_value
= value
;
4015 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
4017 if (bfd_is_abs_section (sec
)
4019 && type_ptr
->internal_elf_sym
.st_shndx
!= 0)
4021 /* This symbol is in a real ELF section which we did
4022 not create as a BFD section. Undo the mapping done
4023 by copy_private_symbol_data. */
4024 shndx
= type_ptr
->internal_elf_sym
.st_shndx
;
4028 shndx
= elf_onesymtab (abfd
);
4031 shndx
= elf_dynsymtab (abfd
);
4034 shndx
= elf_tdata (abfd
)->strtab_section
;
4037 shndx
= elf_tdata (abfd
)->shstrtab_section
;
4045 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
4051 /* Writing this would be a hell of a lot easier if
4052 we had some decent documentation on bfd, and
4053 knew what to expect of the library, and what to
4054 demand of applications. For example, it
4055 appears that `objcopy' might not set the
4056 section of a symbol to be a section that is
4057 actually in the output file. */
4058 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
4059 BFD_ASSERT (sec2
!= 0);
4060 shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec2
);
4061 BFD_ASSERT (shndx
!= -1);
4065 sym
.st_shndx
= shndx
;
4068 if ((flags
& BSF_FUNCTION
) != 0)
4070 else if ((flags
& BSF_OBJECT
) != 0)
4075 /* Processor-specific types */
4076 if (bed
->elf_backend_get_symbol_type
)
4077 type
= (*bed
->elf_backend_get_symbol_type
) (&type_ptr
->internal_elf_sym
, type
);
4079 if (flags
& BSF_SECTION_SYM
)
4080 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
4081 else if (bfd_is_com_section (syms
[idx
]->section
))
4082 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, type
);
4083 else if (bfd_is_und_section (syms
[idx
]->section
))
4084 sym
.st_info
= ELF_ST_INFO (((flags
& BSF_WEAK
)
4088 else if (flags
& BSF_FILE
)
4089 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
4092 int bind
= STB_LOCAL
;
4094 if (flags
& BSF_LOCAL
)
4096 else if (flags
& BSF_WEAK
)
4098 else if (flags
& BSF_GLOBAL
)
4101 sym
.st_info
= ELF_ST_INFO (bind
, type
);
4104 if (type_ptr
!= NULL
)
4105 sym
.st_other
= type_ptr
->internal_elf_sym
.st_other
;
4109 bed
->s
->swap_symbol_out (abfd
, &sym
, (PTR
) outbound_syms
);
4110 outbound_syms
+= bed
->s
->sizeof_sym
;
4114 symstrtab_hdr
->sh_size
= _bfd_stringtab_size (stt
);
4115 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
4117 symstrtab_hdr
->sh_flags
= 0;
4118 symstrtab_hdr
->sh_addr
= 0;
4119 symstrtab_hdr
->sh_entsize
= 0;
4120 symstrtab_hdr
->sh_link
= 0;
4121 symstrtab_hdr
->sh_info
= 0;
4122 symstrtab_hdr
->sh_addralign
= 1;
4128 /* Return the number of bytes required to hold the symtab vector.
4130 Note that we base it on the count plus 1, since we will null terminate
4131 the vector allocated based on this size. However, the ELF symbol table
4132 always has a dummy entry as symbol #0, so it ends up even. */
4135 _bfd_elf_get_symtab_upper_bound (abfd
)
4140 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4142 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4143 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4149 _bfd_elf_get_dynamic_symtab_upper_bound (abfd
)
4154 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
4156 if (elf_dynsymtab (abfd
) == 0)
4158 bfd_set_error (bfd_error_invalid_operation
);
4162 symcount
= hdr
->sh_size
/ get_elf_backend_data (abfd
)->s
->sizeof_sym
;
4163 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
4169 _bfd_elf_get_reloc_upper_bound (abfd
, asect
)
4173 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
4176 /* Canonicalize the relocs. */
4179 _bfd_elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4188 if (! get_elf_backend_data (abfd
)->s
->slurp_reloc_table (abfd
,
4194 tblptr
= section
->relocation
;
4195 for (i
= 0; i
< section
->reloc_count
; i
++)
4196 *relptr
++ = tblptr
++;
4200 return section
->reloc_count
;
4204 _bfd_elf_get_symtab (abfd
, alocation
)
4206 asymbol
**alocation
;
4208 long symcount
= get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4209 (abfd
, alocation
, false);
4212 bfd_get_symcount (abfd
) = symcount
;
4217 _bfd_elf_canonicalize_dynamic_symtab (abfd
, alocation
)
4219 asymbol
**alocation
;
4221 return get_elf_backend_data (abfd
)->s
->slurp_symbol_table
4222 (abfd
, alocation
, true);
4225 /* Return the size required for the dynamic reloc entries. Any
4226 section that was actually installed in the BFD, and has type
4227 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
4228 considered to be a dynamic reloc section. */
4231 _bfd_elf_get_dynamic_reloc_upper_bound (abfd
)
4237 if (elf_dynsymtab (abfd
) == 0)
4239 bfd_set_error (bfd_error_invalid_operation
);
4243 ret
= sizeof (arelent
*);
4244 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
4245 if (elf_section_data (s
)->this_hdr
.sh_link
== elf_dynsymtab (abfd
)
4246 && (elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
4247 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
))
4248 ret
+= ((s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
)
4249 * sizeof (arelent
*));
4254 /* Canonicalize the dynamic relocation entries. Note that we return
4255 the dynamic relocations as a single block, although they are
4256 actually associated with particular sections; the interface, which
4257 was designed for SunOS style shared libraries, expects that there
4258 is only one set of dynamic relocs. Any section that was actually
4259 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
4260 the dynamic symbol table, is considered to be a dynamic reloc
4264 _bfd_elf_canonicalize_dynamic_reloc (abfd
, storage
, syms
)
4269 boolean (*slurp_relocs
) PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
4273 if (elf_dynsymtab (abfd
) == 0)
4275 bfd_set_error (bfd_error_invalid_operation
);
4279 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
4281 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
))
4290 if (! (*slurp_relocs
) (abfd
, s
, syms
, true))
4292 count
= s
->_raw_size
/ elf_section_data (s
)->this_hdr
.sh_entsize
;
4294 for (i
= 0; i
< count
; i
++)
4305 /* Read in the version information. */
4308 _bfd_elf_slurp_version_tables (abfd
)
4311 bfd_byte
*contents
= NULL
;
4313 if (elf_dynverdef (abfd
) != 0)
4315 Elf_Internal_Shdr
*hdr
;
4316 Elf_External_Verdef
*everdef
;
4317 Elf_Internal_Verdef
*iverdef
;
4320 hdr
= &elf_tdata (abfd
)->dynverdef_hdr
;
4322 elf_tdata (abfd
)->verdef
=
4323 ((Elf_Internal_Verdef
*)
4324 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verdef
)));
4325 if (elf_tdata (abfd
)->verdef
== NULL
)
4328 elf_tdata (abfd
)->cverdefs
= hdr
->sh_info
;
4330 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4331 if (contents
== NULL
)
4333 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4334 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4337 everdef
= (Elf_External_Verdef
*) contents
;
4338 iverdef
= elf_tdata (abfd
)->verdef
;
4339 for (i
= 0; i
< hdr
->sh_info
; i
++, iverdef
++)
4341 Elf_External_Verdaux
*everdaux
;
4342 Elf_Internal_Verdaux
*iverdaux
;
4345 _bfd_elf_swap_verdef_in (abfd
, everdef
, iverdef
);
4347 iverdef
->vd_bfd
= abfd
;
4349 iverdef
->vd_auxptr
= ((Elf_Internal_Verdaux
*)
4352 * sizeof (Elf_Internal_Verdaux
))));
4353 if (iverdef
->vd_auxptr
== NULL
)
4356 everdaux
= ((Elf_External_Verdaux
*)
4357 ((bfd_byte
*) everdef
+ iverdef
->vd_aux
));
4358 iverdaux
= iverdef
->vd_auxptr
;
4359 for (j
= 0; j
< iverdef
->vd_cnt
; j
++, iverdaux
++)
4361 _bfd_elf_swap_verdaux_in (abfd
, everdaux
, iverdaux
);
4363 iverdaux
->vda_nodename
=
4364 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4365 iverdaux
->vda_name
);
4366 if (iverdaux
->vda_nodename
== NULL
)
4369 if (j
+ 1 < iverdef
->vd_cnt
)
4370 iverdaux
->vda_nextptr
= iverdaux
+ 1;
4372 iverdaux
->vda_nextptr
= NULL
;
4374 everdaux
= ((Elf_External_Verdaux
*)
4375 ((bfd_byte
*) everdaux
+ iverdaux
->vda_next
));
4378 iverdef
->vd_nodename
= iverdef
->vd_auxptr
->vda_nodename
;
4380 if (i
+ 1 < hdr
->sh_info
)
4381 iverdef
->vd_nextdef
= iverdef
+ 1;
4383 iverdef
->vd_nextdef
= NULL
;
4385 everdef
= ((Elf_External_Verdef
*)
4386 ((bfd_byte
*) everdef
+ iverdef
->vd_next
));
4393 if (elf_dynverref (abfd
) != 0)
4395 Elf_Internal_Shdr
*hdr
;
4396 Elf_External_Verneed
*everneed
;
4397 Elf_Internal_Verneed
*iverneed
;
4400 hdr
= &elf_tdata (abfd
)->dynverref_hdr
;
4402 elf_tdata (abfd
)->verref
=
4403 ((Elf_Internal_Verneed
*)
4404 bfd_zalloc (abfd
, hdr
->sh_info
* sizeof (Elf_Internal_Verneed
)));
4405 if (elf_tdata (abfd
)->verref
== NULL
)
4408 elf_tdata (abfd
)->cverrefs
= hdr
->sh_info
;
4410 contents
= (bfd_byte
*) bfd_malloc (hdr
->sh_size
);
4411 if (contents
== NULL
)
4413 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0
4414 || bfd_read ((PTR
) contents
, 1, hdr
->sh_size
, abfd
) != hdr
->sh_size
)
4417 everneed
= (Elf_External_Verneed
*) contents
;
4418 iverneed
= elf_tdata (abfd
)->verref
;
4419 for (i
= 0; i
< hdr
->sh_info
; i
++, iverneed
++)
4421 Elf_External_Vernaux
*evernaux
;
4422 Elf_Internal_Vernaux
*ivernaux
;
4425 _bfd_elf_swap_verneed_in (abfd
, everneed
, iverneed
);
4427 iverneed
->vn_bfd
= abfd
;
4429 iverneed
->vn_filename
=
4430 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4432 if (iverneed
->vn_filename
== NULL
)
4435 iverneed
->vn_auxptr
=
4436 ((Elf_Internal_Vernaux
*)
4438 iverneed
->vn_cnt
* sizeof (Elf_Internal_Vernaux
)));
4440 evernaux
= ((Elf_External_Vernaux
*)
4441 ((bfd_byte
*) everneed
+ iverneed
->vn_aux
));
4442 ivernaux
= iverneed
->vn_auxptr
;
4443 for (j
= 0; j
< iverneed
->vn_cnt
; j
++, ivernaux
++)
4445 _bfd_elf_swap_vernaux_in (abfd
, evernaux
, ivernaux
);
4447 ivernaux
->vna_nodename
=
4448 bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4449 ivernaux
->vna_name
);
4450 if (ivernaux
->vna_nodename
== NULL
)
4453 if (j
+ 1 < iverneed
->vn_cnt
)
4454 ivernaux
->vna_nextptr
= ivernaux
+ 1;
4456 ivernaux
->vna_nextptr
= NULL
;
4458 evernaux
= ((Elf_External_Vernaux
*)
4459 ((bfd_byte
*) evernaux
+ ivernaux
->vna_next
));
4462 if (i
+ 1 < hdr
->sh_info
)
4463 iverneed
->vn_nextref
= iverneed
+ 1;
4465 iverneed
->vn_nextref
= NULL
;
4467 everneed
= ((Elf_External_Verneed
*)
4468 ((bfd_byte
*) everneed
+ iverneed
->vn_next
));
4478 if (contents
== NULL
)
4484 _bfd_elf_make_empty_symbol (abfd
)
4487 elf_symbol_type
*newsym
;
4489 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
4494 newsym
->symbol
.the_bfd
= abfd
;
4495 return &newsym
->symbol
;
4500 _bfd_elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
4505 bfd_symbol_info (symbol
, ret
);
4508 /* Return whether a symbol name implies a local symbol. Most targets
4509 use this function for the is_local_label_name entry point, but some
4513 _bfd_elf_is_local_label_name (abfd
, name
)
4517 /* Normal local symbols start with ``.L''. */
4518 if (name
[0] == '.' && name
[1] == 'L')
4521 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
4522 DWARF debugging symbols starting with ``..''. */
4523 if (name
[0] == '.' && name
[1] == '.')
4526 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
4527 emitting DWARF debugging output. I suspect this is actually a
4528 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
4529 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
4530 underscore to be emitted on some ELF targets). For ease of use,
4531 we treat such symbols as local. */
4532 if (name
[0] == '_' && name
[1] == '.' && name
[2] == 'L' && name
[3] == '_')
4539 _bfd_elf_get_lineno (ignore_abfd
, symbol
)
4548 _bfd_elf_set_arch_mach (abfd
, arch
, machine
)
4550 enum bfd_architecture arch
;
4551 unsigned long machine
;
4553 /* If this isn't the right architecture for this backend, and this
4554 isn't the generic backend, fail. */
4555 if (arch
!= get_elf_backend_data (abfd
)->arch
4556 && arch
!= bfd_arch_unknown
4557 && get_elf_backend_data (abfd
)->arch
!= bfd_arch_unknown
)
4560 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
4563 /* Find the nearest line to a particular section and offset, for error
4567 _bfd_elf_find_nearest_line (abfd
,
4578 CONST
char **filename_ptr
;
4579 CONST
char **functionname_ptr
;
4580 unsigned int *line_ptr
;
4583 const char *filename
;
4588 if (_bfd_dwarf1_find_nearest_line (abfd
, section
, symbols
, offset
,
4589 filename_ptr
, functionname_ptr
,
4593 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
4594 filename_ptr
, functionname_ptr
,
4598 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
4599 &found
, filename_ptr
,
4600 functionname_ptr
, line_ptr
,
4601 &elf_tdata (abfd
)->line_info
))
4606 if (symbols
== NULL
)
4613 for (p
= symbols
; *p
!= NULL
; p
++)
4617 q
= (elf_symbol_type
*) *p
;
4619 if (bfd_get_section (&q
->symbol
) != section
)
4622 switch (ELF_ST_TYPE (q
->internal_elf_sym
.st_info
))
4627 filename
= bfd_asymbol_name (&q
->symbol
);
4631 if (q
->symbol
.section
== section
4632 && q
->symbol
.value
>= low_func
4633 && q
->symbol
.value
<= offset
)
4635 func
= (asymbol
*) q
;
4636 low_func
= q
->symbol
.value
;
4645 *filename_ptr
= filename
;
4646 *functionname_ptr
= bfd_asymbol_name (func
);
4652 _bfd_elf_sizeof_headers (abfd
, reloc
)
4658 ret
= get_elf_backend_data (abfd
)->s
->sizeof_ehdr
;
4660 ret
+= get_program_header_size (abfd
);
4665 _bfd_elf_set_section_contents (abfd
, section
, location
, offset
, count
)
4670 bfd_size_type count
;
4672 Elf_Internal_Shdr
*hdr
;
4674 if (! abfd
->output_has_begun
4675 && ! _bfd_elf_compute_section_file_positions
4676 (abfd
, (struct bfd_link_info
*) NULL
))
4679 hdr
= &elf_section_data (section
)->this_hdr
;
4681 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
4683 if (bfd_write (location
, 1, count
, abfd
) != count
)
4690 _bfd_elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
4693 Elf_Internal_Rela
*dst
;
4700 _bfd_elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
4703 Elf_Internal_Rel
*dst
;
4709 /* Try to convert a non-ELF reloc into an ELF one. */
4712 _bfd_elf_validate_reloc (abfd
, areloc
)
4716 /* Check whether we really have an ELF howto. */
4718 if ((*areloc
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
)
4720 bfd_reloc_code_real_type code
;
4721 reloc_howto_type
*howto
;
4723 /* Alien reloc: Try to determine its type to replace it with an
4724 equivalent ELF reloc. */
4726 if (areloc
->howto
->pc_relative
)
4728 switch (areloc
->howto
->bitsize
)
4731 code
= BFD_RELOC_8_PCREL
;
4734 code
= BFD_RELOC_12_PCREL
;
4737 code
= BFD_RELOC_16_PCREL
;
4740 code
= BFD_RELOC_24_PCREL
;
4743 code
= BFD_RELOC_32_PCREL
;
4746 code
= BFD_RELOC_64_PCREL
;
4752 howto
= bfd_reloc_type_lookup (abfd
, code
);
4754 if (areloc
->howto
->pcrel_offset
!= howto
->pcrel_offset
)
4756 if (howto
->pcrel_offset
)
4757 areloc
->addend
+= areloc
->address
;
4759 areloc
->addend
-= areloc
->address
; /* addend is unsigned!! */
4764 switch (areloc
->howto
->bitsize
)
4770 code
= BFD_RELOC_14
;
4773 code
= BFD_RELOC_16
;
4776 code
= BFD_RELOC_26
;
4779 code
= BFD_RELOC_32
;
4782 code
= BFD_RELOC_64
;
4788 howto
= bfd_reloc_type_lookup (abfd
, code
);
4792 areloc
->howto
= howto
;
4800 (*_bfd_error_handler
)
4801 (_("%s: unsupported relocation type %s"),
4802 bfd_get_filename (abfd
), areloc
->howto
->name
);
4803 bfd_set_error (bfd_error_bad_value
);
4808 _bfd_elf_close_and_cleanup (abfd
)
4811 if (bfd_get_format (abfd
) == bfd_object
)
4813 if (elf_shstrtab (abfd
) != NULL
)
4814 _bfd_stringtab_free (elf_shstrtab (abfd
));
4817 return _bfd_generic_close_and_cleanup (abfd
);
4820 /* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
4821 in the relocation's offset. Thus we cannot allow any sort of sanity
4822 range-checking to interfere. There is nothing else to do in processing
4825 bfd_reloc_status_type
4826 _bfd_elf_rel_vtable_reloc_fn (abfd
, re
, symbol
, data
, is
, obfd
, errmsg
)
4829 struct symbol_cache_entry
*symbol
;
4835 return bfd_reloc_ok
;
4839 /* Elf core file support. Much of this only works on native
4840 toolchains, since we rely on knowing the
4841 machine-dependent procfs structure in order to pick
4842 out details about the corefile. */
4844 #ifdef HAVE_SYS_PROCFS_H
4845 # include <sys/procfs.h>
4849 /* Define offsetof for those systems which lack it. */
4852 # define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
4856 /* FIXME: this is kinda wrong, but it's what gdb wants. */
4859 elfcore_make_pid (abfd
)
4862 return ((elf_tdata (abfd
)->core_lwpid
<< 16)
4863 + (elf_tdata (abfd
)->core_pid
));
4867 /* If there isn't a section called NAME, make one, using
4868 data from SECT. Note, this function will generate a
4869 reference to NAME, so you shouldn't deallocate or
4873 elfcore_maybe_make_sect (abfd
, name
, sect
)
4880 if (bfd_get_section_by_name (abfd
, name
) != NULL
)
4883 sect2
= bfd_make_section (abfd
, name
);
4887 sect2
->_raw_size
= sect
->_raw_size
;
4888 sect2
->filepos
= sect
->filepos
;
4889 sect2
->flags
= sect
->flags
;
4890 sect2
->alignment_power
= sect
->alignment_power
;
4895 /* prstatus_t exists on:
4897 linux 2.[01] + glibc
4901 #if defined (HAVE_PRSTATUS_T)
4903 elfcore_grok_prstatus (abfd
, note
)
4905 Elf_Internal_Note
* note
;
4912 if (note
->descsz
!= sizeof (prstat
))
4915 memcpy (&prstat
, note
->descdata
, sizeof (prstat
));
4917 elf_tdata (abfd
)->core_signal
= prstat
.pr_cursig
;
4918 elf_tdata (abfd
)->core_pid
= prstat
.pr_pid
;
4920 /* pr_who exists on:
4923 pr_who doesn't exist on:
4926 #if defined (HAVE_PRSTATUS_T_PR_WHO)
4927 elf_tdata (abfd
)->core_lwpid
= prstat
.pr_who
;
4930 /* Make a ".reg/999" section. */
4932 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
4933 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
4938 sect
= bfd_make_section (abfd
, name
);
4941 sect
->_raw_size
= sizeof (prstat
.pr_reg
);
4942 sect
->filepos
= note
->descpos
+ offsetof (prstatus_t
, pr_reg
);
4943 sect
->flags
= SEC_HAS_CONTENTS
;
4944 sect
->alignment_power
= 2;
4946 if (! elfcore_maybe_make_sect (abfd
, ".reg", sect
))
4951 #endif /* defined (HAVE_PRSTATUS_T) */
4954 /* There isn't a consistent prfpregset_t across platforms,
4955 but it doesn't matter, because we don't have to pick this
4956 data structure apart. */
4959 elfcore_grok_prfpreg (abfd
, note
)
4961 Elf_Internal_Note
* note
;
4967 /* Make a ".reg2/999" section. */
4969 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
4970 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
4975 sect
= bfd_make_section (abfd
, name
);
4978 sect
->_raw_size
= note
->descsz
;
4979 sect
->filepos
= note
->descpos
;
4980 sect
->flags
= SEC_HAS_CONTENTS
;
4981 sect
->alignment_power
= 2;
4983 if (! elfcore_maybe_make_sect (abfd
, ".reg2", sect
))
4989 #if defined (HAVE_PRPSINFO_T)
4990 # define elfcore_psinfo_t prpsinfo_t
4993 #if defined (HAVE_PSINFO_T)
4994 # define elfcore_psinfo_t psinfo_t
4998 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5000 /* return a malloc'ed copy of a string at START which is at
5001 most MAX bytes long, possibly without a terminating '\0'.
5002 the copy will always have a terminating '\0'. */
5005 elfcore_strndup (abfd
, start
, max
)
5011 char* end
= memchr (start
, '\0', max
);
5019 dup
= bfd_alloc (abfd
, len
+ 1);
5023 memcpy (dup
, start
, len
);
5030 elfcore_grok_psinfo (abfd
, note
)
5032 Elf_Internal_Note
* note
;
5034 elfcore_psinfo_t psinfo
;
5036 if (note
->descsz
!= sizeof (elfcore_psinfo_t
))
5039 memcpy (&psinfo
, note
->descdata
, note
->descsz
);
5041 elf_tdata (abfd
)->core_program
5042 = elfcore_strndup (abfd
, psinfo
.pr_fname
, sizeof (psinfo
.pr_fname
));
5044 elf_tdata (abfd
)->core_command
5045 = elfcore_strndup (abfd
, psinfo
.pr_psargs
, sizeof (psinfo
.pr_psargs
));
5047 /* Note that for some reason, a spurious space is tacked
5048 onto the end of the args in some (at least one anyway)
5049 implementations, so strip it off if it exists. */
5052 char* command
= elf_tdata (abfd
)->core_command
;
5053 int n
= strlen (command
);
5055 if (0 < n
&& command
[n
- 1] == ' ')
5056 command
[n
- 1] = '\0';
5061 #endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
5064 #if defined (HAVE_PSTATUS_T)
5066 elfcore_grok_pstatus (abfd
, note
)
5068 Elf_Internal_Note
* note
;
5072 if (note
->descsz
!= sizeof (pstat
))
5075 memcpy (&pstat
, note
->descdata
, sizeof (pstat
));
5077 elf_tdata (abfd
)->core_pid
= pstat
.pr_pid
;
5079 /* Could grab some more details from the "representative"
5080 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
5081 NT_LWPSTATUS note, presumably. */
5085 #endif /* defined (HAVE_PSTATUS_T) */
5088 #if defined (HAVE_LWPSTATUS_T)
5090 elfcore_grok_lwpstatus (abfd
, note
)
5092 Elf_Internal_Note
* note
;
5094 lwpstatus_t lwpstat
;
5099 if (note
->descsz
!= sizeof (lwpstat
))
5102 memcpy (&lwpstat
, note
->descdata
, sizeof (lwpstat
));
5104 elf_tdata (abfd
)->core_lwpid
= lwpstat
.pr_lwpid
;
5105 elf_tdata (abfd
)->core_signal
= lwpstat
.pr_cursig
;
5107 /* Make a ".reg/999" section. */
5109 sprintf (buf
, ".reg/%d", elfcore_make_pid (abfd
));
5110 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5115 sect
= bfd_make_section (abfd
, name
);
5119 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5120 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.gregs
);
5121 sect
->filepos
= note
->descpos
5122 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.gregs
);
5125 #if defined (HAVE_LWPSTATUS_T_PR_REG)
5126 sect
->_raw_size
= sizeof (lwpstat
.pr_reg
);
5127 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_reg
);
5130 sect
->flags
= SEC_HAS_CONTENTS
;
5131 sect
->alignment_power
= 2;
5133 if (!elfcore_maybe_make_sect (abfd
, ".reg", sect
))
5136 /* Make a ".reg2/999" section */
5138 sprintf (buf
, ".reg2/%d", elfcore_make_pid (abfd
));
5139 name
= bfd_alloc (abfd
, strlen (buf
) + 1);
5144 sect
= bfd_make_section (abfd
, name
);
5148 #if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
5149 sect
->_raw_size
= sizeof (lwpstat
.pr_context
.uc_mcontext
.fpregs
);
5150 sect
->filepos
= note
->descpos
5151 + offsetof (lwpstatus_t
, pr_context
.uc_mcontext
.fpregs
);
5154 #if defined (HAVE_LWPSTATUS_T_PR_FPREG)
5155 sect
->_raw_size
= sizeof (lwpstat
.pr_fpreg
);
5156 sect
->filepos
= note
->descpos
+ offsetof (lwpstatus_t
, pr_fpreg
);
5159 sect
->flags
= SEC_HAS_CONTENTS
;
5160 sect
->alignment_power
= 2;
5162 if (!elfcore_maybe_make_sect (abfd
, ".reg2", sect
))
5167 #endif /* defined (HAVE_LWPSTATUS_T) */
5172 elfcore_grok_note (abfd
, note
)
5174 Elf_Internal_Note
* note
;
5181 #if defined (HAVE_PRSTATUS_T)
5183 return elfcore_grok_prstatus (abfd
, note
);
5186 #if defined (HAVE_PSTATUS_T)
5188 return elfcore_grok_pstatus (abfd
, note
);
5191 #if defined (HAVE_LWPSTATUS_T)
5193 return elfcore_grok_lwpstatus (abfd
, note
);
5196 case NT_FPREGSET
: /* FIXME: rename to NT_PRFPREG */
5197 return elfcore_grok_prfpreg (abfd
, note
);
5199 #if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
5202 return elfcore_grok_psinfo (abfd
, note
);
5209 elfcore_read_notes (abfd
, offset
, size
)
5220 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
5223 buf
= bfd_malloc ((size_t) size
);
5227 if (bfd_read (buf
, size
, 1, abfd
) != size
)
5235 while (p
< buf
+ size
)
5237 /* FIXME: bad alignment assumption. */
5238 Elf_External_Note
* xnp
= (Elf_External_Note
*) p
;
5239 Elf_Internal_Note in
;
5241 in
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->type
);
5243 in
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->namesz
);
5244 in
.namedata
= xnp
->name
;
5246 in
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) xnp
->descsz
);
5247 in
.descdata
= in
.namedata
+ BFD_ALIGN (in
.namesz
, 4);
5248 in
.descpos
= offset
+ (in
.descdata
- buf
);
5250 if (! elfcore_grok_note (abfd
, &in
))
5253 p
= in
.descdata
+ BFD_ALIGN (in
.descsz
, 4);
5263 _bfd_elfcore_section_from_phdr (abfd
, phdr
, sec_num
)
5265 Elf_Internal_Phdr
* phdr
;
5268 if (! bfd_section_from_phdr (abfd
, phdr
, sec_num
))
5271 if (phdr
->p_type
== PT_NOTE
5272 && ! elfcore_read_notes (abfd
, phdr
->p_offset
, phdr
->p_filesz
))