1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
6 Written by Fred Fish @ Cygnus Support, from information published
7 in "UNIX System V Release 4, Programmers Guide: ANSI C and
8 Programming Support Tools". Sufficient support for gdb.
10 Rewritten by Mark Eichin @ Cygnus Support, from information
11 published in "System V Application Binary Interface", chapters 4
12 and 5, as well as the various "Processor Supplement" documents
13 derived from it. Added support for assembler and other object file
14 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
15 Meissner (Open Software Foundation), and Peter Hoogenboom (University
16 of Utah) to finish and extend this.
18 This file is part of BFD, the Binary File Descriptor library.
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 3 of the License, or
23 (at your option) any later version.
25 This program is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
30 You should have received a copy of the GNU General Public License
31 along with this program; if not, write to the Free Software
32 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
33 MA 02110-1301, USA. */
36 /* Problems and other issues to resolve.
38 (1) BFD expects there to be some fixed number of "sections" in
39 the object file. I.E. there is a "section_count" variable in the
40 bfd structure which contains the number of sections. However, ELF
41 supports multiple "views" of a file. In particular, with current
42 implementations, executable files typically have two tables, a
43 program header table and a section header table, both of which
44 partition the executable.
46 In ELF-speak, the "linking view" of the file uses the section header
47 table to access "sections" within the file, and the "execution view"
48 uses the program header table to access "segments" within the file.
49 "Segments" typically may contain all the data from one or more
52 Note that the section header table is optional in ELF executables,
53 but it is this information that is most useful to gdb. If the
54 section header table is missing, then gdb should probably try
55 to make do with the program header table. (FIXME)
57 (2) The code in this file is compiled twice, once in 32-bit mode and
58 once in 64-bit mode. More of it should be made size-independent
61 (3) ELF section symbols are handled rather sloppily now. This should
62 be cleaned up, and ELF section symbols reconciled with BFD section
65 (4) We need a published spec for 64-bit ELF. We've got some stuff here
66 that we're using for SPARC V9 64-bit chips, but don't assume that
72 #include "libiberty.h"
77 /* Renaming structures, typedefs, macros and functions to be size-specific. */
78 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
79 #define Elf_External_Sym NAME(Elf,External_Sym)
80 #define Elf_External_Shdr NAME(Elf,External_Shdr)
81 #define Elf_External_Phdr NAME(Elf,External_Phdr)
82 #define Elf_External_Rel NAME(Elf,External_Rel)
83 #define Elf_External_Rela NAME(Elf,External_Rela)
84 #define Elf_External_Dyn NAME(Elf,External_Dyn)
86 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
87 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
88 #define elf_core_file_matches_executable_p \
89 NAME(bfd_elf,core_file_matches_executable_p)
90 #define elf_core_file_pid NAME(bfd_elf,core_file_pid)
91 #define elf_object_p NAME(bfd_elf,object_p)
92 #define elf_core_file_p NAME(bfd_elf,core_file_p)
93 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
94 #define elf_get_dynamic_symtab_upper_bound \
95 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
96 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
97 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
98 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
99 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
100 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
101 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
102 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
103 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
104 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
105 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
106 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
107 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
108 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
109 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
110 #define elf_canonicalize_dynamic_symtab \
111 NAME(bfd_elf,canonicalize_dynamic_symtab)
112 #define elf_get_synthetic_symtab \
113 NAME(bfd_elf,get_synthetic_symtab)
114 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
115 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
116 #define elf_get_lineno NAME(bfd_elf,get_lineno)
117 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
118 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
119 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
120 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
121 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
122 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
123 #define elf_find_section NAME(bfd_elf,find_section)
124 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
125 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
126 #define elf_checksum_contents NAME(bfd_elf,checksum_contents)
127 #define elf_write_relocs NAME(bfd_elf,write_relocs)
128 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
131 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
132 #define ELF_R_SYM(X) ELF64_R_SYM(X)
133 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
134 #define ELFCLASS ELFCLASS64
136 #define LOG_FILE_ALIGN 3
139 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
140 #define ELF_R_SYM(X) ELF32_R_SYM(X)
141 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
142 #define ELFCLASS ELFCLASS32
144 #define LOG_FILE_ALIGN 2
148 static void elf_debug_section (int, Elf_Internal_Shdr
*);
151 static void elf_debug_file (Elf_Internal_Ehdr
*);
154 /* Structure swapping routines */
156 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
157 can be handled by explicitly specifying 32 bits or "the long type". */
159 #define H_PUT_WORD H_PUT_64
160 #define H_PUT_SIGNED_WORD H_PUT_S64
161 #define H_GET_WORD H_GET_64
162 #define H_GET_SIGNED_WORD H_GET_S64
165 #define H_PUT_WORD H_PUT_32
166 #define H_PUT_SIGNED_WORD H_PUT_S32
167 #define H_GET_WORD H_GET_32
168 #define H_GET_SIGNED_WORD H_GET_S32
171 /* Translate an ELF symbol in external format into an ELF symbol in internal
175 elf_swap_symbol_in (bfd
*abfd
,
178 Elf_Internal_Sym
*dst
)
180 const Elf_External_Sym
*src
= (const Elf_External_Sym
*) psrc
;
181 const Elf_External_Sym_Shndx
*shndx
= (const Elf_External_Sym_Shndx
*) pshn
;
182 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
184 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
186 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
188 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
189 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
190 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
191 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
192 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
193 if (dst
->st_shndx
== (SHN_XINDEX
& 0xffff))
197 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
199 else if (dst
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
200 dst
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
201 dst
->st_target_internal
= 0;
205 /* Translate an ELF symbol in internal format into an ELF symbol in external
209 elf_swap_symbol_out (bfd
*abfd
,
210 const Elf_Internal_Sym
*src
,
215 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
216 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
217 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
218 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
219 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
220 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
222 if (tmp
>= (SHN_LORESERVE
& 0xffff) && tmp
< SHN_LORESERVE
)
226 H_PUT_32 (abfd
, tmp
, shndx
);
227 tmp
= SHN_XINDEX
& 0xffff;
229 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
232 /* Translate an ELF file header in external format into an ELF file header in
236 elf_swap_ehdr_in (bfd
*abfd
,
237 const Elf_External_Ehdr
*src
,
238 Elf_Internal_Ehdr
*dst
)
240 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
241 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
242 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
243 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
244 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
246 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
248 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
249 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
250 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
251 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
252 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
253 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
254 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
255 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
256 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
257 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
260 /* Translate an ELF file header in internal format into an ELF file header in
264 elf_swap_ehdr_out (bfd
*abfd
,
265 const Elf_Internal_Ehdr
*src
,
266 Elf_External_Ehdr
*dst
)
269 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
270 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
271 /* note that all elements of dst are *arrays of unsigned char* already... */
272 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
273 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
274 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
276 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
278 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
279 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
280 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
281 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
282 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
283 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
287 H_PUT_16 (abfd
, tmp
, dst
->e_phnum
);
288 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
290 if (tmp
>= (SHN_LORESERVE
& 0xffff))
292 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
293 tmp
= src
->e_shstrndx
;
294 if (tmp
>= (SHN_LORESERVE
& 0xffff))
295 tmp
= SHN_XINDEX
& 0xffff;
296 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
299 /* Translate an ELF section header table entry in external format into an
300 ELF section header table entry in internal format. */
303 elf_swap_shdr_in (bfd
*abfd
,
304 const Elf_External_Shdr
*src
,
305 Elf_Internal_Shdr
*dst
)
307 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
309 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
310 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
311 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
313 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
315 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
316 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
317 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
318 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
319 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
320 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
321 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
322 dst
->bfd_section
= NULL
;
323 dst
->contents
= NULL
;
326 /* Translate an ELF section header table entry in internal format into an
327 ELF section header table entry in external format. */
330 elf_swap_shdr_out (bfd
*abfd
,
331 const Elf_Internal_Shdr
*src
,
332 Elf_External_Shdr
*dst
)
334 /* note that all elements of dst are *arrays of unsigned char* already... */
335 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
336 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
337 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
338 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
339 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
340 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
341 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
342 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
343 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
344 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
347 /* Translate an ELF program header table entry in external format into an
348 ELF program header table entry in internal format. */
351 elf_swap_phdr_in (bfd
*abfd
,
352 const Elf_External_Phdr
*src
,
353 Elf_Internal_Phdr
*dst
)
355 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
357 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
358 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
359 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
362 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
363 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
367 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
368 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
370 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
371 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
372 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
376 elf_swap_phdr_out (bfd
*abfd
,
377 const Elf_Internal_Phdr
*src
,
378 Elf_External_Phdr
*dst
)
380 const struct elf_backend_data
*bed
;
383 bed
= get_elf_backend_data (abfd
);
384 p_paddr
= bed
->want_p_paddr_set_to_zero
? 0 : src
->p_paddr
;
386 /* note that all elements of dst are *arrays of unsigned char* already... */
387 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
388 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
389 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
390 H_PUT_WORD (abfd
, p_paddr
, dst
->p_paddr
);
391 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
392 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
393 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
394 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
397 /* Translate an ELF reloc from external format to internal format. */
399 elf_swap_reloc_in (bfd
*abfd
,
401 Elf_Internal_Rela
*dst
)
403 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
404 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
405 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
410 elf_swap_reloca_in (bfd
*abfd
,
412 Elf_Internal_Rela
*dst
)
414 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
415 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
416 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
417 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
420 /* Translate an ELF reloc from internal format to external format. */
422 elf_swap_reloc_out (bfd
*abfd
,
423 const Elf_Internal_Rela
*src
,
426 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
427 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
428 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
432 elf_swap_reloca_out (bfd
*abfd
,
433 const Elf_Internal_Rela
*src
,
436 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
437 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
438 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
439 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
443 elf_swap_dyn_in (bfd
*abfd
,
445 Elf_Internal_Dyn
*dst
)
447 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
449 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
450 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
454 elf_swap_dyn_out (bfd
*abfd
,
455 const Elf_Internal_Dyn
*src
,
458 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
460 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
461 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
464 /* ELF .o/exec file reading */
466 /* Begin processing a given object.
468 First we validate the file by reading in the ELF header and checking
471 static inline bfd_boolean
472 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
474 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
475 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
476 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
477 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
480 /* Check to see if the file associated with ABFD matches the target vector
483 Note that we may be called several times with the same ABFD, but different
484 target vectors, most of which will not match. We have to avoid leaving
485 any side effects in ABFD, or any data it points to (like tdata), if the
486 file does not match the target vector. */
489 elf_object_p (bfd
*abfd
)
491 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
492 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
493 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
494 Elf_Internal_Shdr i_shdr
;
495 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
496 unsigned int shindex
;
497 const struct elf_backend_data
*ebd
;
498 struct bfd_preserve preserve
;
501 const bfd_target
*target
;
503 preserve
.marker
= NULL
;
505 /* Read in the ELF header in external format. */
507 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
509 if (bfd_get_error () != bfd_error_system_call
)
510 goto got_wrong_format_error
;
515 /* Now check to see if we have a valid ELF file, and one that BFD can
516 make use of. The magic number must match, the address size ('class')
517 and byte-swapping must match our XVEC entry, and it must have a
518 section header table (FIXME: See comments re sections at top of this
521 if (! elf_file_p (&x_ehdr
)
522 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
523 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
524 goto got_wrong_format_error
;
526 /* Check that file's byte order matches xvec's */
527 switch (x_ehdr
.e_ident
[EI_DATA
])
529 case ELFDATA2MSB
: /* Big-endian */
530 if (! bfd_header_big_endian (abfd
))
531 goto got_wrong_format_error
;
533 case ELFDATA2LSB
: /* Little-endian */
534 if (! bfd_header_little_endian (abfd
))
535 goto got_wrong_format_error
;
537 case ELFDATANONE
: /* No data encoding specified */
538 default: /* Unknown data encoding specified */
539 goto got_wrong_format_error
;
542 if (!bfd_preserve_save (abfd
, &preserve
))
547 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
548 the tdata pointer in the bfd. */
550 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
552 preserve
.marker
= elf_tdata (abfd
);
554 /* Now that we know the byte order, swap in the rest of the header */
555 i_ehdrp
= elf_elfheader (abfd
);
556 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
558 elf_debug_file (i_ehdrp
);
561 /* Reject ET_CORE (header indicates core file, not object file) */
562 if (i_ehdrp
->e_type
== ET_CORE
)
563 goto got_wrong_format_error
;
565 /* If this is a relocatable file and there is no section header
566 table, then we're hosed. */
567 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
568 goto got_wrong_format_error
;
570 /* As a simple sanity check, verify that what BFD thinks is the
571 size of each section header table entry actually matches the size
572 recorded in the file, but only if there are any sections. */
573 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
574 goto got_wrong_format_error
;
576 /* Further sanity check. */
577 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
578 goto got_wrong_format_error
;
580 ebd
= get_elf_backend_data (abfd
);
581 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
582 goto got_wrong_format_error
;
584 /* Check that the ELF e_machine field matches what this particular
585 BFD format expects. */
586 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
587 && (ebd
->elf_machine_alt1
== 0
588 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
589 && (ebd
->elf_machine_alt2
== 0
590 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
591 && ebd
->elf_machine_code
!= EM_NONE
)
592 goto got_wrong_format_error
;
594 if (i_ehdrp
->e_type
== ET_EXEC
)
595 abfd
->flags
|= EXEC_P
;
596 else if (i_ehdrp
->e_type
== ET_DYN
)
597 abfd
->flags
|= DYNAMIC
;
599 if (i_ehdrp
->e_phnum
> 0)
600 abfd
->flags
|= D_PAGED
;
602 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
604 /* It's OK if this fails for the generic target. */
605 if (ebd
->elf_machine_code
!= EM_NONE
)
609 if (ebd
->elf_machine_code
!= EM_NONE
610 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
611 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
612 goto got_wrong_format_error
;
614 if (i_ehdrp
->e_shoff
!= 0)
616 bfd_signed_vma where
= i_ehdrp
->e_shoff
;
618 if (where
!= (file_ptr
) where
)
619 goto got_wrong_format_error
;
621 /* Seek to the section header table in the file. */
622 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
625 /* Read the first section header at index 0, and convert to internal
627 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
629 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
631 /* If the section count is zero, the actual count is in the first
633 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
635 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
636 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
637 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
638 || i_ehdrp
->e_shnum
== 0)
639 goto got_wrong_format_error
;
642 /* And similarly for the string table index. */
643 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
645 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
646 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
647 goto got_wrong_format_error
;
650 /* And program headers. */
651 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
653 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
654 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
655 goto got_wrong_format_error
;
658 /* Sanity check that we can read all of the section headers.
659 It ought to be good enough to just read the last one. */
660 if (i_ehdrp
->e_shnum
!= 1)
662 /* Check that we don't have a totally silly number of sections. */
663 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
664 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
665 goto got_wrong_format_error
;
667 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
668 if (where
!= (file_ptr
) where
)
669 goto got_wrong_format_error
;
670 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
671 goto got_wrong_format_error
;
673 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
675 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
678 /* Back to where we were. */
679 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
680 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
685 /* Allocate space for a copy of the section header table in
687 if (i_ehdrp
->e_shnum
!= 0)
689 Elf_Internal_Shdr
*shdrp
;
690 unsigned int num_sec
;
692 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
693 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
696 num_sec
= i_ehdrp
->e_shnum
;
697 elf_numsections (abfd
) = num_sec
;
698 amt
= sizeof (i_shdrp
) * num_sec
;
699 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
700 if (!elf_elfsections (abfd
))
703 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
704 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
705 elf_elfsections (abfd
)[shindex
] = shdrp
++;
707 /* Read in the rest of the section header table and convert it
709 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
711 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
713 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
715 /* Sanity check sh_link and sh_info. */
716 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
718 /* PR 10478: Accept Solaris binaries with a sh_link
719 field set to SHN_BEFORE or SHN_AFTER. */
720 switch (ebd
->elf_machine_code
)
729 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
730 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
732 /* Otherwise fall through. */
734 goto got_wrong_format_error
;
738 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
739 || i_shdrp
[shindex
].sh_type
== SHT_RELA
740 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
741 && i_shdrp
[shindex
].sh_info
>= num_sec
)
742 goto got_wrong_format_error
;
744 /* If the section is loaded, but not page aligned, clear
746 if (i_shdrp
[shindex
].sh_size
!= 0
747 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
748 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
749 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
752 abfd
->flags
&= ~D_PAGED
;
756 /* A further sanity check. */
757 if (i_ehdrp
->e_shnum
!= 0)
759 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
))
762 We used to just goto got_wrong_format_error here
763 but there are binaries in existance for which this test
764 will prevent the binutils from working with them at all.
765 So we are kind, and reset the string index value to 0
766 so that at least some processing can be done. */
767 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
768 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd
->filename
);
771 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
772 goto got_wrong_format_error
;
774 /* Read in the program headers. */
775 if (i_ehdrp
->e_phnum
== 0)
776 elf_tdata (abfd
)->phdr
= NULL
;
779 Elf_Internal_Phdr
*i_phdr
;
782 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
783 elf_tdata (abfd
)->phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
784 if (elf_tdata (abfd
)->phdr
== NULL
)
786 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
788 i_phdr
= elf_tdata (abfd
)->phdr
;
789 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
791 Elf_External_Phdr x_phdr
;
793 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
795 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
799 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
801 unsigned int num_sec
;
803 /* Once all of the section headers have been read and converted, we
804 can start processing them. Note that the first section header is
805 a dummy placeholder entry, so we ignore it. */
806 num_sec
= elf_numsections (abfd
);
807 for (shindex
= 1; shindex
< num_sec
; shindex
++)
808 if (!bfd_section_from_shdr (abfd
, shindex
))
811 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
812 if (! _bfd_elf_setup_sections (abfd
))
813 goto got_wrong_format_error
;
816 /* Let the backend double check the format and override global
818 if (ebd
->elf_backend_object_p
)
820 if (! (*ebd
->elf_backend_object_p
) (abfd
))
821 goto got_wrong_format_error
;
824 /* Remember the entry point specified in the ELF file header. */
825 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
827 /* If we have created any reloc sections that are associated with
828 debugging sections, mark the reloc sections as debugging as well. */
829 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
831 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
832 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
833 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
835 unsigned long targ_index
;
838 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
839 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
841 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
842 s
->flags
|= SEC_DEBUGGING
;
846 bfd_preserve_finish (abfd
, &preserve
);
849 got_wrong_format_error
:
850 /* There is way too much undoing of half-known state here. The caller,
851 bfd_check_format_matches, really shouldn't iterate on live bfd's to
852 check match/no-match like it does. We have to rely on that a call to
853 bfd_default_set_arch_mach with the previously known mach, undoes what
854 was done by the first bfd_default_set_arch_mach (with mach 0) here.
855 For this to work, only elf-data and the mach may be changed by the
856 target-specific elf_backend_object_p function. Note that saving the
857 whole bfd here and restoring it would be even worse; the first thing
858 you notice is that the cached bfd file position gets out of sync. */
859 bfd_set_error (bfd_error_wrong_format
);
862 if (preserve
.marker
!= NULL
)
863 bfd_preserve_restore (abfd
, &preserve
);
867 /* ELF .o/exec file writing */
869 /* Write out the relocs. */
872 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
874 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
875 Elf_Internal_Shdr
*rela_hdr
;
877 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
884 /* If we have already failed, don't do anything. */
888 if ((sec
->flags
& SEC_RELOC
) == 0)
891 /* The linker backend writes the relocs out itself, and sets the
892 reloc_count field to zero to inhibit writing them here. Also,
893 sometimes the SEC_RELOC flag gets set even when there aren't any
895 if (sec
->reloc_count
== 0)
898 /* If we have opened an existing file for update, reloc_count may be
899 set even though we are not linking. In that case we have nothing
901 if (sec
->orelocation
== NULL
)
904 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
905 if (rela_hdr
== NULL
)
906 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
908 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
909 rela_hdr
->contents
= (unsigned char *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
910 if (rela_hdr
->contents
== NULL
)
916 /* Figure out whether the relocations are RELA or REL relocations. */
917 if (rela_hdr
->sh_type
== SHT_RELA
)
919 swap_out
= elf_swap_reloca_out
;
920 extsize
= sizeof (Elf_External_Rela
);
922 else if (rela_hdr
->sh_type
== SHT_REL
)
924 swap_out
= elf_swap_reloc_out
;
925 extsize
= sizeof (Elf_External_Rel
);
928 /* Every relocation section should be either an SHT_RELA or an
932 /* The address of an ELF reloc is section relative for an object
933 file, and absolute for an executable file or shared library.
934 The address of a BFD reloc is always section relative. */
936 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
937 addr_offset
= sec
->vma
;
939 /* orelocation has the data, reloc_count has the count... */
942 dst_rela
= rela_hdr
->contents
;
944 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
946 Elf_Internal_Rela src_rela
;
951 ptr
= sec
->orelocation
[idx
];
952 sym
= *ptr
->sym_ptr_ptr
;
955 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
960 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
969 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
970 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
971 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
977 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
978 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
979 src_rela
.r_addend
= ptr
->addend
;
980 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
984 /* Write out the program headers. */
987 elf_write_out_phdrs (bfd
*abfd
,
988 const Elf_Internal_Phdr
*phdr
,
993 Elf_External_Phdr extphdr
;
994 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
995 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
996 != sizeof (Elf_External_Phdr
))
1003 /* Write out the section headers and the ELF file header. */
1006 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1008 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1009 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1010 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1011 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1015 i_ehdrp
= elf_elfheader (abfd
);
1016 i_shdrp
= elf_elfsections (abfd
);
1018 /* swap the header before spitting it out... */
1021 elf_debug_file (i_ehdrp
);
1023 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1024 amt
= sizeof (x_ehdr
);
1025 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1026 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1029 /* Some fields in the first section header handle overflow of ehdr
1031 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1032 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1033 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1034 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1035 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1036 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1038 /* at this point we've concocted all the ELF sections... */
1039 amt
= i_ehdrp
->e_shnum
;
1040 amt
*= sizeof (*x_shdrp
);
1041 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1045 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1048 elf_debug_section (count
, *i_shdrp
);
1050 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1052 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1053 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1056 /* need to dump the string table too... */
1062 elf_checksum_contents (bfd
*abfd
,
1063 void (*process
) (const void *, size_t, void *),
1066 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1067 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1068 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1069 unsigned int count
, num
;
1072 Elf_External_Ehdr x_ehdr
;
1073 Elf_Internal_Ehdr i_ehdr
;
1076 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1077 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1078 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1081 num
= i_ehdrp
->e_phnum
;
1082 for (count
= 0; count
< num
; count
++)
1084 Elf_External_Phdr x_phdr
;
1085 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1086 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1089 num
= elf_numsections (abfd
);
1090 for (count
= 0; count
< num
; count
++)
1092 Elf_Internal_Shdr i_shdr
;
1093 Elf_External_Shdr x_shdr
;
1095 i_shdr
= *i_shdrp
[count
];
1096 i_shdr
.sh_offset
= 0;
1098 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1099 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1102 Process the section's contents, if it has some. Read them in if necessary. */
1103 if (i_shdr
.contents
)
1104 (*process
) (i_shdr
.contents
, i_shdr
.sh_size
, arg
);
1105 else if (i_shdr
.sh_type
!= SHT_NOBITS
)
1109 sec
= bfd_section_from_elf_index (abfd
, count
);
1112 if (sec
->contents
== NULL
)
1114 /* Force rereading from file. */
1115 sec
->flags
&= ~SEC_IN_MEMORY
;
1116 if (! bfd_malloc_and_get_section (abfd
, sec
, & sec
->contents
))
1119 if (sec
->contents
!= NULL
)
1120 (*process
) (sec
->contents
, i_shdr
.sh_size
, arg
);
1129 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1131 Elf_Internal_Shdr
*hdr
;
1132 Elf_Internal_Shdr
*verhdr
;
1133 unsigned long symcount
; /* Number of external ELF symbols */
1134 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1135 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1136 Elf_Internal_Sym
*isym
;
1137 Elf_Internal_Sym
*isymend
;
1138 Elf_Internal_Sym
*isymbuf
= NULL
;
1139 Elf_External_Versym
*xver
;
1140 Elf_External_Versym
*xverbuf
= NULL
;
1141 const struct elf_backend_data
*ebd
;
1144 /* Read each raw ELF symbol, converting from external ELF form to
1145 internal ELF form, and then using the information to create a
1146 canonical bfd symbol table entry.
1148 Note that we allocate the initial bfd canonical symbol buffer
1149 based on a one-to-one mapping of the ELF symbols to canonical
1150 symbols. We actually use all the ELF symbols, so there will be no
1151 space left over at the end. When we have all the symbols, we
1152 build the caller's pointer vector. */
1156 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1161 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1162 if (elf_dynversym (abfd
) == 0)
1165 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1166 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1167 && elf_tdata (abfd
)->verdef
== NULL
)
1168 || (elf_tdata (abfd
)->dynverref_section
!= 0
1169 && elf_tdata (abfd
)->verref
== NULL
))
1171 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1176 ebd
= get_elf_backend_data (abfd
);
1177 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1179 sym
= symbase
= NULL
;
1182 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1184 if (isymbuf
== NULL
)
1188 amt
*= sizeof (elf_symbol_type
);
1189 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1190 if (symbase
== (elf_symbol_type
*) NULL
)
1193 /* Read the raw ELF version symbol information. */
1195 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1197 (*_bfd_error_handler
)
1198 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1200 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1203 /* Slurp in the symbols without the version information,
1204 since that is more helpful than just quitting. */
1210 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1213 xverbuf
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1214 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1217 if (bfd_bread (xverbuf
, verhdr
->sh_size
, abfd
) != verhdr
->sh_size
)
1221 /* Skip first symbol, which is a null dummy. */
1225 isymend
= isymbuf
+ symcount
;
1226 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1228 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1229 sym
->symbol
.the_bfd
= abfd
;
1231 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1233 sym
->symbol
.value
= isym
->st_value
;
1235 if (isym
->st_shndx
== SHN_UNDEF
)
1237 sym
->symbol
.section
= bfd_und_section_ptr
;
1239 else if (isym
->st_shndx
== SHN_ABS
)
1241 sym
->symbol
.section
= bfd_abs_section_ptr
;
1243 else if (isym
->st_shndx
== SHN_COMMON
)
1245 sym
->symbol
.section
= bfd_com_section_ptr
;
1246 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1248 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1252 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1254 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1258 sym
->symbol
.section
= xc
;
1260 /* Elf puts the alignment into the `value' field, and
1261 the size into the `size' field. BFD wants to see the
1262 size in the value field, and doesn't care (at the
1263 moment) about the alignment. */
1264 sym
->symbol
.value
= isym
->st_size
;
1269 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1270 if (sym
->symbol
.section
== NULL
)
1272 /* This symbol is in a section for which we did not
1273 create a BFD section. Just use bfd_abs_section,
1274 although it is wrong. FIXME. */
1275 sym
->symbol
.section
= bfd_abs_section_ptr
;
1279 /* If this is a relocatable file, then the symbol value is
1280 already section relative. */
1281 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1282 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1284 switch (ELF_ST_BIND (isym
->st_info
))
1287 sym
->symbol
.flags
|= BSF_LOCAL
;
1290 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1291 sym
->symbol
.flags
|= BSF_GLOBAL
;
1294 sym
->symbol
.flags
|= BSF_WEAK
;
1296 case STB_GNU_UNIQUE
:
1297 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1301 switch (ELF_ST_TYPE (isym
->st_info
))
1304 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1307 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1310 sym
->symbol
.flags
|= BSF_FUNCTION
;
1313 /* FIXME: Do we have to put the size field into the value field
1314 as we do with symbols in SHN_COMMON sections (see above) ? */
1317 sym
->symbol
.flags
|= BSF_OBJECT
;
1320 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1323 sym
->symbol
.flags
|= BSF_RELC
;
1326 sym
->symbol
.flags
|= BSF_SRELC
;
1329 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1334 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1338 Elf_Internal_Versym iversym
;
1340 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1341 sym
->version
= iversym
.vs_vers
;
1345 /* Do some backend-specific processing on this symbol. */
1346 if (ebd
->elf_backend_symbol_processing
)
1347 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1351 /* Do some backend-specific processing on this symbol table. */
1352 if (ebd
->elf_backend_symbol_table_processing
)
1353 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1355 /* We rely on the zalloc to clear out the final symbol entry. */
1357 symcount
= sym
- symbase
;
1359 /* Fill in the user's symbol pointer vector if needed. */
1367 *symptrs
++ = &sym
->symbol
;
1370 *symptrs
= 0; /* Final null pointer */
1373 if (xverbuf
!= NULL
)
1375 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1380 if (xverbuf
!= NULL
)
1382 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1387 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1391 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1393 Elf_Internal_Shdr
*rel_hdr
,
1394 bfd_size_type reloc_count
,
1397 bfd_boolean dynamic
)
1399 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1400 void *allocated
= NULL
;
1401 bfd_byte
*native_relocs
;
1405 unsigned int symcount
;
1407 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1408 if (allocated
== NULL
)
1411 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1412 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1413 != rel_hdr
->sh_size
))
1416 native_relocs
= (bfd_byte
*) allocated
;
1418 entsize
= rel_hdr
->sh_entsize
;
1419 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1420 || entsize
== sizeof (Elf_External_Rela
));
1423 symcount
= bfd_get_dynamic_symcount (abfd
);
1425 symcount
= bfd_get_symcount (abfd
);
1427 for (i
= 0, relent
= relents
;
1429 i
++, relent
++, native_relocs
+= entsize
)
1431 Elf_Internal_Rela rela
;
1433 if (entsize
== sizeof (Elf_External_Rela
))
1434 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1436 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1438 /* The address of an ELF reloc is section relative for an object
1439 file, and absolute for an executable file or shared library.
1440 The address of a normal BFD reloc is always section relative,
1441 and the address of a dynamic reloc is absolute.. */
1442 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1443 relent
->address
= rela
.r_offset
;
1445 relent
->address
= rela
.r_offset
- asect
->vma
;
1447 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1448 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1449 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1451 (*_bfd_error_handler
)
1452 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1453 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1454 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1460 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1462 relent
->sym_ptr_ptr
= ps
;
1465 relent
->addend
= rela
.r_addend
;
1467 if ((entsize
== sizeof (Elf_External_Rela
)
1468 && ebd
->elf_info_to_howto
!= NULL
)
1469 || ebd
->elf_info_to_howto_rel
== NULL
)
1470 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1472 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1475 if (allocated
!= NULL
)
1481 if (allocated
!= NULL
)
1486 /* Read in and swap the external relocs. */
1489 elf_slurp_reloc_table (bfd
*abfd
,
1492 bfd_boolean dynamic
)
1494 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1495 Elf_Internal_Shdr
*rel_hdr
;
1496 Elf_Internal_Shdr
*rel_hdr2
;
1497 bfd_size_type reloc_count
;
1498 bfd_size_type reloc_count2
;
1502 if (asect
->relocation
!= NULL
)
1507 if ((asect
->flags
& SEC_RELOC
) == 0
1508 || asect
->reloc_count
== 0)
1511 rel_hdr
= d
->rel
.hdr
;
1512 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1513 rel_hdr2
= d
->rela
.hdr
;
1514 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1516 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1517 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1518 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1523 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1524 case because relocations against this section may use the
1525 dynamic symbol table, and in that case bfd_section_from_shdr
1526 in elf.c does not update the RELOC_COUNT. */
1527 if (asect
->size
== 0)
1530 rel_hdr
= &d
->this_hdr
;
1531 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1536 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1537 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1538 if (relents
== NULL
)
1542 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1543 rel_hdr
, reloc_count
,
1549 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1550 rel_hdr2
, reloc_count2
,
1551 relents
+ reloc_count
,
1555 asect
->relocation
= relents
;
1561 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1563 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1564 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1567 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1568 (long) hdr
->sh_name
,
1569 (long) hdr
->sh_type
,
1570 (long) hdr
->sh_flags
);
1572 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1573 (long) hdr
->sh_addr
,
1574 (long) hdr
->sh_offset
,
1575 (long) hdr
->sh_size
);
1577 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1578 (long) hdr
->sh_link
,
1579 (long) hdr
->sh_info
,
1580 (long) hdr
->sh_addralign
);
1581 fprintf (stderr
, "sh_entsize = %ld\n",
1582 (long) hdr
->sh_entsize
);
1589 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1591 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1592 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1593 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1594 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1595 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1596 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1597 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1601 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1602 reconstruct an ELF file by reading the segments out of remote memory
1603 based on the ELF file header at EHDR_VMA and the ELF program headers it
1604 points to. If not null, *LOADBASEP is filled in with the difference
1605 between the VMAs from which the segments were read, and the VMAs the
1606 file headers (and hence BFD's idea of each section's VMA) put them at.
1608 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1609 remote memory at target address VMA into the local buffer at MYADDR; it
1610 should return zero on success or an `errno' code on failure. TEMPL must
1611 be a BFD for a target with the word size and byte order found in the
1615 NAME(_bfd_elf
,bfd_from_remote_memory
)
1619 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1621 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1622 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1623 Elf_External_Phdr
*x_phdrs
;
1624 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1626 struct bfd_in_memory
*bim
;
1632 bfd_boolean loadbase_set
;
1634 /* Read in the ELF header in external format. */
1635 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1638 bfd_set_error (bfd_error_system_call
);
1643 /* Now check to see if we have a valid ELF file, and one that BFD can
1644 make use of. The magic number must match, the address size ('class')
1645 and byte-swapping must match our XVEC entry. */
1647 if (! elf_file_p (&x_ehdr
)
1648 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1649 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1651 bfd_set_error (bfd_error_wrong_format
);
1655 /* Check that file's byte order matches xvec's */
1656 switch (x_ehdr
.e_ident
[EI_DATA
])
1658 case ELFDATA2MSB
: /* Big-endian */
1659 if (! bfd_header_big_endian (templ
))
1661 bfd_set_error (bfd_error_wrong_format
);
1665 case ELFDATA2LSB
: /* Little-endian */
1666 if (! bfd_header_little_endian (templ
))
1668 bfd_set_error (bfd_error_wrong_format
);
1672 case ELFDATANONE
: /* No data encoding specified */
1673 default: /* Unknown data encoding specified */
1674 bfd_set_error (bfd_error_wrong_format
);
1678 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1680 /* The file header tells where to find the program headers.
1681 These are what we use to actually choose what to read. */
1683 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1685 bfd_set_error (bfd_error_wrong_format
);
1689 x_phdrs
= (Elf_External_Phdr
*)
1690 bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1691 if (x_phdrs
== NULL
)
1693 bfd_set_error (bfd_error_no_memory
);
1696 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1697 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1701 bfd_set_error (bfd_error_system_call
);
1705 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1709 loadbase
= ehdr_vma
;
1710 loadbase_set
= FALSE
;
1711 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1713 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1714 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1716 bfd_vma segment_end
;
1717 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1718 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1719 if (segment_end
> (bfd_vma
) contents_size
)
1720 contents_size
= segment_end
;
1722 /* LOADADDR is the `Base address' from the gELF specification:
1723 `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1724 first PT_LOAD as PT_LOADs are ordered by P_VADDR. */
1725 if (!loadbase_set
&& (i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1727 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1728 loadbase_set
= TRUE
;
1731 last_phdr
= &i_phdrs
[i
];
1734 if (last_phdr
== NULL
)
1736 /* There were no PT_LOAD segments, so we don't have anything to read. */
1738 bfd_set_error (bfd_error_wrong_format
);
1742 /* Trim the last segment so we don't bother with zeros in the last page
1743 that are off the end of the file. However, if the extra bit in that
1744 page includes the section headers, keep them. */
1745 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1746 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1747 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1749 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1750 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1751 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1752 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1755 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1757 /* Now we know the size of the whole image we want read in. */
1758 contents
= (bfd_byte
*) bfd_zmalloc (contents_size
);
1759 if (contents
== NULL
)
1762 bfd_set_error (bfd_error_no_memory
);
1766 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1767 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1769 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1770 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1771 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1772 if (end
> (bfd_vma
) contents_size
)
1773 end
= contents_size
;
1774 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1775 & -i_phdrs
[i
].p_align
,
1776 contents
+ start
, end
- start
);
1781 bfd_set_error (bfd_error_system_call
);
1788 /* If the segments visible in memory didn't include the section headers,
1789 then clear them from the file header. */
1790 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1791 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1793 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1794 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1795 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1798 /* This will normally have been in the first PT_LOAD segment. But it
1799 conceivably could be missing, and we might have just changed it. */
1800 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1802 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1803 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1807 bfd_set_error (bfd_error_no_memory
);
1810 nbfd
= _bfd_new_bfd ();
1815 bfd_set_error (bfd_error_no_memory
);
1818 nbfd
->filename
= "<in-memory>";
1819 nbfd
->xvec
= templ
->xvec
;
1820 bim
->size
= contents_size
;
1821 bim
->buffer
= contents
;
1822 nbfd
->iostream
= bim
;
1823 nbfd
->flags
= BFD_IN_MEMORY
;
1824 nbfd
->iovec
= &_bfd_memory_iovec
;
1826 nbfd
->direction
= read_direction
;
1827 nbfd
->mtime
= time (NULL
);
1828 nbfd
->mtime_set
= TRUE
;
1831 *loadbasep
= loadbase
;
1835 /* Function for ELF_R_INFO. */
1838 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
1840 return ELF_R_INFO (sym
, type
);
1843 /* Function for ELF_R_SYM. */
1846 NAME(elf
,r_sym
) (bfd_vma r_info
)
1848 return ELF_R_SYM (r_info
);
1851 #include "elfcore.h"
1853 /* Size-dependent data and functions. */
1854 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1855 sizeof (Elf_External_Ehdr
),
1856 sizeof (Elf_External_Phdr
),
1857 sizeof (Elf_External_Shdr
),
1858 sizeof (Elf_External_Rel
),
1859 sizeof (Elf_External_Rela
),
1860 sizeof (Elf_External_Sym
),
1861 sizeof (Elf_External_Dyn
),
1862 sizeof (Elf_External_Note
),
1865 ARCH_SIZE
, LOG_FILE_ALIGN
,
1866 ELFCLASS
, EV_CURRENT
,
1867 elf_write_out_phdrs
,
1868 elf_write_shdrs_and_ehdr
,
1869 elf_checksum_contents
,
1872 elf_swap_symbol_out
,
1873 elf_slurp_reloc_table
,
1874 elf_slurp_symbol_table
,