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 2 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, MA 02110-1301, USA. */
34 /* Problems and other issues to resolve.
36 (1) BFD expects there to be some fixed number of "sections" in
37 the object file. I.E. there is a "section_count" variable in the
38 bfd structure which contains the number of sections. However, ELF
39 supports multiple "views" of a file. In particular, with current
40 implementations, executable files typically have two tables, a
41 program header table and a section header table, both of which
42 partition the executable.
44 In ELF-speak, the "linking view" of the file uses the section header
45 table to access "sections" within the file, and the "execution view"
46 uses the program header table to access "segments" within the file.
47 "Segments" typically may contain all the data from one or more
50 Note that the section header table is optional in ELF executables,
51 but it is this information that is most useful to gdb. If the
52 section header table is missing, then gdb should probably try
53 to make do with the program header table. (FIXME)
55 (2) The code in this file is compiled twice, once in 32-bit mode and
56 once in 64-bit mode. More of it should be made size-independent
59 (3) ELF section symbols are handled rather sloppily now. This should
60 be cleaned up, and ELF section symbols reconciled with BFD section
63 (4) We need a published spec for 64-bit ELF. We've got some stuff here
64 that we're using for SPARC V9 64-bit chips, but don't assume that
70 #include "libiberty.h"
75 /* Renaming structures, typedefs, macros and functions to be size-specific. */
76 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
77 #define Elf_External_Sym NAME(Elf,External_Sym)
78 #define Elf_External_Shdr NAME(Elf,External_Shdr)
79 #define Elf_External_Phdr NAME(Elf,External_Phdr)
80 #define Elf_External_Rel NAME(Elf,External_Rel)
81 #define Elf_External_Rela NAME(Elf,External_Rela)
82 #define Elf_External_Dyn NAME(Elf,External_Dyn)
84 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
85 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
86 #define elf_core_file_matches_executable_p \
87 NAME(bfd_elf,core_file_matches_executable_p)
88 #define elf_object_p NAME(bfd_elf,object_p)
89 #define elf_core_file_p NAME(bfd_elf,core_file_p)
90 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
91 #define elf_get_dynamic_symtab_upper_bound \
92 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
93 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
94 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
95 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
96 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
97 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
98 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
99 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
100 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
101 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
102 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
103 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
104 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
105 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
106 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
107 #define elf_canonicalize_dynamic_symtab \
108 NAME(bfd_elf,canonicalize_dynamic_symtab)
109 #define elf_get_synthetic_symtab \
110 NAME(bfd_elf,get_synthetic_symtab)
111 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
112 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
113 #define elf_get_lineno NAME(bfd_elf,get_lineno)
114 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
115 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
116 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
117 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
118 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
119 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
120 #define elf_find_section NAME(bfd_elf,find_section)
121 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
122 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
123 #define elf_write_relocs NAME(bfd_elf,write_relocs)
124 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
127 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
128 #define ELF_R_SYM(X) ELF64_R_SYM(X)
129 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
130 #define ELFCLASS ELFCLASS64
132 #define LOG_FILE_ALIGN 3
135 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
136 #define ELF_R_SYM(X) ELF32_R_SYM(X)
137 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
138 #define ELFCLASS ELFCLASS32
140 #define LOG_FILE_ALIGN 2
144 static void elf_debug_section (int, Elf_Internal_Shdr
*);
147 static void elf_debug_file (Elf_Internal_Ehdr
*);
150 /* Structure swapping routines */
152 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
153 can be handled by explicitly specifying 32 bits or "the long type". */
155 #define H_PUT_WORD H_PUT_64
156 #define H_PUT_SIGNED_WORD H_PUT_S64
157 #define H_GET_WORD H_GET_64
158 #define H_GET_SIGNED_WORD H_GET_S64
161 #define H_PUT_WORD H_PUT_32
162 #define H_PUT_SIGNED_WORD H_PUT_S32
163 #define H_GET_WORD H_GET_32
164 #define H_GET_SIGNED_WORD H_GET_S32
167 /* Translate an ELF symbol in external format into an ELF symbol in internal
171 elf_swap_symbol_in (bfd
*abfd
,
174 Elf_Internal_Sym
*dst
)
176 const Elf_External_Sym
*src
= psrc
;
177 const Elf_External_Sym_Shndx
*shndx
= pshn
;
178 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
180 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
182 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
184 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
185 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
186 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
187 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
188 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
189 if (dst
->st_shndx
== SHN_XINDEX
)
193 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
198 /* Translate an ELF symbol in internal format into an ELF symbol in external
202 elf_swap_symbol_out (bfd
*abfd
,
203 const Elf_Internal_Sym
*src
,
208 Elf_External_Sym
*dst
= cdst
;
209 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
210 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
211 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
212 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
213 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
215 if (tmp
> SHN_HIRESERVE
)
219 H_PUT_32 (abfd
, tmp
, shndx
);
222 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
225 /* Translate an ELF file header in external format into an ELF file header in
229 elf_swap_ehdr_in (bfd
*abfd
,
230 const Elf_External_Ehdr
*src
,
231 Elf_Internal_Ehdr
*dst
)
233 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
234 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
235 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
236 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
237 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
239 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
241 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
242 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
243 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
244 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
245 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
246 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
247 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
248 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
249 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
250 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
253 /* Translate an ELF file header in internal format into an ELF file header in
257 elf_swap_ehdr_out (bfd
*abfd
,
258 const Elf_Internal_Ehdr
*src
,
259 Elf_External_Ehdr
*dst
)
262 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
263 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
264 /* note that all elements of dst are *arrays of unsigned char* already... */
265 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
266 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
267 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
269 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
271 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
272 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
273 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
274 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
275 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
276 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
277 H_PUT_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
278 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
280 if (tmp
>= SHN_LORESERVE
)
282 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
283 tmp
= src
->e_shstrndx
;
284 if (tmp
>= SHN_LORESERVE
)
286 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
289 /* Translate an ELF section header table entry in external format into an
290 ELF section header table entry in internal format. */
293 elf_swap_shdr_in (bfd
*abfd
,
294 const Elf_External_Shdr
*src
,
295 Elf_Internal_Shdr
*dst
)
297 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
299 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
300 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
301 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
303 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
305 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
306 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
307 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
308 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
309 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
310 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
311 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
312 dst
->bfd_section
= NULL
;
313 dst
->contents
= NULL
;
316 /* Translate an ELF section header table entry in internal format into an
317 ELF section header table entry in external format. */
320 elf_swap_shdr_out (bfd
*abfd
,
321 const Elf_Internal_Shdr
*src
,
322 Elf_External_Shdr
*dst
)
324 /* note that all elements of dst are *arrays of unsigned char* already... */
325 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
326 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
327 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
328 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
329 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
330 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
331 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
332 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
333 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
334 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
337 /* Translate an ELF program header table entry in external format into an
338 ELF program header table entry in internal format. */
341 elf_swap_phdr_in (bfd
*abfd
,
342 const Elf_External_Phdr
*src
,
343 Elf_Internal_Phdr
*dst
)
345 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
347 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
348 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
349 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
352 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
353 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
357 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
358 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
360 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
361 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
362 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
366 elf_swap_phdr_out (bfd
*abfd
,
367 const Elf_Internal_Phdr
*src
,
368 Elf_External_Phdr
*dst
)
370 /* note that all elements of dst are *arrays of unsigned char* already... */
371 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
372 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
373 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
374 H_PUT_WORD (abfd
, src
->p_paddr
, dst
->p_paddr
);
375 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
376 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
377 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
378 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
381 /* Translate an ELF reloc from external format to internal format. */
383 elf_swap_reloc_in (bfd
*abfd
,
385 Elf_Internal_Rela
*dst
)
387 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
388 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
389 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
394 elf_swap_reloca_in (bfd
*abfd
,
396 Elf_Internal_Rela
*dst
)
398 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
399 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
400 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
401 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
404 /* Translate an ELF reloc from internal format to external format. */
406 elf_swap_reloc_out (bfd
*abfd
,
407 const Elf_Internal_Rela
*src
,
410 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
411 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
412 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
416 elf_swap_reloca_out (bfd
*abfd
,
417 const Elf_Internal_Rela
*src
,
420 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
421 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
422 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
423 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
427 elf_swap_dyn_in (bfd
*abfd
,
429 Elf_Internal_Dyn
*dst
)
431 const Elf_External_Dyn
*src
= p
;
433 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
434 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
438 elf_swap_dyn_out (bfd
*abfd
,
439 const Elf_Internal_Dyn
*src
,
442 Elf_External_Dyn
*dst
= p
;
444 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
445 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
448 /* ELF .o/exec file reading */
450 /* Begin processing a given object.
452 First we validate the file by reading in the ELF header and checking
455 static inline bfd_boolean
456 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
458 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
459 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
460 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
461 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
464 /* Determines if a given section index is valid. */
466 static inline bfd_boolean
467 valid_section_index_p (unsigned index
, unsigned num_sections
)
469 /* Note: We allow SHN_UNDEF as a valid section index. */
470 if (index
< SHN_LORESERVE
|| index
> SHN_HIRESERVE
)
471 return index
< num_sections
;
473 /* We disallow the use of reserved indcies, except for those
474 with OS or Application specific meaning. The test make use
475 of the knowledge that:
476 SHN_LORESERVE == SHN_LOPROC
478 SHN_HIPROC == SHN_LOOS - 1 */
479 /* XXX - Should we allow SHN_XINDEX as a valid index here ? */
480 return (index
>= SHN_LOPROC
&& index
<= SHN_HIOS
);
483 /* Check to see if the file associated with ABFD matches the target vector
486 Note that we may be called several times with the same ABFD, but different
487 target vectors, most of which will not match. We have to avoid leaving
488 any side effects in ABFD, or any data it points to (like tdata), if the
489 file does not match the target vector. */
492 elf_object_p (bfd
*abfd
)
494 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
495 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
496 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
497 Elf_Internal_Shdr i_shdr
;
498 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
499 unsigned int shindex
;
500 const struct elf_backend_data
*ebd
;
501 struct bfd_preserve preserve
;
504 const bfd_target
*target
;
505 const bfd_target
* const *target_ptr
;
507 preserve
.marker
= NULL
;
509 /* Read in the ELF header in external format. */
511 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
513 if (bfd_get_error () != bfd_error_system_call
)
514 goto got_wrong_format_error
;
519 /* Now check to see if we have a valid ELF file, and one that BFD can
520 make use of. The magic number must match, the address size ('class')
521 and byte-swapping must match our XVEC entry, and it must have a
522 section header table (FIXME: See comments re sections at top of this
525 if (! elf_file_p (&x_ehdr
)
526 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
527 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
528 goto got_wrong_format_error
;
530 /* Check that file's byte order matches xvec's */
531 switch (x_ehdr
.e_ident
[EI_DATA
])
533 case ELFDATA2MSB
: /* Big-endian */
534 if (! bfd_header_big_endian (abfd
))
535 goto got_wrong_format_error
;
537 case ELFDATA2LSB
: /* Little-endian */
538 if (! bfd_header_little_endian (abfd
))
539 goto got_wrong_format_error
;
541 case ELFDATANONE
: /* No data encoding specified */
542 default: /* Unknown data encoding specified */
543 goto got_wrong_format_error
;
546 if (!bfd_preserve_save (abfd
, &preserve
))
551 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
552 the tdata pointer in the bfd. */
554 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
556 preserve
.marker
= elf_tdata (abfd
);
558 /* Now that we know the byte order, swap in the rest of the header */
559 i_ehdrp
= elf_elfheader (abfd
);
560 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
562 elf_debug_file (i_ehdrp
);
565 /* Reject ET_CORE (header indicates core file, not object file) */
566 if (i_ehdrp
->e_type
== ET_CORE
)
567 goto got_wrong_format_error
;
569 /* If this is a relocatable file and there is no section header
570 table, then we're hosed. */
571 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
572 goto got_wrong_format_error
;
574 /* As a simple sanity check, verify that what BFD thinks is the
575 size of each section header table entry actually matches the size
576 recorded in the file, but only if there are any sections. */
577 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
578 goto got_wrong_format_error
;
580 /* Further sanity check. */
581 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
582 goto got_wrong_format_error
;
584 ebd
= get_elf_backend_data (abfd
);
586 /* Check that the ELF e_machine field matches what this particular
587 BFD format expects. */
588 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
589 && (ebd
->elf_machine_alt1
== 0
590 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
591 && (ebd
->elf_machine_alt2
== 0
592 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
594 if (ebd
->elf_machine_code
!= EM_NONE
)
595 goto got_wrong_format_error
;
597 /* This is the generic ELF target. Let it match any ELF target
598 for which we do not have a specific backend. */
599 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
601 const struct elf_backend_data
*back
;
603 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
605 back
= (const struct elf_backend_data
*) (*target_ptr
)->backend_data
;
606 if (back
->elf_machine_code
== i_ehdrp
->e_machine
607 || (back
->elf_machine_alt1
!= 0
608 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
609 || (back
->elf_machine_alt2
!= 0
610 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
612 /* target_ptr is an ELF backend which matches this
613 object file, so reject the generic ELF target. */
614 goto got_wrong_format_error
;
619 if (i_ehdrp
->e_type
== ET_EXEC
)
620 abfd
->flags
|= EXEC_P
;
621 else if (i_ehdrp
->e_type
== ET_DYN
)
622 abfd
->flags
|= DYNAMIC
;
624 if (i_ehdrp
->e_phnum
> 0)
625 abfd
->flags
|= D_PAGED
;
627 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
629 /* It's OK if this fails for the generic target. */
630 if (ebd
->elf_machine_code
!= EM_NONE
)
634 if (ebd
->elf_machine_code
!= EM_NONE
635 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
)
637 if (ebd
->elf_osabi
!= ELFOSABI_NONE
)
638 goto got_wrong_format_error
;
640 /* This is an ELFOSABI_NONE ELF target. Let it match any ELF
641 target of the compatible machine for which we do not have a
642 backend with matching ELFOSABI. */
643 for (target_ptr
= bfd_target_vector
;
647 const struct elf_backend_data
*back
;
649 /* Skip this target and targets with incompatible byte
651 if (*target_ptr
== target
652 || (*target_ptr
)->flavour
!= bfd_target_elf_flavour
653 || (*target_ptr
)->byteorder
!= target
->byteorder
654 || ((*target_ptr
)->header_byteorder
655 != target
->header_byteorder
))
658 back
= (const struct elf_backend_data
*) (*target_ptr
)->backend_data
;
659 if (back
->elf_osabi
== i_ehdrp
->e_ident
[EI_OSABI
]
660 && (back
->elf_machine_code
== i_ehdrp
->e_machine
661 || (back
->elf_machine_alt1
!= 0
662 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
663 || (back
->elf_machine_alt2
!= 0
664 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
)))
666 /* target_ptr is an ELF backend which matches this
667 object file, so reject the ELFOSABI_NONE ELF target. */
668 goto got_wrong_format_error
;
673 if (i_ehdrp
->e_shoff
!= 0)
675 bfd_signed_vma where
= i_ehdrp
->e_shoff
;
677 if (where
!= (file_ptr
) where
)
678 goto got_wrong_format_error
;
680 /* Seek to the section header table in the file. */
681 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
684 /* Read the first section header at index 0, and convert to internal
686 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
688 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
690 /* If the section count is zero, the actual count is in the first
692 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
694 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
695 if (i_ehdrp
->e_shnum
!= i_shdr
.sh_size
696 || i_ehdrp
->e_shnum
== 0)
697 goto got_wrong_format_error
;
700 /* And similarly for the string table index. */
701 if (i_ehdrp
->e_shstrndx
== SHN_XINDEX
)
703 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
704 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
705 goto got_wrong_format_error
;
708 /* Sanity check that we can read all of the section headers.
709 It ought to be good enough to just read the last one. */
710 if (i_ehdrp
->e_shnum
!= 1)
712 /* Check that we don't have a totally silly number of sections. */
713 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
714 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
715 goto got_wrong_format_error
;
717 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
718 if (where
!= (file_ptr
) where
)
719 goto got_wrong_format_error
;
720 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
721 goto got_wrong_format_error
;
723 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
725 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
728 /* Back to where we were. */
729 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
730 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
735 /* Allocate space for a copy of the section header table in
737 if (i_ehdrp
->e_shnum
!= 0)
739 Elf_Internal_Shdr
*shdrp
;
740 unsigned int num_sec
;
742 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
743 i_shdrp
= bfd_alloc (abfd
, amt
);
746 num_sec
= i_ehdrp
->e_shnum
;
747 if (num_sec
> SHN_LORESERVE
)
748 num_sec
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
749 elf_numsections (abfd
) = num_sec
;
750 amt
= sizeof (i_shdrp
) * num_sec
;
751 elf_elfsections (abfd
) = bfd_alloc (abfd
, amt
);
752 if (!elf_elfsections (abfd
))
755 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
758 if (num_sec
> SHN_LORESERVE
)
760 for ( ; shindex
< SHN_LORESERVE
; shindex
++)
761 elf_elfsections (abfd
)[shindex
] = shdrp
++;
762 for ( ; shindex
< SHN_HIRESERVE
+ 1; shindex
++)
763 elf_elfsections (abfd
)[shindex
] = i_shdrp
;
765 for ( ; shindex
< num_sec
; shindex
++)
766 elf_elfsections (abfd
)[shindex
] = shdrp
++;
768 /* Read in the rest of the section header table and convert it
770 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
772 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
774 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
776 /* Sanity check sh_link and sh_info. */
777 if (! valid_section_index_p (i_shdrp
[shindex
].sh_link
, num_sec
))
778 goto got_wrong_format_error
;
780 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
781 || i_shdrp
[shindex
].sh_type
== SHT_RELA
782 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
783 && ! valid_section_index_p (i_shdrp
[shindex
].sh_info
, num_sec
))
784 goto got_wrong_format_error
;
786 /* If the section is loaded, but not page aligned, clear
788 if (i_shdrp
[shindex
].sh_size
!= 0
789 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
790 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
791 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
794 abfd
->flags
&= ~D_PAGED
;
798 /* A further sanity check. */
799 if (i_ehdrp
->e_shnum
!= 0)
801 if (! valid_section_index_p (i_ehdrp
->e_shstrndx
, elf_numsections (abfd
)))
804 We used to just goto got_wrong_format_error here
805 but there are binaries in existance for which this test
806 will prevent the binutils from working with them at all.
807 So we are kind, and reset the string index value to 0
808 so that at least some processing can be done. */
809 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
810 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd
->filename
);
813 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
814 goto got_wrong_format_error
;
816 /* Read in the program headers. */
817 if (i_ehdrp
->e_phnum
== 0)
818 elf_tdata (abfd
)->phdr
= NULL
;
821 Elf_Internal_Phdr
*i_phdr
;
824 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
825 elf_tdata (abfd
)->phdr
= bfd_alloc (abfd
, amt
);
826 if (elf_tdata (abfd
)->phdr
== NULL
)
828 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
830 i_phdr
= elf_tdata (abfd
)->phdr
;
831 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
833 Elf_External_Phdr x_phdr
;
835 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
837 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
841 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
843 unsigned int num_sec
;
845 /* Once all of the section headers have been read and converted, we
846 can start processing them. Note that the first section header is
847 a dummy placeholder entry, so we ignore it. */
848 num_sec
= elf_numsections (abfd
);
849 for (shindex
= 1; shindex
< num_sec
; shindex
++)
851 if (! bfd_section_from_shdr (abfd
, shindex
))
853 if (shindex
== SHN_LORESERVE
- 1)
854 shindex
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
857 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
858 if (! _bfd_elf_setup_sections (abfd
))
859 goto got_wrong_format_error
;
862 /* Let the backend double check the format and override global
864 if (ebd
->elf_backend_object_p
)
866 if (! (*ebd
->elf_backend_object_p
) (abfd
))
867 goto got_wrong_format_error
;
870 /* Remember the entry point specified in the ELF file header. */
871 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
873 /* If we have created any reloc sections that are associated with
874 debugging sections, mark the reloc sections as debugging as well. */
875 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
877 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
878 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
879 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
881 unsigned long targ_index
;
884 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
885 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
887 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
888 s
->flags
|= SEC_DEBUGGING
;
892 bfd_preserve_finish (abfd
, &preserve
);
895 got_wrong_format_error
:
896 /* There is way too much undoing of half-known state here. The caller,
897 bfd_check_format_matches, really shouldn't iterate on live bfd's to
898 check match/no-match like it does. We have to rely on that a call to
899 bfd_default_set_arch_mach with the previously known mach, undoes what
900 was done by the first bfd_default_set_arch_mach (with mach 0) here.
901 For this to work, only elf-data and the mach may be changed by the
902 target-specific elf_backend_object_p function. Note that saving the
903 whole bfd here and restoring it would be even worse; the first thing
904 you notice is that the cached bfd file position gets out of sync. */
905 bfd_set_error (bfd_error_wrong_format
);
908 if (preserve
.marker
!= NULL
)
909 bfd_preserve_restore (abfd
, &preserve
);
913 /* ELF .o/exec file writing */
915 /* Write out the relocs. */
918 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
920 bfd_boolean
*failedp
= data
;
921 Elf_Internal_Shdr
*rela_hdr
;
923 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
930 /* If we have already failed, don't do anything. */
934 if ((sec
->flags
& SEC_RELOC
) == 0)
937 /* The linker backend writes the relocs out itself, and sets the
938 reloc_count field to zero to inhibit writing them here. Also,
939 sometimes the SEC_RELOC flag gets set even when there aren't any
941 if (sec
->reloc_count
== 0)
944 /* If we have opened an existing file for update, reloc_count may be
945 set even though we are not linking. In that case we have nothing
947 if (sec
->orelocation
== NULL
)
950 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
952 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
953 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
954 if (rela_hdr
->contents
== NULL
)
960 /* Figure out whether the relocations are RELA or REL relocations. */
961 if (rela_hdr
->sh_type
== SHT_RELA
)
963 swap_out
= elf_swap_reloca_out
;
964 extsize
= sizeof (Elf_External_Rela
);
966 else if (rela_hdr
->sh_type
== SHT_REL
)
968 swap_out
= elf_swap_reloc_out
;
969 extsize
= sizeof (Elf_External_Rel
);
972 /* Every relocation section should be either an SHT_RELA or an
976 /* The address of an ELF reloc is section relative for an object
977 file, and absolute for an executable file or shared library.
978 The address of a BFD reloc is always section relative. */
980 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
981 addr_offset
= sec
->vma
;
983 /* orelocation has the data, reloc_count has the count... */
986 dst_rela
= rela_hdr
->contents
;
988 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
990 Elf_Internal_Rela src_rela
;
995 ptr
= sec
->orelocation
[idx
];
996 sym
= *ptr
->sym_ptr_ptr
;
999 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
1004 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
1013 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
1014 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
1015 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
1021 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
1022 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1023 src_rela
.r_addend
= ptr
->addend
;
1024 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
1028 /* Write out the program headers. */
1031 elf_write_out_phdrs (bfd
*abfd
,
1032 const Elf_Internal_Phdr
*phdr
,
1037 Elf_External_Phdr extphdr
;
1038 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1039 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
1040 != sizeof (Elf_External_Phdr
))
1047 /* Write out the section headers and the ELF file header. */
1050 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1052 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1053 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1054 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1055 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1059 i_ehdrp
= elf_elfheader (abfd
);
1060 i_shdrp
= elf_elfsections (abfd
);
1062 /* swap the header before spitting it out... */
1065 elf_debug_file (i_ehdrp
);
1067 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1068 amt
= sizeof (x_ehdr
);
1069 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1070 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1073 /* Some fields in the first section header handle overflow of ehdr
1075 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
)
1076 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1077 if (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
)
1078 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1080 /* at this point we've concocted all the ELF sections... */
1081 amt
= i_ehdrp
->e_shnum
;
1082 amt
*= sizeof (*x_shdrp
);
1083 x_shdrp
= bfd_alloc (abfd
, amt
);
1087 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1090 elf_debug_section (count
, *i_shdrp
);
1092 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1094 if (count
== SHN_LORESERVE
- 1)
1095 i_shdrp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
1097 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1098 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1101 /* need to dump the string table too... */
1107 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1109 Elf_Internal_Shdr
*hdr
;
1110 Elf_Internal_Shdr
*verhdr
;
1111 unsigned long symcount
; /* Number of external ELF symbols */
1112 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1113 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1114 Elf_Internal_Sym
*isym
;
1115 Elf_Internal_Sym
*isymend
;
1116 Elf_Internal_Sym
*isymbuf
= NULL
;
1117 Elf_External_Versym
*xver
;
1118 Elf_External_Versym
*xverbuf
= NULL
;
1119 const struct elf_backend_data
*ebd
;
1122 /* Read each raw ELF symbol, converting from external ELF form to
1123 internal ELF form, and then using the information to create a
1124 canonical bfd symbol table entry.
1126 Note that we allocate the initial bfd canonical symbol buffer
1127 based on a one-to-one mapping of the ELF symbols to canonical
1128 symbols. We actually use all the ELF symbols, so there will be no
1129 space left over at the end. When we have all the symbols, we
1130 build the caller's pointer vector. */
1134 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1139 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1140 if (elf_dynversym (abfd
) == 0)
1143 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1144 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1145 && elf_tdata (abfd
)->verdef
== NULL
)
1146 || (elf_tdata (abfd
)->dynverref_section
!= 0
1147 && elf_tdata (abfd
)->verref
== NULL
))
1149 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1154 ebd
= get_elf_backend_data (abfd
);
1155 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1157 sym
= symbase
= NULL
;
1160 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1162 if (isymbuf
== NULL
)
1166 amt
*= sizeof (elf_symbol_type
);
1167 symbase
= bfd_zalloc (abfd
, amt
);
1168 if (symbase
== (elf_symbol_type
*) NULL
)
1171 /* Read the raw ELF version symbol information. */
1173 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1175 (*_bfd_error_handler
)
1176 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1178 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1181 /* Slurp in the symbols without the version information,
1182 since that is more helpful than just quitting. */
1188 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1191 xverbuf
= bfd_malloc (verhdr
->sh_size
);
1192 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1195 if (bfd_bread (xverbuf
, verhdr
->sh_size
, abfd
) != verhdr
->sh_size
)
1199 /* Skip first symbol, which is a null dummy. */
1203 isymend
= isymbuf
+ symcount
;
1204 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1206 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1207 sym
->symbol
.the_bfd
= abfd
;
1209 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1211 sym
->symbol
.value
= isym
->st_value
;
1213 if (isym
->st_shndx
== SHN_UNDEF
)
1215 sym
->symbol
.section
= bfd_und_section_ptr
;
1217 else if (isym
->st_shndx
< SHN_LORESERVE
1218 || isym
->st_shndx
> SHN_HIRESERVE
)
1220 sym
->symbol
.section
= bfd_section_from_elf_index (abfd
,
1222 if (sym
->symbol
.section
== NULL
)
1224 /* This symbol is in a section for which we did not
1225 create a BFD section. Just use bfd_abs_section,
1226 although it is wrong. FIXME. */
1227 sym
->symbol
.section
= bfd_abs_section_ptr
;
1230 else if (isym
->st_shndx
== SHN_ABS
)
1232 sym
->symbol
.section
= bfd_abs_section_ptr
;
1234 else if (isym
->st_shndx
== SHN_COMMON
)
1236 sym
->symbol
.section
= bfd_com_section_ptr
;
1237 /* Elf puts the alignment into the `value' field, and
1238 the size into the `size' field. BFD wants to see the
1239 size in the value field, and doesn't care (at the
1240 moment) about the alignment. */
1241 sym
->symbol
.value
= isym
->st_size
;
1244 sym
->symbol
.section
= bfd_abs_section_ptr
;
1246 /* If this is a relocatable file, then the symbol value is
1247 already section relative. */
1248 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1249 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1251 switch (ELF_ST_BIND (isym
->st_info
))
1254 sym
->symbol
.flags
|= BSF_LOCAL
;
1257 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1258 sym
->symbol
.flags
|= BSF_GLOBAL
;
1261 sym
->symbol
.flags
|= BSF_WEAK
;
1265 switch (ELF_ST_TYPE (isym
->st_info
))
1268 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1271 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1274 sym
->symbol
.flags
|= BSF_FUNCTION
;
1277 sym
->symbol
.flags
|= BSF_OBJECT
;
1280 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1283 sym
->symbol
.flags
|= BSF_RELC
;
1286 sym
->symbol
.flags
|= BSF_SRELC
;
1291 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1295 Elf_Internal_Versym iversym
;
1297 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1298 sym
->version
= iversym
.vs_vers
;
1302 /* Do some backend-specific processing on this symbol. */
1303 if (ebd
->elf_backend_symbol_processing
)
1304 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1308 /* Do some backend-specific processing on this symbol table. */
1309 if (ebd
->elf_backend_symbol_table_processing
)
1310 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1312 /* We rely on the zalloc to clear out the final symbol entry. */
1314 symcount
= sym
- symbase
;
1316 /* Fill in the user's symbol pointer vector if needed. */
1324 *symptrs
++ = &sym
->symbol
;
1327 *symptrs
= 0; /* Final null pointer */
1330 if (xverbuf
!= NULL
)
1332 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1337 if (xverbuf
!= NULL
)
1339 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1344 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1348 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1350 Elf_Internal_Shdr
*rel_hdr
,
1351 bfd_size_type reloc_count
,
1354 bfd_boolean dynamic
)
1356 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1357 void *allocated
= NULL
;
1358 bfd_byte
*native_relocs
;
1362 unsigned int symcount
;
1364 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1365 if (allocated
== NULL
)
1368 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1369 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1370 != rel_hdr
->sh_size
))
1373 native_relocs
= allocated
;
1375 entsize
= rel_hdr
->sh_entsize
;
1376 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1377 || entsize
== sizeof (Elf_External_Rela
));
1380 symcount
= bfd_get_dynamic_symcount (abfd
);
1382 symcount
= bfd_get_symcount (abfd
);
1384 for (i
= 0, relent
= relents
;
1386 i
++, relent
++, native_relocs
+= entsize
)
1388 Elf_Internal_Rela rela
;
1390 if (entsize
== sizeof (Elf_External_Rela
))
1391 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1393 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1395 /* The address of an ELF reloc is section relative for an object
1396 file, and absolute for an executable file or shared library.
1397 The address of a normal BFD reloc is always section relative,
1398 and the address of a dynamic reloc is absolute.. */
1399 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1400 relent
->address
= rela
.r_offset
;
1402 relent
->address
= rela
.r_offset
- asect
->vma
;
1404 if (ELF_R_SYM (rela
.r_info
) == 0)
1405 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1406 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1408 (*_bfd_error_handler
)
1409 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1410 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1411 relent
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
1417 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1419 relent
->sym_ptr_ptr
= ps
;
1422 relent
->addend
= rela
.r_addend
;
1424 if ((entsize
== sizeof (Elf_External_Rela
)
1425 && ebd
->elf_info_to_howto
!= NULL
)
1426 || ebd
->elf_info_to_howto_rel
== NULL
)
1427 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1429 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1432 if (allocated
!= NULL
)
1438 if (allocated
!= NULL
)
1443 /* Read in and swap the external relocs. */
1446 elf_slurp_reloc_table (bfd
*abfd
,
1449 bfd_boolean dynamic
)
1451 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1452 Elf_Internal_Shdr
*rel_hdr
;
1453 Elf_Internal_Shdr
*rel_hdr2
;
1454 bfd_size_type reloc_count
;
1455 bfd_size_type reloc_count2
;
1459 if (asect
->relocation
!= NULL
)
1464 if ((asect
->flags
& SEC_RELOC
) == 0
1465 || asect
->reloc_count
== 0)
1468 rel_hdr
= &d
->rel_hdr
;
1469 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1470 rel_hdr2
= d
->rel_hdr2
;
1471 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1473 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1474 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1475 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1480 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1481 case because relocations against this section may use the
1482 dynamic symbol table, and in that case bfd_section_from_shdr
1483 in elf.c does not update the RELOC_COUNT. */
1484 if (asect
->size
== 0)
1487 rel_hdr
= &d
->this_hdr
;
1488 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1493 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1494 relents
= bfd_alloc (abfd
, amt
);
1495 if (relents
== NULL
)
1498 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1499 rel_hdr
, reloc_count
,
1505 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1506 rel_hdr2
, reloc_count2
,
1507 relents
+ reloc_count
,
1511 asect
->relocation
= relents
;
1517 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1519 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1520 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1523 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1524 (long) hdr
->sh_name
,
1525 (long) hdr
->sh_type
,
1526 (long) hdr
->sh_flags
);
1528 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1529 (long) hdr
->sh_addr
,
1530 (long) hdr
->sh_offset
,
1531 (long) hdr
->sh_size
);
1533 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1534 (long) hdr
->sh_link
,
1535 (long) hdr
->sh_info
,
1536 (long) hdr
->sh_addralign
);
1537 fprintf (stderr
, "sh_entsize = %ld\n",
1538 (long) hdr
->sh_entsize
);
1545 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1547 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1548 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1549 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1550 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1551 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1552 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1553 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1557 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1558 reconstruct an ELF file by reading the segments out of remote memory
1559 based on the ELF file header at EHDR_VMA and the ELF program headers it
1560 points to. If not null, *LOADBASEP is filled in with the difference
1561 between the VMAs from which the segments were read, and the VMAs the
1562 file headers (and hence BFD's idea of each section's VMA) put them at.
1564 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1565 remote memory at target address VMA into the local buffer at MYADDR; it
1566 should return zero on success or an `errno' code on failure. TEMPL must
1567 be a BFD for a target with the word size and byte order found in the
1571 NAME(_bfd_elf
,bfd_from_remote_memory
)
1575 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
1577 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1578 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1579 Elf_External_Phdr
*x_phdrs
;
1580 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1582 struct bfd_in_memory
*bim
;
1589 /* Read in the ELF header in external format. */
1590 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1593 bfd_set_error (bfd_error_system_call
);
1598 /* Now check to see if we have a valid ELF file, and one that BFD can
1599 make use of. The magic number must match, the address size ('class')
1600 and byte-swapping must match our XVEC entry. */
1602 if (! elf_file_p (&x_ehdr
)
1603 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1604 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1606 bfd_set_error (bfd_error_wrong_format
);
1610 /* Check that file's byte order matches xvec's */
1611 switch (x_ehdr
.e_ident
[EI_DATA
])
1613 case ELFDATA2MSB
: /* Big-endian */
1614 if (! bfd_header_big_endian (templ
))
1616 bfd_set_error (bfd_error_wrong_format
);
1620 case ELFDATA2LSB
: /* Little-endian */
1621 if (! bfd_header_little_endian (templ
))
1623 bfd_set_error (bfd_error_wrong_format
);
1627 case ELFDATANONE
: /* No data encoding specified */
1628 default: /* Unknown data encoding specified */
1629 bfd_set_error (bfd_error_wrong_format
);
1633 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1635 /* The file header tells where to find the program headers.
1636 These are what we use to actually choose what to read. */
1638 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1640 bfd_set_error (bfd_error_wrong_format
);
1644 x_phdrs
= bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1645 if (x_phdrs
== NULL
)
1647 bfd_set_error (bfd_error_no_memory
);
1650 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1651 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1655 bfd_set_error (bfd_error_system_call
);
1659 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1663 loadbase
= ehdr_vma
;
1664 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1666 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1667 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1668 is executable only, and one is read only. We must not use the
1670 if (i_phdrs
[i
].p_type
== PT_LOAD
&& (i_phdrs
[i
].p_flags
& PF_R
))
1672 bfd_vma segment_end
;
1673 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1674 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1675 if (segment_end
> (bfd_vma
) contents_size
)
1676 contents_size
= segment_end
;
1678 if ((i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1679 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1681 last_phdr
= &i_phdrs
[i
];
1684 if (last_phdr
== NULL
)
1686 /* There were no PT_LOAD segments, so we don't have anything to read. */
1688 bfd_set_error (bfd_error_wrong_format
);
1692 /* Trim the last segment so we don't bother with zeros in the last page
1693 that are off the end of the file. However, if the extra bit in that
1694 page includes the section headers, keep them. */
1695 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1696 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1697 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1699 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1700 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1701 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1702 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1705 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1707 /* Now we know the size of the whole image we want read in. */
1708 contents
= bfd_zmalloc (contents_size
);
1709 if (contents
== NULL
)
1712 bfd_set_error (bfd_error_no_memory
);
1716 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1717 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1718 is executable only, and one is read only. We must not use the
1720 if (i_phdrs
[i
].p_type
== PT_LOAD
&& (i_phdrs
[i
].p_flags
& PF_R
))
1722 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1723 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1724 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1725 if (end
> (bfd_vma
) contents_size
)
1726 end
= contents_size
;
1727 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1728 & -i_phdrs
[i
].p_align
,
1729 contents
+ start
, end
- start
);
1734 bfd_set_error (bfd_error_system_call
);
1741 /* If the segments visible in memory didn't include the section headers,
1742 then clear them from the file header. */
1743 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1744 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1746 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1747 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1748 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1751 /* This will normally have been in the first PT_LOAD segment. But it
1752 conceivably could be missing, and we might have just changed it. */
1753 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1755 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1756 bim
= bfd_malloc (sizeof (struct bfd_in_memory
));
1760 bfd_set_error (bfd_error_no_memory
);
1763 nbfd
= _bfd_new_bfd ();
1768 bfd_set_error (bfd_error_no_memory
);
1771 nbfd
->filename
= "<in-memory>";
1772 nbfd
->xvec
= templ
->xvec
;
1773 bim
->size
= contents_size
;
1774 bim
->buffer
= contents
;
1775 nbfd
->iostream
= bim
;
1776 nbfd
->flags
= BFD_IN_MEMORY
;
1777 nbfd
->direction
= read_direction
;
1778 nbfd
->mtime
= time (NULL
);
1779 nbfd
->mtime_set
= TRUE
;
1782 *loadbasep
= loadbase
;
1786 #include "elfcore.h"
1788 /* Size-dependent data and functions. */
1789 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1790 sizeof (Elf_External_Ehdr
),
1791 sizeof (Elf_External_Phdr
),
1792 sizeof (Elf_External_Shdr
),
1793 sizeof (Elf_External_Rel
),
1794 sizeof (Elf_External_Rela
),
1795 sizeof (Elf_External_Sym
),
1796 sizeof (Elf_External_Dyn
),
1797 sizeof (Elf_External_Note
),
1800 ARCH_SIZE
, LOG_FILE_ALIGN
,
1801 ELFCLASS
, EV_CURRENT
,
1802 elf_write_out_phdrs
,
1803 elf_write_shdrs_and_ehdr
,
1806 elf_swap_symbol_out
,
1807 elf_slurp_reloc_table
,
1808 elf_slurp_symbol_table
,