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
;
500 const bfd_target
*target
;
502 /* Read in the ELF header in external format. */
504 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
506 if (bfd_get_error () != bfd_error_system_call
)
507 goto got_wrong_format_error
;
512 /* Now check to see if we have a valid ELF file, and one that BFD can
513 make use of. The magic number must match, the address size ('class')
514 and byte-swapping must match our XVEC entry, and it must have a
515 section header table (FIXME: See comments re sections at top of this
518 if (! elf_file_p (&x_ehdr
)
519 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
520 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
521 goto got_wrong_format_error
;
523 /* Check that file's byte order matches xvec's */
524 switch (x_ehdr
.e_ident
[EI_DATA
])
526 case ELFDATA2MSB
: /* Big-endian */
527 if (! bfd_header_big_endian (abfd
))
528 goto got_wrong_format_error
;
530 case ELFDATA2LSB
: /* Little-endian */
531 if (! bfd_header_little_endian (abfd
))
532 goto got_wrong_format_error
;
534 case ELFDATANONE
: /* No data encoding specified */
535 default: /* Unknown data encoding specified */
536 goto got_wrong_format_error
;
541 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
542 the tdata pointer in the bfd. */
544 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
547 /* Now that we know the byte order, swap in the rest of the header */
548 i_ehdrp
= elf_elfheader (abfd
);
549 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
551 elf_debug_file (i_ehdrp
);
554 /* Reject ET_CORE (header indicates core file, not object file) */
555 if (i_ehdrp
->e_type
== ET_CORE
)
556 goto got_wrong_format_error
;
558 /* If this is a relocatable file and there is no section header
559 table, then we're hosed. */
560 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
561 goto got_wrong_format_error
;
563 /* As a simple sanity check, verify that what BFD thinks is the
564 size of each section header table entry actually matches the size
565 recorded in the file, but only if there are any sections. */
566 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
567 goto got_wrong_format_error
;
569 /* Further sanity check. */
570 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
571 goto got_wrong_format_error
;
573 ebd
= get_elf_backend_data (abfd
);
574 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
575 goto got_wrong_format_error
;
577 /* Check that the ELF e_machine field matches what this particular
578 BFD format expects. */
579 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
580 && (ebd
->elf_machine_alt1
== 0
581 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
582 && (ebd
->elf_machine_alt2
== 0
583 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
584 && ebd
->elf_machine_code
!= EM_NONE
)
585 goto got_wrong_format_error
;
587 if (i_ehdrp
->e_type
== ET_EXEC
)
588 abfd
->flags
|= EXEC_P
;
589 else if (i_ehdrp
->e_type
== ET_DYN
)
590 abfd
->flags
|= DYNAMIC
;
592 if (i_ehdrp
->e_phnum
> 0)
593 abfd
->flags
|= D_PAGED
;
595 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
597 /* It's OK if this fails for the generic target. */
598 if (ebd
->elf_machine_code
!= EM_NONE
)
602 if (ebd
->elf_machine_code
!= EM_NONE
603 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
604 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
605 goto got_wrong_format_error
;
607 if (i_ehdrp
->e_shoff
!= 0)
609 bfd_signed_vma where
= i_ehdrp
->e_shoff
;
611 if (where
!= (file_ptr
) where
)
612 goto got_wrong_format_error
;
614 /* Seek to the section header table in the file. */
615 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
618 /* Read the first section header at index 0, and convert to internal
620 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
622 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
624 /* If the section count is zero, the actual count is in the first
626 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
628 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
629 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
630 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
631 || i_ehdrp
->e_shnum
== 0)
632 goto got_wrong_format_error
;
635 /* And similarly for the string table index. */
636 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
638 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
639 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
640 goto got_wrong_format_error
;
643 /* And program headers. */
644 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
646 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
647 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
648 goto got_wrong_format_error
;
651 /* Sanity check that we can read all of the section headers.
652 It ought to be good enough to just read the last one. */
653 if (i_ehdrp
->e_shnum
!= 1)
655 /* Check that we don't have a totally silly number of sections. */
656 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
657 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
658 goto got_wrong_format_error
;
660 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
661 if (where
!= (file_ptr
) where
)
662 goto got_wrong_format_error
;
663 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
664 goto got_wrong_format_error
;
666 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
668 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
671 /* Back to where we were. */
672 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
673 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
678 /* Allocate space for a copy of the section header table in
680 if (i_ehdrp
->e_shnum
!= 0)
682 Elf_Internal_Shdr
*shdrp
;
683 unsigned int num_sec
;
685 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
686 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
689 num_sec
= i_ehdrp
->e_shnum
;
690 elf_numsections (abfd
) = num_sec
;
691 amt
= sizeof (i_shdrp
) * num_sec
;
692 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
693 if (!elf_elfsections (abfd
))
696 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
697 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
698 elf_elfsections (abfd
)[shindex
] = shdrp
++;
700 /* Read in the rest of the section header table and convert it
702 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
704 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
706 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
708 /* Sanity check sh_link and sh_info. */
709 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
711 /* PR 10478: Accept Solaris binaries with a sh_link
712 field set to SHN_BEFORE or SHN_AFTER. */
713 switch (ebd
->elf_machine_code
)
722 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
723 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
725 /* Otherwise fall through. */
727 goto got_wrong_format_error
;
731 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
732 || i_shdrp
[shindex
].sh_type
== SHT_RELA
733 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
734 && i_shdrp
[shindex
].sh_info
>= num_sec
)
735 goto got_wrong_format_error
;
737 /* If the section is loaded, but not page aligned, clear
739 if (i_shdrp
[shindex
].sh_size
!= 0
740 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
741 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
742 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
745 abfd
->flags
&= ~D_PAGED
;
749 /* A further sanity check. */
750 if (i_ehdrp
->e_shnum
!= 0)
752 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
))
755 We used to just goto got_wrong_format_error here
756 but there are binaries in existance for which this test
757 will prevent the binutils from working with them at all.
758 So we are kind, and reset the string index value to 0
759 so that at least some processing can be done. */
760 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
761 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd
->filename
);
764 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
765 goto got_wrong_format_error
;
767 /* Read in the program headers. */
768 if (i_ehdrp
->e_phnum
== 0)
769 elf_tdata (abfd
)->phdr
= NULL
;
772 Elf_Internal_Phdr
*i_phdr
;
775 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
776 elf_tdata (abfd
)->phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
777 if (elf_tdata (abfd
)->phdr
== NULL
)
779 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
781 i_phdr
= elf_tdata (abfd
)->phdr
;
782 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
784 Elf_External_Phdr x_phdr
;
786 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
788 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
792 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
794 unsigned int num_sec
;
796 /* Once all of the section headers have been read and converted, we
797 can start processing them. Note that the first section header is
798 a dummy placeholder entry, so we ignore it. */
799 num_sec
= elf_numsections (abfd
);
800 for (shindex
= 1; shindex
< num_sec
; shindex
++)
801 if (!bfd_section_from_shdr (abfd
, shindex
))
804 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
805 if (! _bfd_elf_setup_sections (abfd
))
806 goto got_wrong_format_error
;
809 /* Let the backend double check the format and override global
811 if (ebd
->elf_backend_object_p
)
813 if (! (*ebd
->elf_backend_object_p
) (abfd
))
814 goto got_wrong_format_error
;
817 /* Remember the entry point specified in the ELF file header. */
818 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
820 /* If we have created any reloc sections that are associated with
821 debugging sections, mark the reloc sections as debugging as well. */
822 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
824 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
825 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
826 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
828 unsigned long targ_index
;
831 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
832 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
834 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
835 s
->flags
|= SEC_DEBUGGING
;
840 got_wrong_format_error
:
841 bfd_set_error (bfd_error_wrong_format
);
847 /* ELF .o/exec file writing */
849 /* Write out the relocs. */
852 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
854 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
855 Elf_Internal_Shdr
*rela_hdr
;
857 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
864 /* If we have already failed, don't do anything. */
868 if ((sec
->flags
& SEC_RELOC
) == 0)
871 /* The linker backend writes the relocs out itself, and sets the
872 reloc_count field to zero to inhibit writing them here. Also,
873 sometimes the SEC_RELOC flag gets set even when there aren't any
875 if (sec
->reloc_count
== 0)
878 /* If we have opened an existing file for update, reloc_count may be
879 set even though we are not linking. In that case we have nothing
881 if (sec
->orelocation
== NULL
)
884 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
885 if (rela_hdr
== NULL
)
886 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
888 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
889 rela_hdr
->contents
= (unsigned char *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
890 if (rela_hdr
->contents
== NULL
)
896 /* Figure out whether the relocations are RELA or REL relocations. */
897 if (rela_hdr
->sh_type
== SHT_RELA
)
899 swap_out
= elf_swap_reloca_out
;
900 extsize
= sizeof (Elf_External_Rela
);
902 else if (rela_hdr
->sh_type
== SHT_REL
)
904 swap_out
= elf_swap_reloc_out
;
905 extsize
= sizeof (Elf_External_Rel
);
908 /* Every relocation section should be either an SHT_RELA or an
912 /* The address of an ELF reloc is section relative for an object
913 file, and absolute for an executable file or shared library.
914 The address of a BFD reloc is always section relative. */
916 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
917 addr_offset
= sec
->vma
;
919 /* orelocation has the data, reloc_count has the count... */
922 dst_rela
= rela_hdr
->contents
;
924 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
926 Elf_Internal_Rela src_rela
;
931 ptr
= sec
->orelocation
[idx
];
932 sym
= *ptr
->sym_ptr_ptr
;
935 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
940 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
949 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
950 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
951 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
957 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
958 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
959 src_rela
.r_addend
= ptr
->addend
;
960 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
964 /* Write out the program headers. */
967 elf_write_out_phdrs (bfd
*abfd
,
968 const Elf_Internal_Phdr
*phdr
,
973 Elf_External_Phdr extphdr
;
974 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
975 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
976 != sizeof (Elf_External_Phdr
))
983 /* Write out the section headers and the ELF file header. */
986 elf_write_shdrs_and_ehdr (bfd
*abfd
)
988 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
989 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
990 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
991 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
995 i_ehdrp
= elf_elfheader (abfd
);
996 i_shdrp
= elf_elfsections (abfd
);
998 /* swap the header before spitting it out... */
1001 elf_debug_file (i_ehdrp
);
1003 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1004 amt
= sizeof (x_ehdr
);
1005 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1006 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1009 /* Some fields in the first section header handle overflow of ehdr
1011 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1012 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1013 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1014 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1015 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1016 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1018 /* at this point we've concocted all the ELF sections... */
1019 amt
= i_ehdrp
->e_shnum
;
1020 amt
*= sizeof (*x_shdrp
);
1021 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1025 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1028 elf_debug_section (count
, *i_shdrp
);
1030 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1032 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1033 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1036 /* need to dump the string table too... */
1042 elf_checksum_contents (bfd
*abfd
,
1043 void (*process
) (const void *, size_t, void *),
1046 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1047 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1048 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1049 unsigned int count
, num
;
1052 Elf_External_Ehdr x_ehdr
;
1053 Elf_Internal_Ehdr i_ehdr
;
1056 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1057 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1058 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1061 num
= i_ehdrp
->e_phnum
;
1062 for (count
= 0; count
< num
; count
++)
1064 Elf_External_Phdr x_phdr
;
1065 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1066 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1069 num
= elf_numsections (abfd
);
1070 for (count
= 0; count
< num
; count
++)
1072 Elf_Internal_Shdr i_shdr
;
1073 Elf_External_Shdr x_shdr
;
1075 i_shdr
= *i_shdrp
[count
];
1076 i_shdr
.sh_offset
= 0;
1078 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1079 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1082 Process the section's contents, if it has some. Read them in if necessary. */
1083 if (i_shdr
.contents
)
1084 (*process
) (i_shdr
.contents
, i_shdr
.sh_size
, arg
);
1085 else if (i_shdr
.sh_type
!= SHT_NOBITS
)
1089 sec
= bfd_section_from_elf_index (abfd
, count
);
1092 if (sec
->contents
== NULL
)
1094 /* Force rereading from file. */
1095 sec
->flags
&= ~SEC_IN_MEMORY
;
1096 if (! bfd_malloc_and_get_section (abfd
, sec
, & sec
->contents
))
1099 if (sec
->contents
!= NULL
)
1100 (*process
) (sec
->contents
, i_shdr
.sh_size
, arg
);
1109 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1111 Elf_Internal_Shdr
*hdr
;
1112 Elf_Internal_Shdr
*verhdr
;
1113 unsigned long symcount
; /* Number of external ELF symbols */
1114 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1115 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1116 Elf_Internal_Sym
*isym
;
1117 Elf_Internal_Sym
*isymend
;
1118 Elf_Internal_Sym
*isymbuf
= NULL
;
1119 Elf_External_Versym
*xver
;
1120 Elf_External_Versym
*xverbuf
= NULL
;
1121 const struct elf_backend_data
*ebd
;
1124 /* Read each raw ELF symbol, converting from external ELF form to
1125 internal ELF form, and then using the information to create a
1126 canonical bfd symbol table entry.
1128 Note that we allocate the initial bfd canonical symbol buffer
1129 based on a one-to-one mapping of the ELF symbols to canonical
1130 symbols. We actually use all the ELF symbols, so there will be no
1131 space left over at the end. When we have all the symbols, we
1132 build the caller's pointer vector. */
1136 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1141 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1142 if (elf_dynversym (abfd
) == 0)
1145 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1146 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1147 && elf_tdata (abfd
)->verdef
== NULL
)
1148 || (elf_tdata (abfd
)->dynverref_section
!= 0
1149 && elf_tdata (abfd
)->verref
== NULL
))
1151 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1156 ebd
= get_elf_backend_data (abfd
);
1157 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1159 sym
= symbase
= NULL
;
1162 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1164 if (isymbuf
== NULL
)
1168 amt
*= sizeof (elf_symbol_type
);
1169 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1170 if (symbase
== (elf_symbol_type
*) NULL
)
1173 /* Read the raw ELF version symbol information. */
1175 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1177 (*_bfd_error_handler
)
1178 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1180 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1183 /* Slurp in the symbols without the version information,
1184 since that is more helpful than just quitting. */
1190 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1193 xverbuf
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1194 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1197 if (bfd_bread (xverbuf
, verhdr
->sh_size
, abfd
) != verhdr
->sh_size
)
1201 /* Skip first symbol, which is a null dummy. */
1205 isymend
= isymbuf
+ symcount
;
1206 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1208 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1209 sym
->symbol
.the_bfd
= abfd
;
1211 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1213 sym
->symbol
.value
= isym
->st_value
;
1215 if (isym
->st_shndx
== SHN_UNDEF
)
1217 sym
->symbol
.section
= bfd_und_section_ptr
;
1219 else if (isym
->st_shndx
== SHN_ABS
)
1221 sym
->symbol
.section
= bfd_abs_section_ptr
;
1223 else if (isym
->st_shndx
== SHN_COMMON
)
1225 sym
->symbol
.section
= bfd_com_section_ptr
;
1226 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1228 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1232 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1234 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1238 sym
->symbol
.section
= xc
;
1240 /* Elf puts the alignment into the `value' field, and
1241 the size into the `size' field. BFD wants to see the
1242 size in the value field, and doesn't care (at the
1243 moment) about the alignment. */
1244 sym
->symbol
.value
= isym
->st_size
;
1249 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1250 if (sym
->symbol
.section
== NULL
)
1252 /* This symbol is in a section for which we did not
1253 create a BFD section. Just use bfd_abs_section,
1254 although it is wrong. FIXME. */
1255 sym
->symbol
.section
= bfd_abs_section_ptr
;
1259 /* If this is a relocatable file, then the symbol value is
1260 already section relative. */
1261 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1262 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1264 switch (ELF_ST_BIND (isym
->st_info
))
1267 sym
->symbol
.flags
|= BSF_LOCAL
;
1270 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1271 sym
->symbol
.flags
|= BSF_GLOBAL
;
1274 sym
->symbol
.flags
|= BSF_WEAK
;
1276 case STB_GNU_UNIQUE
:
1277 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1281 switch (ELF_ST_TYPE (isym
->st_info
))
1284 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1287 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1290 sym
->symbol
.flags
|= BSF_FUNCTION
;
1293 /* FIXME: Do we have to put the size field into the value field
1294 as we do with symbols in SHN_COMMON sections (see above) ? */
1297 sym
->symbol
.flags
|= BSF_OBJECT
;
1300 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1303 sym
->symbol
.flags
|= BSF_RELC
;
1306 sym
->symbol
.flags
|= BSF_SRELC
;
1309 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1314 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1318 Elf_Internal_Versym iversym
;
1320 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1321 sym
->version
= iversym
.vs_vers
;
1325 /* Do some backend-specific processing on this symbol. */
1326 if (ebd
->elf_backend_symbol_processing
)
1327 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1331 /* Do some backend-specific processing on this symbol table. */
1332 if (ebd
->elf_backend_symbol_table_processing
)
1333 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1335 /* We rely on the zalloc to clear out the final symbol entry. */
1337 symcount
= sym
- symbase
;
1339 /* Fill in the user's symbol pointer vector if needed. */
1347 *symptrs
++ = &sym
->symbol
;
1350 *symptrs
= 0; /* Final null pointer */
1353 if (xverbuf
!= NULL
)
1355 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1360 if (xverbuf
!= NULL
)
1362 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1367 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1371 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1373 Elf_Internal_Shdr
*rel_hdr
,
1374 bfd_size_type reloc_count
,
1377 bfd_boolean dynamic
)
1379 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1380 void *allocated
= NULL
;
1381 bfd_byte
*native_relocs
;
1385 unsigned int symcount
;
1387 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1388 if (allocated
== NULL
)
1391 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1392 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1393 != rel_hdr
->sh_size
))
1396 native_relocs
= (bfd_byte
*) allocated
;
1398 entsize
= rel_hdr
->sh_entsize
;
1399 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1400 || entsize
== sizeof (Elf_External_Rela
));
1403 symcount
= bfd_get_dynamic_symcount (abfd
);
1405 symcount
= bfd_get_symcount (abfd
);
1407 for (i
= 0, relent
= relents
;
1409 i
++, relent
++, native_relocs
+= entsize
)
1411 Elf_Internal_Rela rela
;
1413 if (entsize
== sizeof (Elf_External_Rela
))
1414 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1416 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1418 /* The address of an ELF reloc is section relative for an object
1419 file, and absolute for an executable file or shared library.
1420 The address of a normal BFD reloc is always section relative,
1421 and the address of a dynamic reloc is absolute.. */
1422 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1423 relent
->address
= rela
.r_offset
;
1425 relent
->address
= rela
.r_offset
- asect
->vma
;
1427 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1428 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1429 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1431 (*_bfd_error_handler
)
1432 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1433 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1434 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1440 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1442 relent
->sym_ptr_ptr
= ps
;
1445 relent
->addend
= rela
.r_addend
;
1447 if ((entsize
== sizeof (Elf_External_Rela
)
1448 && ebd
->elf_info_to_howto
!= NULL
)
1449 || ebd
->elf_info_to_howto_rel
== NULL
)
1450 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1452 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1455 if (allocated
!= NULL
)
1461 if (allocated
!= NULL
)
1466 /* Read in and swap the external relocs. */
1469 elf_slurp_reloc_table (bfd
*abfd
,
1472 bfd_boolean dynamic
)
1474 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1475 Elf_Internal_Shdr
*rel_hdr
;
1476 Elf_Internal_Shdr
*rel_hdr2
;
1477 bfd_size_type reloc_count
;
1478 bfd_size_type reloc_count2
;
1482 if (asect
->relocation
!= NULL
)
1487 if ((asect
->flags
& SEC_RELOC
) == 0
1488 || asect
->reloc_count
== 0)
1491 rel_hdr
= d
->rel
.hdr
;
1492 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1493 rel_hdr2
= d
->rela
.hdr
;
1494 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1496 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1497 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1498 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1503 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1504 case because relocations against this section may use the
1505 dynamic symbol table, and in that case bfd_section_from_shdr
1506 in elf.c does not update the RELOC_COUNT. */
1507 if (asect
->size
== 0)
1510 rel_hdr
= &d
->this_hdr
;
1511 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1516 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1517 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1518 if (relents
== NULL
)
1522 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1523 rel_hdr
, reloc_count
,
1529 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1530 rel_hdr2
, reloc_count2
,
1531 relents
+ reloc_count
,
1535 asect
->relocation
= relents
;
1541 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1543 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1544 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1547 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1548 (long) hdr
->sh_name
,
1549 (long) hdr
->sh_type
,
1550 (long) hdr
->sh_flags
);
1552 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1553 (long) hdr
->sh_addr
,
1554 (long) hdr
->sh_offset
,
1555 (long) hdr
->sh_size
);
1557 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1558 (long) hdr
->sh_link
,
1559 (long) hdr
->sh_info
,
1560 (long) hdr
->sh_addralign
);
1561 fprintf (stderr
, "sh_entsize = %ld\n",
1562 (long) hdr
->sh_entsize
);
1569 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1571 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1572 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1573 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1574 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1575 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1576 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1577 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1581 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1582 reconstruct an ELF file by reading the segments out of remote memory
1583 based on the ELF file header at EHDR_VMA and the ELF program headers it
1584 points to. If not null, *LOADBASEP is filled in with the difference
1585 between the VMAs from which the segments were read, and the VMAs the
1586 file headers (and hence BFD's idea of each section's VMA) put them at.
1588 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1589 remote memory at target address VMA into the local buffer at MYADDR; it
1590 should return zero on success or an `errno' code on failure. TEMPL must
1591 be a BFD for a target with the word size and byte order found in the
1595 NAME(_bfd_elf
,bfd_from_remote_memory
)
1599 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1601 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1602 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1603 Elf_External_Phdr
*x_phdrs
;
1604 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1606 struct bfd_in_memory
*bim
;
1612 bfd_boolean loadbase_set
;
1614 /* Read in the ELF header in external format. */
1615 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1618 bfd_set_error (bfd_error_system_call
);
1623 /* Now check to see if we have a valid ELF file, and one that BFD can
1624 make use of. The magic number must match, the address size ('class')
1625 and byte-swapping must match our XVEC entry. */
1627 if (! elf_file_p (&x_ehdr
)
1628 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1629 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1631 bfd_set_error (bfd_error_wrong_format
);
1635 /* Check that file's byte order matches xvec's */
1636 switch (x_ehdr
.e_ident
[EI_DATA
])
1638 case ELFDATA2MSB
: /* Big-endian */
1639 if (! bfd_header_big_endian (templ
))
1641 bfd_set_error (bfd_error_wrong_format
);
1645 case ELFDATA2LSB
: /* Little-endian */
1646 if (! bfd_header_little_endian (templ
))
1648 bfd_set_error (bfd_error_wrong_format
);
1652 case ELFDATANONE
: /* No data encoding specified */
1653 default: /* Unknown data encoding specified */
1654 bfd_set_error (bfd_error_wrong_format
);
1658 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1660 /* The file header tells where to find the program headers.
1661 These are what we use to actually choose what to read. */
1663 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1665 bfd_set_error (bfd_error_wrong_format
);
1669 x_phdrs
= (Elf_External_Phdr
*)
1670 bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1671 if (x_phdrs
== NULL
)
1673 bfd_set_error (bfd_error_no_memory
);
1676 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1677 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1681 bfd_set_error (bfd_error_system_call
);
1685 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1689 loadbase
= ehdr_vma
;
1690 loadbase_set
= FALSE
;
1691 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1693 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1694 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1696 bfd_vma segment_end
;
1697 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1698 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1699 if (segment_end
> (bfd_vma
) contents_size
)
1700 contents_size
= segment_end
;
1702 /* LOADADDR is the `Base address' from the gELF specification:
1703 `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1704 first PT_LOAD as PT_LOADs are ordered by P_VADDR. */
1705 if (!loadbase_set
&& (i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1707 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1708 loadbase_set
= TRUE
;
1711 last_phdr
= &i_phdrs
[i
];
1714 if (last_phdr
== NULL
)
1716 /* There were no PT_LOAD segments, so we don't have anything to read. */
1718 bfd_set_error (bfd_error_wrong_format
);
1722 /* Trim the last segment so we don't bother with zeros in the last page
1723 that are off the end of the file. However, if the extra bit in that
1724 page includes the section headers, keep them. */
1725 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1726 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1727 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1729 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1730 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1731 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1732 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1735 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1737 /* Now we know the size of the whole image we want read in. */
1738 contents
= (bfd_byte
*) bfd_zmalloc (contents_size
);
1739 if (contents
== NULL
)
1742 bfd_set_error (bfd_error_no_memory
);
1746 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1747 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1749 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1750 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1751 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1752 if (end
> (bfd_vma
) contents_size
)
1753 end
= contents_size
;
1754 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1755 & -i_phdrs
[i
].p_align
,
1756 contents
+ start
, end
- start
);
1761 bfd_set_error (bfd_error_system_call
);
1768 /* If the segments visible in memory didn't include the section headers,
1769 then clear them from the file header. */
1770 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1771 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1773 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1774 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1775 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1778 /* This will normally have been in the first PT_LOAD segment. But it
1779 conceivably could be missing, and we might have just changed it. */
1780 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1782 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1783 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1787 bfd_set_error (bfd_error_no_memory
);
1790 nbfd
= _bfd_new_bfd ();
1795 bfd_set_error (bfd_error_no_memory
);
1798 nbfd
->filename
= "<in-memory>";
1799 nbfd
->xvec
= templ
->xvec
;
1800 bim
->size
= contents_size
;
1801 bim
->buffer
= contents
;
1802 nbfd
->iostream
= bim
;
1803 nbfd
->flags
= BFD_IN_MEMORY
;
1804 nbfd
->iovec
= &_bfd_memory_iovec
;
1806 nbfd
->direction
= read_direction
;
1807 nbfd
->mtime
= time (NULL
);
1808 nbfd
->mtime_set
= TRUE
;
1811 *loadbasep
= loadbase
;
1815 /* Function for ELF_R_INFO. */
1818 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
1820 return ELF_R_INFO (sym
, type
);
1823 /* Function for ELF_R_SYM. */
1826 NAME(elf
,r_sym
) (bfd_vma r_info
)
1828 return ELF_R_SYM (r_info
);
1831 #include "elfcore.h"
1833 /* Size-dependent data and functions. */
1834 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1835 sizeof (Elf_External_Ehdr
),
1836 sizeof (Elf_External_Phdr
),
1837 sizeof (Elf_External_Shdr
),
1838 sizeof (Elf_External_Rel
),
1839 sizeof (Elf_External_Rela
),
1840 sizeof (Elf_External_Sym
),
1841 sizeof (Elf_External_Dyn
),
1842 sizeof (Elf_External_Note
),
1845 ARCH_SIZE
, LOG_FILE_ALIGN
,
1846 ELFCLASS
, EV_CURRENT
,
1847 elf_write_out_phdrs
,
1848 elf_write_shdrs_and_ehdr
,
1849 elf_checksum_contents
,
1852 elf_swap_symbol_out
,
1853 elf_slurp_reloc_table
,
1854 elf_slurp_symbol_table
,