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
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_object_p NAME(bfd_elf,object_p)
91 #define elf_core_file_p NAME(bfd_elf,core_file_p)
92 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
93 #define elf_get_dynamic_symtab_upper_bound \
94 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
95 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
96 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
97 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
98 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
99 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
100 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
101 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
102 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
103 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
104 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
105 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
106 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
107 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
108 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
109 #define elf_canonicalize_dynamic_symtab \
110 NAME(bfd_elf,canonicalize_dynamic_symtab)
111 #define elf_get_synthetic_symtab \
112 NAME(bfd_elf,get_synthetic_symtab)
113 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
114 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
115 #define elf_get_lineno NAME(bfd_elf,get_lineno)
116 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
117 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
118 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
119 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
120 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
121 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
122 #define elf_find_section NAME(bfd_elf,find_section)
123 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
124 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
125 #define elf_write_relocs NAME(bfd_elf,write_relocs)
126 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
129 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
130 #define ELF_R_SYM(X) ELF64_R_SYM(X)
131 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
132 #define ELFCLASS ELFCLASS64
134 #define LOG_FILE_ALIGN 3
137 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
138 #define ELF_R_SYM(X) ELF32_R_SYM(X)
139 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
140 #define ELFCLASS ELFCLASS32
142 #define LOG_FILE_ALIGN 2
146 static void elf_debug_section (int, Elf_Internal_Shdr
*);
149 static void elf_debug_file (Elf_Internal_Ehdr
*);
152 /* Structure swapping routines */
154 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
155 can be handled by explicitly specifying 32 bits or "the long type". */
157 #define H_PUT_WORD H_PUT_64
158 #define H_PUT_SIGNED_WORD H_PUT_S64
159 #define H_GET_WORD H_GET_64
160 #define H_GET_SIGNED_WORD H_GET_S64
163 #define H_PUT_WORD H_PUT_32
164 #define H_PUT_SIGNED_WORD H_PUT_S32
165 #define H_GET_WORD H_GET_32
166 #define H_GET_SIGNED_WORD H_GET_S32
169 /* Translate an ELF symbol in external format into an ELF symbol in internal
173 elf_swap_symbol_in (bfd
*abfd
,
176 Elf_Internal_Sym
*dst
)
178 const Elf_External_Sym
*src
= psrc
;
179 const Elf_External_Sym_Shndx
*shndx
= pshn
;
180 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
182 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
184 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
186 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
187 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
188 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
189 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
190 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
191 if (dst
->st_shndx
== SHN_XINDEX
)
195 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
200 /* Translate an ELF symbol in internal format into an ELF symbol in external
204 elf_swap_symbol_out (bfd
*abfd
,
205 const Elf_Internal_Sym
*src
,
210 Elf_External_Sym
*dst
= cdst
;
211 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
212 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
213 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
214 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
215 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
217 if (tmp
> SHN_HIRESERVE
)
221 H_PUT_32 (abfd
, tmp
, shndx
);
224 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
227 /* Translate an ELF file header in external format into an ELF file header in
231 elf_swap_ehdr_in (bfd
*abfd
,
232 const Elf_External_Ehdr
*src
,
233 Elf_Internal_Ehdr
*dst
)
235 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
236 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
237 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
238 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
239 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
241 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
243 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
244 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
245 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
246 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
247 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
248 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
249 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
250 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
251 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
252 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
255 /* Translate an ELF file header in internal format into an ELF file header in
259 elf_swap_ehdr_out (bfd
*abfd
,
260 const Elf_Internal_Ehdr
*src
,
261 Elf_External_Ehdr
*dst
)
264 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
265 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
266 /* note that all elements of dst are *arrays of unsigned char* already... */
267 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
268 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
269 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
271 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
273 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
274 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
275 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
276 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
277 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
278 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
279 H_PUT_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
280 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
282 if (tmp
>= SHN_LORESERVE
)
284 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
285 tmp
= src
->e_shstrndx
;
286 if (tmp
>= SHN_LORESERVE
)
288 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
291 /* Translate an ELF section header table entry in external format into an
292 ELF section header table entry in internal format. */
295 elf_swap_shdr_in (bfd
*abfd
,
296 const Elf_External_Shdr
*src
,
297 Elf_Internal_Shdr
*dst
)
299 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
301 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
302 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
303 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
305 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
307 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
308 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
309 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
310 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
311 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
312 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
313 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
314 dst
->bfd_section
= NULL
;
315 dst
->contents
= NULL
;
318 /* Translate an ELF section header table entry in internal format into an
319 ELF section header table entry in external format. */
322 elf_swap_shdr_out (bfd
*abfd
,
323 const Elf_Internal_Shdr
*src
,
324 Elf_External_Shdr
*dst
)
326 /* note that all elements of dst are *arrays of unsigned char* already... */
327 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
328 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
329 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
330 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
331 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
332 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
333 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
334 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
335 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
336 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
339 /* Translate an ELF program header table entry in external format into an
340 ELF program header table entry in internal format. */
343 elf_swap_phdr_in (bfd
*abfd
,
344 const Elf_External_Phdr
*src
,
345 Elf_Internal_Phdr
*dst
)
347 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
349 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
350 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
351 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
354 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
355 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
359 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
360 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
362 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
363 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
364 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
368 elf_swap_phdr_out (bfd
*abfd
,
369 const Elf_Internal_Phdr
*src
,
370 Elf_External_Phdr
*dst
)
372 /* note that all elements of dst are *arrays of unsigned char* already... */
373 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
374 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
375 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
376 H_PUT_WORD (abfd
, src
->p_paddr
, dst
->p_paddr
);
377 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
378 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
379 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
380 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
383 /* Translate an ELF reloc from external format to internal format. */
385 elf_swap_reloc_in (bfd
*abfd
,
387 Elf_Internal_Rela
*dst
)
389 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
390 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
391 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
396 elf_swap_reloca_in (bfd
*abfd
,
398 Elf_Internal_Rela
*dst
)
400 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
401 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
402 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
403 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
406 /* Translate an ELF reloc from internal format to external format. */
408 elf_swap_reloc_out (bfd
*abfd
,
409 const Elf_Internal_Rela
*src
,
412 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
413 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
414 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
418 elf_swap_reloca_out (bfd
*abfd
,
419 const Elf_Internal_Rela
*src
,
422 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
423 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
424 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
425 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
429 elf_swap_dyn_in (bfd
*abfd
,
431 Elf_Internal_Dyn
*dst
)
433 const Elf_External_Dyn
*src
= p
;
435 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
436 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
440 elf_swap_dyn_out (bfd
*abfd
,
441 const Elf_Internal_Dyn
*src
,
444 Elf_External_Dyn
*dst
= p
;
446 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
447 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
450 /* ELF .o/exec file reading */
452 /* Begin processing a given object.
454 First we validate the file by reading in the ELF header and checking
457 static inline bfd_boolean
458 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
460 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
461 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
462 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
463 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
466 /* Determines if a given section index is valid. */
468 static inline bfd_boolean
469 valid_section_index_p (unsigned index
, unsigned num_sections
)
471 /* Note: We allow SHN_UNDEF as a valid section index. */
472 if (index
< SHN_LORESERVE
|| index
> SHN_HIRESERVE
)
473 return index
< num_sections
;
475 /* We disallow the use of reserved indcies, except for those
476 with OS or Application specific meaning. The test make use
477 of the knowledge that:
478 SHN_LORESERVE == SHN_LOPROC
480 SHN_HIPROC == SHN_LOOS - 1 */
481 /* XXX - Should we allow SHN_XINDEX as a valid index here ? */
482 return (index
>= SHN_LOPROC
&& index
<= SHN_HIOS
);
485 /* Check to see if the file associated with ABFD matches the target vector
488 Note that we may be called several times with the same ABFD, but different
489 target vectors, most of which will not match. We have to avoid leaving
490 any side effects in ABFD, or any data it points to (like tdata), if the
491 file does not match the target vector. */
494 elf_object_p (bfd
*abfd
)
496 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
497 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
498 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
499 Elf_Internal_Shdr i_shdr
;
500 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
501 unsigned int shindex
;
502 const struct elf_backend_data
*ebd
;
503 struct bfd_preserve preserve
;
506 const bfd_target
*target
;
507 const bfd_target
* const *target_ptr
;
509 preserve
.marker
= NULL
;
511 /* Read in the ELF header in external format. */
513 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
515 if (bfd_get_error () != bfd_error_system_call
)
516 goto got_wrong_format_error
;
521 /* Now check to see if we have a valid ELF file, and one that BFD can
522 make use of. The magic number must match, the address size ('class')
523 and byte-swapping must match our XVEC entry, and it must have a
524 section header table (FIXME: See comments re sections at top of this
527 if (! elf_file_p (&x_ehdr
)
528 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
529 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
530 goto got_wrong_format_error
;
532 /* Check that file's byte order matches xvec's */
533 switch (x_ehdr
.e_ident
[EI_DATA
])
535 case ELFDATA2MSB
: /* Big-endian */
536 if (! bfd_header_big_endian (abfd
))
537 goto got_wrong_format_error
;
539 case ELFDATA2LSB
: /* Little-endian */
540 if (! bfd_header_little_endian (abfd
))
541 goto got_wrong_format_error
;
543 case ELFDATANONE
: /* No data encoding specified */
544 default: /* Unknown data encoding specified */
545 goto got_wrong_format_error
;
548 if (!bfd_preserve_save (abfd
, &preserve
))
553 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
554 the tdata pointer in the bfd. */
556 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
558 preserve
.marker
= elf_tdata (abfd
);
560 /* Now that we know the byte order, swap in the rest of the header */
561 i_ehdrp
= elf_elfheader (abfd
);
562 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
564 elf_debug_file (i_ehdrp
);
567 /* Reject ET_CORE (header indicates core file, not object file) */
568 if (i_ehdrp
->e_type
== ET_CORE
)
569 goto got_wrong_format_error
;
571 /* If this is a relocatable file and there is no section header
572 table, then we're hosed. */
573 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
574 goto got_wrong_format_error
;
576 /* As a simple sanity check, verify that what BFD thinks is the
577 size of each section header table entry actually matches the size
578 recorded in the file, but only if there are any sections. */
579 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
580 goto got_wrong_format_error
;
582 /* Further sanity check. */
583 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
584 goto got_wrong_format_error
;
586 ebd
= get_elf_backend_data (abfd
);
588 /* Check that the ELF e_machine field matches what this particular
589 BFD format expects. */
590 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
591 && (ebd
->elf_machine_alt1
== 0
592 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
593 && (ebd
->elf_machine_alt2
== 0
594 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
596 if (ebd
->elf_machine_code
!= EM_NONE
)
597 goto got_wrong_format_error
;
599 /* This is the generic ELF target. Let it match any ELF target
600 for which we do not have a specific backend. */
601 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
603 const struct elf_backend_data
*back
;
605 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
607 back
= (const struct elf_backend_data
*) (*target_ptr
)->backend_data
;
608 if (back
->elf_machine_code
== i_ehdrp
->e_machine
609 || (back
->elf_machine_alt1
!= 0
610 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
611 || (back
->elf_machine_alt2
!= 0
612 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
614 /* target_ptr is an ELF backend which matches this
615 object file, so reject the generic ELF target. */
616 goto got_wrong_format_error
;
621 if (i_ehdrp
->e_type
== ET_EXEC
)
622 abfd
->flags
|= EXEC_P
;
623 else if (i_ehdrp
->e_type
== ET_DYN
)
624 abfd
->flags
|= DYNAMIC
;
626 if (i_ehdrp
->e_phnum
> 0)
627 abfd
->flags
|= D_PAGED
;
629 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
631 /* It's OK if this fails for the generic target. */
632 if (ebd
->elf_machine_code
!= EM_NONE
)
636 if (ebd
->elf_machine_code
!= EM_NONE
637 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
)
639 if (ebd
->elf_osabi
!= ELFOSABI_NONE
)
640 goto got_wrong_format_error
;
642 /* This is an ELFOSABI_NONE ELF target. Let it match any ELF
643 target of the compatible machine for which we do not have a
644 backend with matching ELFOSABI. */
645 for (target_ptr
= bfd_target_vector
;
649 const struct elf_backend_data
*back
;
651 /* Skip this target and targets with incompatible byte
653 if (*target_ptr
== target
654 || (*target_ptr
)->flavour
!= bfd_target_elf_flavour
655 || (*target_ptr
)->byteorder
!= target
->byteorder
656 || ((*target_ptr
)->header_byteorder
657 != target
->header_byteorder
))
660 back
= (const struct elf_backend_data
*) (*target_ptr
)->backend_data
;
661 if (back
->elf_osabi
== i_ehdrp
->e_ident
[EI_OSABI
]
662 && (back
->elf_machine_code
== i_ehdrp
->e_machine
663 || (back
->elf_machine_alt1
!= 0
664 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
665 || (back
->elf_machine_alt2
!= 0
666 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
)))
668 /* target_ptr is an ELF backend which matches this
669 object file, so reject the ELFOSABI_NONE ELF target. */
670 goto got_wrong_format_error
;
675 if (i_ehdrp
->e_shoff
!= 0)
677 bfd_signed_vma where
= i_ehdrp
->e_shoff
;
679 if (where
!= (file_ptr
) where
)
680 goto got_wrong_format_error
;
682 /* Seek to the section header table in the file. */
683 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
686 /* Read the first section header at index 0, and convert to internal
688 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
690 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
692 /* If the section count is zero, the actual count is in the first
694 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
696 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
697 if (i_ehdrp
->e_shnum
!= i_shdr
.sh_size
698 || i_ehdrp
->e_shnum
== 0)
699 goto got_wrong_format_error
;
702 /* And similarly for the string table index. */
703 if (i_ehdrp
->e_shstrndx
== SHN_XINDEX
)
705 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
706 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
707 goto got_wrong_format_error
;
710 /* Sanity check that we can read all of the section headers.
711 It ought to be good enough to just read the last one. */
712 if (i_ehdrp
->e_shnum
!= 1)
714 /* Check that we don't have a totally silly number of sections. */
715 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
716 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
717 goto got_wrong_format_error
;
719 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
720 if (where
!= (file_ptr
) where
)
721 goto got_wrong_format_error
;
722 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
723 goto got_wrong_format_error
;
725 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
727 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
730 /* Back to where we were. */
731 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
732 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
737 /* Allocate space for a copy of the section header table in
739 if (i_ehdrp
->e_shnum
!= 0)
741 Elf_Internal_Shdr
*shdrp
;
742 unsigned int num_sec
;
744 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
745 i_shdrp
= bfd_alloc (abfd
, amt
);
748 num_sec
= i_ehdrp
->e_shnum
;
749 if (num_sec
> SHN_LORESERVE
)
750 num_sec
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
751 elf_numsections (abfd
) = num_sec
;
752 amt
= sizeof (i_shdrp
) * num_sec
;
753 elf_elfsections (abfd
) = bfd_alloc (abfd
, amt
);
754 if (!elf_elfsections (abfd
))
757 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
760 if (num_sec
> SHN_LORESERVE
)
762 for ( ; shindex
< SHN_LORESERVE
; shindex
++)
763 elf_elfsections (abfd
)[shindex
] = shdrp
++;
764 for ( ; shindex
< SHN_HIRESERVE
+ 1; shindex
++)
765 elf_elfsections (abfd
)[shindex
] = i_shdrp
;
767 for ( ; shindex
< num_sec
; shindex
++)
768 elf_elfsections (abfd
)[shindex
] = shdrp
++;
770 /* Read in the rest of the section header table and convert it
772 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
774 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
776 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
778 /* Sanity check sh_link and sh_info. */
779 if (! valid_section_index_p (i_shdrp
[shindex
].sh_link
, num_sec
))
780 goto got_wrong_format_error
;
782 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
783 || i_shdrp
[shindex
].sh_type
== SHT_RELA
784 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
785 && ! valid_section_index_p (i_shdrp
[shindex
].sh_info
, num_sec
))
786 goto got_wrong_format_error
;
788 /* If the section is loaded, but not page aligned, clear
790 if (i_shdrp
[shindex
].sh_size
!= 0
791 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
792 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
793 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
796 abfd
->flags
&= ~D_PAGED
;
800 /* A further sanity check. */
801 if (i_ehdrp
->e_shnum
!= 0)
803 if (! valid_section_index_p (i_ehdrp
->e_shstrndx
, elf_numsections (abfd
)))
806 We used to just goto got_wrong_format_error here
807 but there are binaries in existance for which this test
808 will prevent the binutils from working with them at all.
809 So we are kind, and reset the string index value to 0
810 so that at least some processing can be done. */
811 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
812 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd
->filename
);
815 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
816 goto got_wrong_format_error
;
818 /* Read in the program headers. */
819 if (i_ehdrp
->e_phnum
== 0)
820 elf_tdata (abfd
)->phdr
= NULL
;
823 Elf_Internal_Phdr
*i_phdr
;
826 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
827 elf_tdata (abfd
)->phdr
= bfd_alloc (abfd
, amt
);
828 if (elf_tdata (abfd
)->phdr
== NULL
)
830 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
832 i_phdr
= elf_tdata (abfd
)->phdr
;
833 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
835 Elf_External_Phdr x_phdr
;
837 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
839 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
843 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
845 unsigned int num_sec
;
847 /* Once all of the section headers have been read and converted, we
848 can start processing them. Note that the first section header is
849 a dummy placeholder entry, so we ignore it. */
850 num_sec
= elf_numsections (abfd
);
851 for (shindex
= 1; shindex
< num_sec
; shindex
++)
853 if (! bfd_section_from_shdr (abfd
, shindex
))
855 if (shindex
== SHN_LORESERVE
- 1)
856 shindex
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
859 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
860 if (! _bfd_elf_setup_sections (abfd
))
861 goto got_wrong_format_error
;
864 /* Let the backend double check the format and override global
866 if (ebd
->elf_backend_object_p
)
868 if (! (*ebd
->elf_backend_object_p
) (abfd
))
869 goto got_wrong_format_error
;
872 /* Remember the entry point specified in the ELF file header. */
873 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
875 /* If we have created any reloc sections that are associated with
876 debugging sections, mark the reloc sections as debugging as well. */
877 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
879 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
880 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
881 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
883 unsigned long targ_index
;
886 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
887 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
889 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
890 s
->flags
|= SEC_DEBUGGING
;
894 bfd_preserve_finish (abfd
, &preserve
);
897 got_wrong_format_error
:
898 /* There is way too much undoing of half-known state here. The caller,
899 bfd_check_format_matches, really shouldn't iterate on live bfd's to
900 check match/no-match like it does. We have to rely on that a call to
901 bfd_default_set_arch_mach with the previously known mach, undoes what
902 was done by the first bfd_default_set_arch_mach (with mach 0) here.
903 For this to work, only elf-data and the mach may be changed by the
904 target-specific elf_backend_object_p function. Note that saving the
905 whole bfd here and restoring it would be even worse; the first thing
906 you notice is that the cached bfd file position gets out of sync. */
907 bfd_set_error (bfd_error_wrong_format
);
910 if (preserve
.marker
!= NULL
)
911 bfd_preserve_restore (abfd
, &preserve
);
915 /* ELF .o/exec file writing */
917 /* Write out the relocs. */
920 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
922 bfd_boolean
*failedp
= data
;
923 Elf_Internal_Shdr
*rela_hdr
;
925 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
932 /* If we have already failed, don't do anything. */
936 if ((sec
->flags
& SEC_RELOC
) == 0)
939 /* The linker backend writes the relocs out itself, and sets the
940 reloc_count field to zero to inhibit writing them here. Also,
941 sometimes the SEC_RELOC flag gets set even when there aren't any
943 if (sec
->reloc_count
== 0)
946 /* If we have opened an existing file for update, reloc_count may be
947 set even though we are not linking. In that case we have nothing
949 if (sec
->orelocation
== NULL
)
952 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
954 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
955 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
956 if (rela_hdr
->contents
== NULL
)
962 /* Figure out whether the relocations are RELA or REL relocations. */
963 if (rela_hdr
->sh_type
== SHT_RELA
)
965 swap_out
= elf_swap_reloca_out
;
966 extsize
= sizeof (Elf_External_Rela
);
968 else if (rela_hdr
->sh_type
== SHT_REL
)
970 swap_out
= elf_swap_reloc_out
;
971 extsize
= sizeof (Elf_External_Rel
);
974 /* Every relocation section should be either an SHT_RELA or an
978 /* The address of an ELF reloc is section relative for an object
979 file, and absolute for an executable file or shared library.
980 The address of a BFD reloc is always section relative. */
982 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
983 addr_offset
= sec
->vma
;
985 /* orelocation has the data, reloc_count has the count... */
988 dst_rela
= rela_hdr
->contents
;
990 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
992 Elf_Internal_Rela src_rela
;
997 ptr
= sec
->orelocation
[idx
];
998 sym
= *ptr
->sym_ptr_ptr
;
1001 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
1006 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
1015 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
1016 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
1017 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
1023 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
1024 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1025 src_rela
.r_addend
= ptr
->addend
;
1026 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
1030 /* Write out the program headers. */
1033 elf_write_out_phdrs (bfd
*abfd
,
1034 const Elf_Internal_Phdr
*phdr
,
1039 Elf_External_Phdr extphdr
;
1040 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1041 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
1042 != sizeof (Elf_External_Phdr
))
1049 /* Write out the section headers and the ELF file header. */
1052 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1054 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1055 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1056 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1057 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1061 i_ehdrp
= elf_elfheader (abfd
);
1062 i_shdrp
= elf_elfsections (abfd
);
1064 /* swap the header before spitting it out... */
1067 elf_debug_file (i_ehdrp
);
1069 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1070 amt
= sizeof (x_ehdr
);
1071 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1072 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1075 /* Some fields in the first section header handle overflow of ehdr
1077 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
)
1078 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1079 if (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
)
1080 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1082 /* at this point we've concocted all the ELF sections... */
1083 amt
= i_ehdrp
->e_shnum
;
1084 amt
*= sizeof (*x_shdrp
);
1085 x_shdrp
= bfd_alloc (abfd
, amt
);
1089 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1092 elf_debug_section (count
, *i_shdrp
);
1094 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1096 if (count
== SHN_LORESERVE
- 1)
1097 i_shdrp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
1099 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1100 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1103 /* need to dump the string table too... */
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
= 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
= 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_LORESERVE
1220 || isym
->st_shndx
> SHN_HIRESERVE
)
1222 sym
->symbol
.section
= bfd_section_from_elf_index (abfd
,
1224 if (sym
->symbol
.section
== NULL
)
1226 /* This symbol is in a section for which we did not
1227 create a BFD section. Just use bfd_abs_section,
1228 although it is wrong. FIXME. */
1229 sym
->symbol
.section
= bfd_abs_section_ptr
;
1232 else if (isym
->st_shndx
== SHN_ABS
)
1234 sym
->symbol
.section
= bfd_abs_section_ptr
;
1236 else if (isym
->st_shndx
== SHN_COMMON
)
1238 sym
->symbol
.section
= bfd_com_section_ptr
;
1239 /* Elf puts the alignment into the `value' field, and
1240 the size into the `size' field. BFD wants to see the
1241 size in the value field, and doesn't care (at the
1242 moment) about the alignment. */
1243 sym
->symbol
.value
= isym
->st_size
;
1246 sym
->symbol
.section
= bfd_abs_section_ptr
;
1248 /* If this is a relocatable file, then the symbol value is
1249 already section relative. */
1250 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1251 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1253 switch (ELF_ST_BIND (isym
->st_info
))
1256 sym
->symbol
.flags
|= BSF_LOCAL
;
1259 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1260 sym
->symbol
.flags
|= BSF_GLOBAL
;
1263 sym
->symbol
.flags
|= BSF_WEAK
;
1267 switch (ELF_ST_TYPE (isym
->st_info
))
1270 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1273 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1276 sym
->symbol
.flags
|= BSF_FUNCTION
;
1279 sym
->symbol
.flags
|= BSF_OBJECT
;
1282 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1285 sym
->symbol
.flags
|= BSF_RELC
;
1288 sym
->symbol
.flags
|= BSF_SRELC
;
1293 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1297 Elf_Internal_Versym iversym
;
1299 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1300 sym
->version
= iversym
.vs_vers
;
1304 /* Do some backend-specific processing on this symbol. */
1305 if (ebd
->elf_backend_symbol_processing
)
1306 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1310 /* Do some backend-specific processing on this symbol table. */
1311 if (ebd
->elf_backend_symbol_table_processing
)
1312 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1314 /* We rely on the zalloc to clear out the final symbol entry. */
1316 symcount
= sym
- symbase
;
1318 /* Fill in the user's symbol pointer vector if needed. */
1326 *symptrs
++ = &sym
->symbol
;
1329 *symptrs
= 0; /* Final null pointer */
1332 if (xverbuf
!= NULL
)
1334 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1339 if (xverbuf
!= NULL
)
1341 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1346 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1350 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1352 Elf_Internal_Shdr
*rel_hdr
,
1353 bfd_size_type reloc_count
,
1356 bfd_boolean dynamic
)
1358 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1359 void *allocated
= NULL
;
1360 bfd_byte
*native_relocs
;
1364 unsigned int symcount
;
1366 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1367 if (allocated
== NULL
)
1370 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1371 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1372 != rel_hdr
->sh_size
))
1375 native_relocs
= allocated
;
1377 entsize
= rel_hdr
->sh_entsize
;
1378 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1379 || entsize
== sizeof (Elf_External_Rela
));
1382 symcount
= bfd_get_dynamic_symcount (abfd
);
1384 symcount
= bfd_get_symcount (abfd
);
1386 for (i
= 0, relent
= relents
;
1388 i
++, relent
++, native_relocs
+= entsize
)
1390 Elf_Internal_Rela rela
;
1392 if (entsize
== sizeof (Elf_External_Rela
))
1393 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1395 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1397 /* The address of an ELF reloc is section relative for an object
1398 file, and absolute for an executable file or shared library.
1399 The address of a normal BFD reloc is always section relative,
1400 and the address of a dynamic reloc is absolute.. */
1401 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1402 relent
->address
= rela
.r_offset
;
1404 relent
->address
= rela
.r_offset
- asect
->vma
;
1406 if (ELF_R_SYM (rela
.r_info
) == 0)
1407 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1408 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1410 (*_bfd_error_handler
)
1411 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1412 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1413 relent
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
1419 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1421 relent
->sym_ptr_ptr
= ps
;
1424 relent
->addend
= rela
.r_addend
;
1426 if ((entsize
== sizeof (Elf_External_Rela
)
1427 && ebd
->elf_info_to_howto
!= NULL
)
1428 || ebd
->elf_info_to_howto_rel
== NULL
)
1429 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1431 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1434 if (allocated
!= NULL
)
1440 if (allocated
!= NULL
)
1445 /* Read in and swap the external relocs. */
1448 elf_slurp_reloc_table (bfd
*abfd
,
1451 bfd_boolean dynamic
)
1453 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1454 Elf_Internal_Shdr
*rel_hdr
;
1455 Elf_Internal_Shdr
*rel_hdr2
;
1456 bfd_size_type reloc_count
;
1457 bfd_size_type reloc_count2
;
1461 if (asect
->relocation
!= NULL
)
1466 if ((asect
->flags
& SEC_RELOC
) == 0
1467 || asect
->reloc_count
== 0)
1470 rel_hdr
= &d
->rel_hdr
;
1471 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1472 rel_hdr2
= d
->rel_hdr2
;
1473 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1475 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1476 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1477 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1482 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1483 case because relocations against this section may use the
1484 dynamic symbol table, and in that case bfd_section_from_shdr
1485 in elf.c does not update the RELOC_COUNT. */
1486 if (asect
->size
== 0)
1489 rel_hdr
= &d
->this_hdr
;
1490 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1495 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1496 relents
= bfd_alloc (abfd
, amt
);
1497 if (relents
== NULL
)
1500 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1501 rel_hdr
, reloc_count
,
1507 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1508 rel_hdr2
, reloc_count2
,
1509 relents
+ reloc_count
,
1513 asect
->relocation
= relents
;
1519 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1521 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1522 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1525 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1526 (long) hdr
->sh_name
,
1527 (long) hdr
->sh_type
,
1528 (long) hdr
->sh_flags
);
1530 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1531 (long) hdr
->sh_addr
,
1532 (long) hdr
->sh_offset
,
1533 (long) hdr
->sh_size
);
1535 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1536 (long) hdr
->sh_link
,
1537 (long) hdr
->sh_info
,
1538 (long) hdr
->sh_addralign
);
1539 fprintf (stderr
, "sh_entsize = %ld\n",
1540 (long) hdr
->sh_entsize
);
1547 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1549 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1550 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1551 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1552 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1553 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1554 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1555 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1559 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1560 reconstruct an ELF file by reading the segments out of remote memory
1561 based on the ELF file header at EHDR_VMA and the ELF program headers it
1562 points to. If not null, *LOADBASEP is filled in with the difference
1563 between the VMAs from which the segments were read, and the VMAs the
1564 file headers (and hence BFD's idea of each section's VMA) put them at.
1566 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1567 remote memory at target address VMA into the local buffer at MYADDR; it
1568 should return zero on success or an `errno' code on failure. TEMPL must
1569 be a BFD for a target with the word size and byte order found in the
1573 NAME(_bfd_elf
,bfd_from_remote_memory
)
1577 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
1579 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1580 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1581 Elf_External_Phdr
*x_phdrs
;
1582 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1584 struct bfd_in_memory
*bim
;
1591 /* Read in the ELF header in external format. */
1592 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1595 bfd_set_error (bfd_error_system_call
);
1600 /* Now check to see if we have a valid ELF file, and one that BFD can
1601 make use of. The magic number must match, the address size ('class')
1602 and byte-swapping must match our XVEC entry. */
1604 if (! elf_file_p (&x_ehdr
)
1605 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1606 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1608 bfd_set_error (bfd_error_wrong_format
);
1612 /* Check that file's byte order matches xvec's */
1613 switch (x_ehdr
.e_ident
[EI_DATA
])
1615 case ELFDATA2MSB
: /* Big-endian */
1616 if (! bfd_header_big_endian (templ
))
1618 bfd_set_error (bfd_error_wrong_format
);
1622 case ELFDATA2LSB
: /* Little-endian */
1623 if (! bfd_header_little_endian (templ
))
1625 bfd_set_error (bfd_error_wrong_format
);
1629 case ELFDATANONE
: /* No data encoding specified */
1630 default: /* Unknown data encoding specified */
1631 bfd_set_error (bfd_error_wrong_format
);
1635 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1637 /* The file header tells where to find the program headers.
1638 These are what we use to actually choose what to read. */
1640 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1642 bfd_set_error (bfd_error_wrong_format
);
1646 x_phdrs
= bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1647 if (x_phdrs
== NULL
)
1649 bfd_set_error (bfd_error_no_memory
);
1652 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1653 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1657 bfd_set_error (bfd_error_system_call
);
1661 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1665 loadbase
= ehdr_vma
;
1666 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1668 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1669 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1670 is executable only, and one is read only. We must not use the
1672 if (i_phdrs
[i
].p_type
== PT_LOAD
&& (i_phdrs
[i
].p_flags
& PF_R
))
1674 bfd_vma segment_end
;
1675 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1676 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1677 if (segment_end
> (bfd_vma
) contents_size
)
1678 contents_size
= segment_end
;
1680 if ((i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1681 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1683 last_phdr
= &i_phdrs
[i
];
1686 if (last_phdr
== NULL
)
1688 /* There were no PT_LOAD segments, so we don't have anything to read. */
1690 bfd_set_error (bfd_error_wrong_format
);
1694 /* Trim the last segment so we don't bother with zeros in the last page
1695 that are off the end of the file. However, if the extra bit in that
1696 page includes the section headers, keep them. */
1697 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1698 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1699 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1701 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1702 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1703 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1704 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1707 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1709 /* Now we know the size of the whole image we want read in. */
1710 contents
= bfd_zmalloc (contents_size
);
1711 if (contents
== NULL
)
1714 bfd_set_error (bfd_error_no_memory
);
1718 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1719 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1720 is executable only, and one is read only. We must not use the
1722 if (i_phdrs
[i
].p_type
== PT_LOAD
&& (i_phdrs
[i
].p_flags
& PF_R
))
1724 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1725 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1726 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1727 if (end
> (bfd_vma
) contents_size
)
1728 end
= contents_size
;
1729 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1730 & -i_phdrs
[i
].p_align
,
1731 contents
+ start
, end
- start
);
1736 bfd_set_error (bfd_error_system_call
);
1743 /* If the segments visible in memory didn't include the section headers,
1744 then clear them from the file header. */
1745 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1746 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1748 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1749 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1750 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1753 /* This will normally have been in the first PT_LOAD segment. But it
1754 conceivably could be missing, and we might have just changed it. */
1755 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1757 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1758 bim
= bfd_malloc (sizeof (struct bfd_in_memory
));
1762 bfd_set_error (bfd_error_no_memory
);
1765 nbfd
= _bfd_new_bfd ();
1770 bfd_set_error (bfd_error_no_memory
);
1773 nbfd
->filename
= "<in-memory>";
1774 nbfd
->xvec
= templ
->xvec
;
1775 bim
->size
= contents_size
;
1776 bim
->buffer
= contents
;
1777 nbfd
->iostream
= bim
;
1778 nbfd
->flags
= BFD_IN_MEMORY
;
1779 nbfd
->direction
= read_direction
;
1780 nbfd
->mtime
= time (NULL
);
1781 nbfd
->mtime_set
= TRUE
;
1784 *loadbasep
= loadbase
;
1788 #include "elfcore.h"
1790 /* Size-dependent data and functions. */
1791 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1792 sizeof (Elf_External_Ehdr
),
1793 sizeof (Elf_External_Phdr
),
1794 sizeof (Elf_External_Shdr
),
1795 sizeof (Elf_External_Rel
),
1796 sizeof (Elf_External_Rela
),
1797 sizeof (Elf_External_Sym
),
1798 sizeof (Elf_External_Dyn
),
1799 sizeof (Elf_External_Note
),
1802 ARCH_SIZE
, LOG_FILE_ALIGN
,
1803 ELFCLASS
, EV_CURRENT
,
1804 elf_write_out_phdrs
,
1805 elf_write_shdrs_and_ehdr
,
1808 elf_swap_symbol_out
,
1809 elf_slurp_reloc_table
,
1810 elf_slurp_symbol_table
,