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 Free Software Foundation, Inc.
5 Written by Fred Fish @ Cygnus Support, from information published
6 in "UNIX System V Release 4, Programmers Guide: ANSI C and
7 Programming Support Tools". Sufficient support for gdb.
9 Rewritten by Mark Eichin @ Cygnus Support, from information
10 published in "System V Application Binary Interface", chapters 4
11 and 5, as well as the various "Processor Supplement" documents
12 derived from it. Added support for assembler and other object file
13 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
14 Meissner (Open Software Foundation), and Peter Hoogenboom (University
15 of Utah) to finish and extend this.
17 This file is part of BFD, the Binary File Descriptor library.
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
33 /* Problems and other issues to resolve.
35 (1) BFD expects there to be some fixed number of "sections" in
36 the object file. I.E. there is a "section_count" variable in the
37 bfd structure which contains the number of sections. However, ELF
38 supports multiple "views" of a file. In particular, with current
39 implementations, executable files typically have two tables, a
40 program header table and a section header table, both of which
41 partition the executable.
43 In ELF-speak, the "linking view" of the file uses the section header
44 table to access "sections" within the file, and the "execution view"
45 uses the program header table to access "segments" within the file.
46 "Segments" typically may contain all the data from one or more
49 Note that the section header table is optional in ELF executables,
50 but it is this information that is most useful to gdb. If the
51 section header table is missing, then gdb should probably try
52 to make do with the program header table. (FIXME)
54 (2) The code in this file is compiled twice, once in 32-bit mode and
55 once in 64-bit mode. More of it should be made size-independent
58 (3) ELF section symbols are handled rather sloppily now. This should
59 be cleaned up, and ELF section symbols reconciled with BFD section
62 (4) We need a published spec for 64-bit ELF. We've got some stuff here
63 that we're using for SPARC V9 64-bit chips, but don't assume that
69 #include "libiberty.h"
74 /* Renaming structures, typedefs, macros and functions to be size-specific. */
75 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
76 #define Elf_External_Sym NAME(Elf,External_Sym)
77 #define Elf_External_Shdr NAME(Elf,External_Shdr)
78 #define Elf_External_Phdr NAME(Elf,External_Phdr)
79 #define Elf_External_Rel NAME(Elf,External_Rel)
80 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define Elf_External_Dyn NAME(Elf,External_Dyn)
83 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
84 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
85 #define elf_core_file_matches_executable_p \
86 NAME(bfd_elf,core_file_matches_executable_p)
87 #define elf_object_p NAME(bfd_elf,object_p)
88 #define elf_core_file_p NAME(bfd_elf,core_file_p)
89 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
90 #define elf_get_dynamic_symtab_upper_bound \
91 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
92 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
93 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
94 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
95 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
96 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
97 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
98 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
99 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
100 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
101 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
102 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
103 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
104 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
105 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
106 #define elf_canonicalize_dynamic_symtab \
107 NAME(bfd_elf,canonicalize_dynamic_symtab)
108 #define elf_get_synthetic_symtab \
109 NAME(bfd_elf,get_synthetic_symtab)
110 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
111 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
112 #define elf_get_lineno NAME(bfd_elf,get_lineno)
113 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
114 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
115 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
116 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
117 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
118 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
119 #define elf_find_section NAME(bfd_elf,find_section)
120 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
121 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
122 #define elf_write_relocs NAME(bfd_elf,write_relocs)
123 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
126 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
127 #define ELF_R_SYM(X) ELF64_R_SYM(X)
128 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
129 #define ELFCLASS ELFCLASS64
131 #define LOG_FILE_ALIGN 3
134 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
135 #define ELF_R_SYM(X) ELF32_R_SYM(X)
136 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
137 #define ELFCLASS ELFCLASS32
139 #define LOG_FILE_ALIGN 2
143 static void elf_debug_section (int, Elf_Internal_Shdr
*);
146 static void elf_debug_file (Elf_Internal_Ehdr
*);
149 /* Structure swapping routines */
151 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
152 can be handled by explicitly specifying 32 bits or "the long type". */
154 #define H_PUT_WORD H_PUT_64
155 #define H_PUT_SIGNED_WORD H_PUT_S64
156 #define H_GET_WORD H_GET_64
157 #define H_GET_SIGNED_WORD H_GET_S64
160 #define H_PUT_WORD H_PUT_32
161 #define H_PUT_SIGNED_WORD H_PUT_S32
162 #define H_GET_WORD H_GET_32
163 #define H_GET_SIGNED_WORD H_GET_S32
166 /* Translate an ELF symbol in external format into an ELF symbol in internal
170 elf_swap_symbol_in (bfd
*abfd
,
173 Elf_Internal_Sym
*dst
)
175 const Elf_External_Sym
*src
= psrc
;
176 const Elf_External_Sym_Shndx
*shndx
= pshn
;
177 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
179 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
181 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
183 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
184 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
185 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
186 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
187 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
188 if (dst
->st_shndx
== SHN_XINDEX
)
192 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
196 /* Translate an ELF symbol in internal format into an ELF symbol in external
200 elf_swap_symbol_out (bfd
*abfd
,
201 const Elf_Internal_Sym
*src
,
206 Elf_External_Sym
*dst
= cdst
;
207 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
208 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
209 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
210 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
211 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
213 if (tmp
> SHN_HIRESERVE
)
217 H_PUT_32 (abfd
, tmp
, shndx
);
220 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
223 /* Translate an ELF file header in external format into an ELF file header in
227 elf_swap_ehdr_in (bfd
*abfd
,
228 const Elf_External_Ehdr
*src
,
229 Elf_Internal_Ehdr
*dst
)
231 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
232 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
233 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
234 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
235 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
237 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
239 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
240 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
241 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
242 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
243 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
244 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
245 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
246 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
247 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
248 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
251 /* Translate an ELF file header in internal format into an ELF file header in
255 elf_swap_ehdr_out (bfd
*abfd
,
256 const Elf_Internal_Ehdr
*src
,
257 Elf_External_Ehdr
*dst
)
260 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
261 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
262 /* note that all elements of dst are *arrays of unsigned char* already... */
263 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
264 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
265 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
267 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
269 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
270 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
271 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
272 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
273 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
274 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
275 H_PUT_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
276 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
278 if (tmp
>= SHN_LORESERVE
)
280 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
281 tmp
= src
->e_shstrndx
;
282 if (tmp
>= SHN_LORESERVE
)
284 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
287 /* Translate an ELF section header table entry in external format into an
288 ELF section header table entry in internal format. */
291 elf_swap_shdr_in (bfd
*abfd
,
292 const Elf_External_Shdr
*src
,
293 Elf_Internal_Shdr
*dst
)
295 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
297 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
298 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
299 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
301 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
303 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
304 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
305 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
306 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
307 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
308 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
309 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
310 dst
->bfd_section
= NULL
;
311 dst
->contents
= NULL
;
314 /* Translate an ELF section header table entry in internal format into an
315 ELF section header table entry in external format. */
318 elf_swap_shdr_out (bfd
*abfd
,
319 const Elf_Internal_Shdr
*src
,
320 Elf_External_Shdr
*dst
)
322 /* note that all elements of dst are *arrays of unsigned char* already... */
323 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
324 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
325 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
326 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
327 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
328 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
329 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
330 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
331 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
332 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
335 /* Translate an ELF program header table entry in external format into an
336 ELF program header table entry in internal format. */
339 elf_swap_phdr_in (bfd
*abfd
,
340 const Elf_External_Phdr
*src
,
341 Elf_Internal_Phdr
*dst
)
343 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
345 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
346 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
347 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
350 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
351 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
355 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
356 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
358 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
359 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
360 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
364 elf_swap_phdr_out (bfd
*abfd
,
365 const Elf_Internal_Phdr
*src
,
366 Elf_External_Phdr
*dst
)
368 /* note that all elements of dst are *arrays of unsigned char* already... */
369 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
370 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
371 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
372 H_PUT_WORD (abfd
, src
->p_paddr
, dst
->p_paddr
);
373 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
374 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
375 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
376 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
379 /* Translate an ELF reloc from external format to internal format. */
381 elf_swap_reloc_in (bfd
*abfd
,
383 Elf_Internal_Rela
*dst
)
385 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
386 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
387 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
392 elf_swap_reloca_in (bfd
*abfd
,
394 Elf_Internal_Rela
*dst
)
396 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
397 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
398 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
399 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
402 /* Translate an ELF reloc from internal format to external format. */
404 elf_swap_reloc_out (bfd
*abfd
,
405 const Elf_Internal_Rela
*src
,
408 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
409 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
410 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
414 elf_swap_reloca_out (bfd
*abfd
,
415 const Elf_Internal_Rela
*src
,
418 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
419 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
420 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
421 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
425 elf_swap_dyn_in (bfd
*abfd
,
427 Elf_Internal_Dyn
*dst
)
429 const Elf_External_Dyn
*src
= p
;
431 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
432 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
436 elf_swap_dyn_out (bfd
*abfd
,
437 const Elf_Internal_Dyn
*src
,
440 Elf_External_Dyn
*dst
= p
;
442 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
443 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
446 /* ELF .o/exec file reading */
448 /* Begin processing a given object.
450 First we validate the file by reading in the ELF header and checking
453 static inline bfd_boolean
454 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
456 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
457 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
458 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
459 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
462 /* Check to see if the file associated with ABFD matches the target vector
465 Note that we may be called several times with the same ABFD, but different
466 target vectors, most of which will not match. We have to avoid leaving
467 any side effects in ABFD, or any data it points to (like tdata), if the
468 file does not match the target vector. */
471 elf_object_p (bfd
*abfd
)
473 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
474 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
475 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
476 Elf_Internal_Shdr i_shdr
;
477 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
478 unsigned int shindex
;
479 const struct elf_backend_data
*ebd
;
480 struct bfd_preserve preserve
;
484 preserve
.marker
= NULL
;
486 /* Read in the ELF header in external format. */
488 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
490 if (bfd_get_error () != bfd_error_system_call
)
491 goto got_wrong_format_error
;
496 /* Now check to see if we have a valid ELF file, and one that BFD can
497 make use of. The magic number must match, the address size ('class')
498 and byte-swapping must match our XVEC entry, and it must have a
499 section header table (FIXME: See comments re sections at top of this
502 if (! elf_file_p (&x_ehdr
)
503 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
504 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
505 goto got_wrong_format_error
;
507 /* Check that file's byte order matches xvec's */
508 switch (x_ehdr
.e_ident
[EI_DATA
])
510 case ELFDATA2MSB
: /* Big-endian */
511 if (! bfd_header_big_endian (abfd
))
512 goto got_wrong_format_error
;
514 case ELFDATA2LSB
: /* Little-endian */
515 if (! bfd_header_little_endian (abfd
))
516 goto got_wrong_format_error
;
518 case ELFDATANONE
: /* No data encoding specified */
519 default: /* Unknown data encoding specified */
520 goto got_wrong_format_error
;
523 if (!bfd_preserve_save (abfd
, &preserve
))
526 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
527 the tdata pointer in the bfd. */
529 if (! (*abfd
->xvec
->_bfd_set_format
[bfd_object
]) (abfd
))
531 preserve
.marker
= elf_tdata (abfd
);
533 /* Now that we know the byte order, swap in the rest of the header */
534 i_ehdrp
= elf_elfheader (abfd
);
535 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
537 elf_debug_file (i_ehdrp
);
540 /* Reject ET_CORE (header indicates core file, not object file) */
541 if (i_ehdrp
->e_type
== ET_CORE
)
542 goto got_wrong_format_error
;
544 /* If this is a relocatable file and there is no section header
545 table, then we're hosed. */
546 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
547 goto got_wrong_format_error
;
549 /* As a simple sanity check, verify that what BFD thinks is the
550 size of each section header table entry actually matches the size
551 recorded in the file, but only if there are any sections. */
552 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
553 goto got_wrong_format_error
;
555 /* Further sanity check. */
556 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
557 goto got_wrong_format_error
;
559 ebd
= get_elf_backend_data (abfd
);
561 /* Check that the ELF e_machine field matches what this particular
562 BFD format expects. */
563 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
564 && (ebd
->elf_machine_alt1
== 0
565 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
566 && (ebd
->elf_machine_alt2
== 0
567 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
569 const bfd_target
* const *target_ptr
;
571 if (ebd
->elf_machine_code
!= EM_NONE
)
572 goto got_wrong_format_error
;
574 /* This is the generic ELF target. Let it match any ELF target
575 for which we do not have a specific backend. */
576 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
578 const struct elf_backend_data
*back
;
580 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
582 back
= (const struct elf_backend_data
*) (*target_ptr
)->backend_data
;
583 if (back
->elf_machine_code
== i_ehdrp
->e_machine
584 || (back
->elf_machine_alt1
!= 0
585 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
586 || (back
->elf_machine_alt2
!= 0
587 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
589 /* target_ptr is an ELF backend which matches this
590 object file, so reject the generic ELF target. */
591 goto got_wrong_format_error
;
596 if (i_ehdrp
->e_type
== ET_EXEC
)
597 abfd
->flags
|= EXEC_P
;
598 else if (i_ehdrp
->e_type
== ET_DYN
)
599 abfd
->flags
|= DYNAMIC
;
601 if (i_ehdrp
->e_phnum
> 0)
602 abfd
->flags
|= D_PAGED
;
604 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
606 /* It's OK if this fails for the generic target. */
607 if (ebd
->elf_machine_code
!= EM_NONE
)
611 if (i_ehdrp
->e_shoff
!= 0)
613 bfd_signed_vma where
= i_ehdrp
->e_shoff
;
615 if (where
!= (file_ptr
) where
)
616 goto got_wrong_format_error
;
618 /* Seek to the section header table in the file. */
619 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
622 /* Read the first section header at index 0, and convert to internal
624 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
626 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
628 /* If the section count is zero, the actual count is in the first
630 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
632 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
633 if (i_ehdrp
->e_shnum
!= i_shdr
.sh_size
634 || i_ehdrp
->e_shnum
== 0)
635 goto got_wrong_format_error
;
638 /* And similarly for the string table index. */
639 if (i_ehdrp
->e_shstrndx
== SHN_XINDEX
)
641 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
642 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
643 goto got_wrong_format_error
;
646 /* Sanity check that we can read all of the section headers.
647 It ought to be good enough to just read the last one. */
648 if (i_ehdrp
->e_shnum
!= 1)
650 /* Check that we don't have a totally silly number of sections. */
651 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
652 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
653 goto got_wrong_format_error
;
655 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
656 if (where
!= (file_ptr
) where
)
657 goto got_wrong_format_error
;
658 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
659 goto got_wrong_format_error
;
661 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
663 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
666 /* Back to where we were. */
667 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
668 if (bfd_seek (abfd
, (file_ptr
) where
, SEEK_SET
) != 0)
673 /* Allocate space for a copy of the section header table in
675 if (i_ehdrp
->e_shnum
!= 0)
677 Elf_Internal_Shdr
*shdrp
;
678 unsigned int num_sec
;
680 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
681 i_shdrp
= bfd_alloc (abfd
, amt
);
684 num_sec
= i_ehdrp
->e_shnum
;
685 if (num_sec
> SHN_LORESERVE
)
686 num_sec
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
687 elf_numsections (abfd
) = num_sec
;
688 amt
= sizeof (i_shdrp
) * num_sec
;
689 elf_elfsections (abfd
) = bfd_alloc (abfd
, amt
);
690 if (!elf_elfsections (abfd
))
693 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
696 if (num_sec
> SHN_LORESERVE
)
698 for ( ; shindex
< SHN_LORESERVE
; shindex
++)
699 elf_elfsections (abfd
)[shindex
] = shdrp
++;
700 for ( ; shindex
< SHN_HIRESERVE
+ 1; shindex
++)
701 elf_elfsections (abfd
)[shindex
] = i_shdrp
;
703 for ( ; shindex
< num_sec
; shindex
++)
704 elf_elfsections (abfd
)[shindex
] = shdrp
++;
706 /* Read in the rest of the section header table and convert it
708 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
710 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
712 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
714 /* Sanity check sh_link and sh_info. */
715 if (i_shdrp
[shindex
].sh_link
>= num_sec
716 || (i_shdrp
[shindex
].sh_link
>= SHN_LORESERVE
717 && i_shdrp
[shindex
].sh_link
<= SHN_HIRESERVE
))
718 goto got_wrong_format_error
;
720 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
721 || i_shdrp
[shindex
].sh_type
== SHT_RELA
722 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
723 && (i_shdrp
[shindex
].sh_info
>= num_sec
724 || (i_shdrp
[shindex
].sh_info
>= SHN_LORESERVE
725 && i_shdrp
[shindex
].sh_info
<= SHN_HIRESERVE
)))
726 goto got_wrong_format_error
;
728 /* If the section is loaded, but not page aligned, clear
730 if (i_shdrp
[shindex
].sh_size
!= 0
731 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
732 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
733 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
736 abfd
->flags
&= ~D_PAGED
;
740 /* A further sanity check. */
741 if (i_ehdrp
->e_shnum
!= 0)
743 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
)
744 || (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
745 && i_ehdrp
->e_shstrndx
<= SHN_HIRESERVE
))
748 We used to just goto got_wrong_format_error here
749 but there are binaries in existance for which this test
750 will prevent the binutils from working with them at all.
751 So we are kind, and reset the string index value to 0
752 so that at least some processing can be done. */
753 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
754 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd
->filename
);
757 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
758 goto got_wrong_format_error
;
760 /* Read in the program headers. */
761 if (i_ehdrp
->e_phnum
== 0)
762 elf_tdata (abfd
)->phdr
= NULL
;
765 Elf_Internal_Phdr
*i_phdr
;
768 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
769 elf_tdata (abfd
)->phdr
= bfd_alloc (abfd
, amt
);
770 if (elf_tdata (abfd
)->phdr
== NULL
)
772 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
774 i_phdr
= elf_tdata (abfd
)->phdr
;
775 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
777 Elf_External_Phdr x_phdr
;
779 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
781 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
785 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
787 unsigned int num_sec
;
789 /* Once all of the section headers have been read and converted, we
790 can start processing them. Note that the first section header is
791 a dummy placeholder entry, so we ignore it. */
792 num_sec
= elf_numsections (abfd
);
793 for (shindex
= 1; shindex
< num_sec
; shindex
++)
795 if (! bfd_section_from_shdr (abfd
, shindex
))
797 if (shindex
== SHN_LORESERVE
- 1)
798 shindex
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
801 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
802 if (! _bfd_elf_setup_sections (abfd
))
803 goto got_wrong_format_error
;
806 /* Let the backend double check the format and override global
808 if (ebd
->elf_backend_object_p
)
810 if (! (*ebd
->elf_backend_object_p
) (abfd
))
811 goto got_wrong_format_error
;
814 /* Remember the entry point specified in the ELF file header. */
815 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
817 /* If we have created any reloc sections that are associated with
818 debugging sections, mark the reloc sections as debugging as well. */
819 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
821 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
822 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
823 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
825 unsigned long targ_index
;
828 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
829 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
831 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
832 s
->flags
|= SEC_DEBUGGING
;
836 bfd_preserve_finish (abfd
, &preserve
);
839 got_wrong_format_error
:
840 /* There is way too much undoing of half-known state here. The caller,
841 bfd_check_format_matches, really shouldn't iterate on live bfd's to
842 check match/no-match like it does. We have to rely on that a call to
843 bfd_default_set_arch_mach with the previously known mach, undoes what
844 was done by the first bfd_default_set_arch_mach (with mach 0) here.
845 For this to work, only elf-data and the mach may be changed by the
846 target-specific elf_backend_object_p function. Note that saving the
847 whole bfd here and restoring it would be even worse; the first thing
848 you notice is that the cached bfd file position gets out of sync. */
849 bfd_set_error (bfd_error_wrong_format
);
852 if (preserve
.marker
!= NULL
)
853 bfd_preserve_restore (abfd
, &preserve
);
857 /* ELF .o/exec file writing */
859 /* Write out the relocs. */
862 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
864 bfd_boolean
*failedp
= data
;
865 Elf_Internal_Shdr
*rela_hdr
;
867 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
874 /* If we have already failed, don't do anything. */
878 if ((sec
->flags
& SEC_RELOC
) == 0)
881 /* The linker backend writes the relocs out itself, and sets the
882 reloc_count field to zero to inhibit writing them here. Also,
883 sometimes the SEC_RELOC flag gets set even when there aren't any
885 if (sec
->reloc_count
== 0)
888 /* If we have opened an existing file for update, reloc_count may be
889 set even though we are not linking. In that case we have nothing
891 if (sec
->orelocation
== NULL
)
894 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
896 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
897 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
898 if (rela_hdr
->contents
== NULL
)
904 /* Figure out whether the relocations are RELA or REL relocations. */
905 if (rela_hdr
->sh_type
== SHT_RELA
)
907 swap_out
= elf_swap_reloca_out
;
908 extsize
= sizeof (Elf_External_Rela
);
910 else if (rela_hdr
->sh_type
== SHT_REL
)
912 swap_out
= elf_swap_reloc_out
;
913 extsize
= sizeof (Elf_External_Rel
);
916 /* Every relocation section should be either an SHT_RELA or an
920 /* The address of an ELF reloc is section relative for an object
921 file, and absolute for an executable file or shared library.
922 The address of a BFD reloc is always section relative. */
924 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
925 addr_offset
= sec
->vma
;
927 /* orelocation has the data, reloc_count has the count... */
930 dst_rela
= rela_hdr
->contents
;
932 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
934 Elf_Internal_Rela src_rela
;
939 ptr
= sec
->orelocation
[idx
];
940 sym
= *ptr
->sym_ptr_ptr
;
943 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
948 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
957 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
958 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
959 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
965 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
966 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
967 src_rela
.r_addend
= ptr
->addend
;
968 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
972 /* Write out the program headers. */
975 elf_write_out_phdrs (bfd
*abfd
,
976 const Elf_Internal_Phdr
*phdr
,
981 Elf_External_Phdr extphdr
;
982 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
983 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
984 != sizeof (Elf_External_Phdr
))
991 /* Write out the section headers and the ELF file header. */
994 elf_write_shdrs_and_ehdr (bfd
*abfd
)
996 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
997 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
998 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
999 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1003 i_ehdrp
= elf_elfheader (abfd
);
1004 i_shdrp
= elf_elfsections (abfd
);
1006 /* swap the header before spitting it out... */
1009 elf_debug_file (i_ehdrp
);
1011 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1012 amt
= sizeof (x_ehdr
);
1013 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1014 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1017 /* Some fields in the first section header handle overflow of ehdr
1019 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
)
1020 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1021 if (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
)
1022 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1024 /* at this point we've concocted all the ELF sections... */
1025 amt
= i_ehdrp
->e_shnum
;
1026 amt
*= sizeof (*x_shdrp
);
1027 x_shdrp
= bfd_alloc (abfd
, amt
);
1031 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1034 elf_debug_section (count
, *i_shdrp
);
1036 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1038 if (count
== SHN_LORESERVE
- 1)
1039 i_shdrp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
1041 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1042 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1045 /* need to dump the string table too... */
1051 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1053 Elf_Internal_Shdr
*hdr
;
1054 Elf_Internal_Shdr
*verhdr
;
1055 unsigned long symcount
; /* Number of external ELF symbols */
1056 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1057 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1058 Elf_Internal_Sym
*isym
;
1059 Elf_Internal_Sym
*isymend
;
1060 Elf_Internal_Sym
*isymbuf
= NULL
;
1061 Elf_External_Versym
*xver
;
1062 Elf_External_Versym
*xverbuf
= NULL
;
1063 const struct elf_backend_data
*ebd
;
1066 /* Read each raw ELF symbol, converting from external ELF form to
1067 internal ELF form, and then using the information to create a
1068 canonical bfd symbol table entry.
1070 Note that we allocate the initial bfd canonical symbol buffer
1071 based on a one-to-one mapping of the ELF symbols to canonical
1072 symbols. We actually use all the ELF symbols, so there will be no
1073 space left over at the end. When we have all the symbols, we
1074 build the caller's pointer vector. */
1078 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1083 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1084 if (elf_dynversym (abfd
) == 0)
1087 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1088 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1089 && elf_tdata (abfd
)->verdef
== NULL
)
1090 || (elf_tdata (abfd
)->dynverref_section
!= 0
1091 && elf_tdata (abfd
)->verref
== NULL
))
1093 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1098 ebd
= get_elf_backend_data (abfd
);
1099 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1101 sym
= symbase
= NULL
;
1104 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1106 if (isymbuf
== NULL
)
1110 amt
*= sizeof (elf_symbol_type
);
1111 symbase
= bfd_zalloc (abfd
, amt
);
1112 if (symbase
== (elf_symbol_type
*) NULL
)
1115 /* Read the raw ELF version symbol information. */
1117 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1119 (*_bfd_error_handler
)
1120 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1122 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1125 /* Slurp in the symbols without the version information,
1126 since that is more helpful than just quitting. */
1132 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1135 xverbuf
= bfd_malloc (verhdr
->sh_size
);
1136 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1139 if (bfd_bread (xverbuf
, verhdr
->sh_size
, abfd
) != verhdr
->sh_size
)
1143 /* Skip first symbol, which is a null dummy. */
1147 isymend
= isymbuf
+ symcount
;
1148 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1150 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1151 sym
->symbol
.the_bfd
= abfd
;
1153 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1155 sym
->symbol
.value
= isym
->st_value
;
1157 if (isym
->st_shndx
== SHN_UNDEF
)
1159 sym
->symbol
.section
= bfd_und_section_ptr
;
1161 else if (isym
->st_shndx
< SHN_LORESERVE
1162 || isym
->st_shndx
> SHN_HIRESERVE
)
1164 sym
->symbol
.section
= bfd_section_from_elf_index (abfd
,
1166 if (sym
->symbol
.section
== NULL
)
1168 /* This symbol is in a section for which we did not
1169 create a BFD section. Just use bfd_abs_section,
1170 although it is wrong. FIXME. */
1171 sym
->symbol
.section
= bfd_abs_section_ptr
;
1174 else if (isym
->st_shndx
== SHN_ABS
)
1176 sym
->symbol
.section
= bfd_abs_section_ptr
;
1178 else if (isym
->st_shndx
== SHN_COMMON
)
1180 sym
->symbol
.section
= bfd_com_section_ptr
;
1181 /* Elf puts the alignment into the `value' field, and
1182 the size into the `size' field. BFD wants to see the
1183 size in the value field, and doesn't care (at the
1184 moment) about the alignment. */
1185 sym
->symbol
.value
= isym
->st_size
;
1188 sym
->symbol
.section
= bfd_abs_section_ptr
;
1190 /* If this is a relocatable file, then the symbol value is
1191 already section relative. */
1192 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1193 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1195 switch (ELF_ST_BIND (isym
->st_info
))
1198 sym
->symbol
.flags
|= BSF_LOCAL
;
1201 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1202 sym
->symbol
.flags
|= BSF_GLOBAL
;
1205 sym
->symbol
.flags
|= BSF_WEAK
;
1209 switch (ELF_ST_TYPE (isym
->st_info
))
1212 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1215 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1218 sym
->symbol
.flags
|= BSF_FUNCTION
;
1221 sym
->symbol
.flags
|= BSF_OBJECT
;
1224 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1229 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1233 Elf_Internal_Versym iversym
;
1235 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1236 sym
->version
= iversym
.vs_vers
;
1240 /* Do some backend-specific processing on this symbol. */
1241 if (ebd
->elf_backend_symbol_processing
)
1242 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1246 /* Do some backend-specific processing on this symbol table. */
1247 if (ebd
->elf_backend_symbol_table_processing
)
1248 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1250 /* We rely on the zalloc to clear out the final symbol entry. */
1252 symcount
= sym
- symbase
;
1254 /* Fill in the user's symbol pointer vector if needed. */
1262 *symptrs
++ = &sym
->symbol
;
1265 *symptrs
= 0; /* Final null pointer */
1268 if (xverbuf
!= NULL
)
1270 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1275 if (xverbuf
!= NULL
)
1277 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1282 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1286 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1288 Elf_Internal_Shdr
*rel_hdr
,
1289 bfd_size_type reloc_count
,
1292 bfd_boolean dynamic
)
1294 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1295 void *allocated
= NULL
;
1296 bfd_byte
*native_relocs
;
1300 unsigned int symcount
;
1302 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1303 if (allocated
== NULL
)
1306 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1307 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1308 != rel_hdr
->sh_size
))
1311 native_relocs
= allocated
;
1313 entsize
= rel_hdr
->sh_entsize
;
1314 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1315 || entsize
== sizeof (Elf_External_Rela
));
1318 symcount
= bfd_get_dynamic_symcount (abfd
);
1320 symcount
= bfd_get_symcount (abfd
);
1322 for (i
= 0, relent
= relents
;
1324 i
++, relent
++, native_relocs
+= entsize
)
1326 Elf_Internal_Rela rela
;
1328 if (entsize
== sizeof (Elf_External_Rela
))
1329 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1331 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1333 /* The address of an ELF reloc is section relative for an object
1334 file, and absolute for an executable file or shared library.
1335 The address of a normal BFD reloc is always section relative,
1336 and the address of a dynamic reloc is absolute.. */
1337 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1338 relent
->address
= rela
.r_offset
;
1340 relent
->address
= rela
.r_offset
- asect
->vma
;
1342 if (ELF_R_SYM (rela
.r_info
) == 0)
1343 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1344 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1346 (*_bfd_error_handler
)
1347 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1348 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1349 relent
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
1354 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1356 relent
->sym_ptr_ptr
= ps
;
1359 relent
->addend
= rela
.r_addend
;
1361 if ((entsize
== sizeof (Elf_External_Rela
)
1362 && ebd
->elf_info_to_howto
!= NULL
)
1363 || ebd
->elf_info_to_howto_rel
== NULL
)
1364 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1366 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1369 if (allocated
!= NULL
)
1375 if (allocated
!= NULL
)
1380 /* Read in and swap the external relocs. */
1383 elf_slurp_reloc_table (bfd
*abfd
,
1386 bfd_boolean dynamic
)
1388 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1389 Elf_Internal_Shdr
*rel_hdr
;
1390 Elf_Internal_Shdr
*rel_hdr2
;
1391 bfd_size_type reloc_count
;
1392 bfd_size_type reloc_count2
;
1396 if (asect
->relocation
!= NULL
)
1401 if ((asect
->flags
& SEC_RELOC
) == 0
1402 || asect
->reloc_count
== 0)
1405 rel_hdr
= &d
->rel_hdr
;
1406 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1407 rel_hdr2
= d
->rel_hdr2
;
1408 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1410 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1411 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1412 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1417 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1418 case because relocations against this section may use the
1419 dynamic symbol table, and in that case bfd_section_from_shdr
1420 in elf.c does not update the RELOC_COUNT. */
1421 if (asect
->size
== 0)
1424 rel_hdr
= &d
->this_hdr
;
1425 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1430 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1431 relents
= bfd_alloc (abfd
, amt
);
1432 if (relents
== NULL
)
1435 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1436 rel_hdr
, reloc_count
,
1442 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1443 rel_hdr2
, reloc_count2
,
1444 relents
+ reloc_count
,
1448 asect
->relocation
= relents
;
1454 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1456 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1457 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1460 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1461 (long) hdr
->sh_name
,
1462 (long) hdr
->sh_type
,
1463 (long) hdr
->sh_flags
);
1465 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1466 (long) hdr
->sh_addr
,
1467 (long) hdr
->sh_offset
,
1468 (long) hdr
->sh_size
);
1470 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1471 (long) hdr
->sh_link
,
1472 (long) hdr
->sh_info
,
1473 (long) hdr
->sh_addralign
);
1474 fprintf (stderr
, "sh_entsize = %ld\n",
1475 (long) hdr
->sh_entsize
);
1482 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1484 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1485 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1486 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1487 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1488 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1489 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1490 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1494 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1495 reconstruct an ELF file by reading the segments out of remote memory
1496 based on the ELF file header at EHDR_VMA and the ELF program headers it
1497 points to. If not null, *LOADBASEP is filled in with the difference
1498 between the VMAs from which the segments were read, and the VMAs the
1499 file headers (and hence BFD's idea of each section's VMA) put them at.
1501 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1502 remote memory at target address VMA into the local buffer at MYADDR; it
1503 should return zero on success or an `errno' code on failure. TEMPL must
1504 be a BFD for a target with the word size and byte order found in the
1508 NAME(_bfd_elf
,bfd_from_remote_memory
)
1512 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, int))
1514 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1515 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1516 Elf_External_Phdr
*x_phdrs
;
1517 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1519 struct bfd_in_memory
*bim
;
1526 /* Read in the ELF header in external format. */
1527 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1530 bfd_set_error (bfd_error_system_call
);
1535 /* Now check to see if we have a valid ELF file, and one that BFD can
1536 make use of. The magic number must match, the address size ('class')
1537 and byte-swapping must match our XVEC entry. */
1539 if (! elf_file_p (&x_ehdr
)
1540 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1541 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1543 bfd_set_error (bfd_error_wrong_format
);
1547 /* Check that file's byte order matches xvec's */
1548 switch (x_ehdr
.e_ident
[EI_DATA
])
1550 case ELFDATA2MSB
: /* Big-endian */
1551 if (! bfd_header_big_endian (templ
))
1553 bfd_set_error (bfd_error_wrong_format
);
1557 case ELFDATA2LSB
: /* Little-endian */
1558 if (! bfd_header_little_endian (templ
))
1560 bfd_set_error (bfd_error_wrong_format
);
1564 case ELFDATANONE
: /* No data encoding specified */
1565 default: /* Unknown data encoding specified */
1566 bfd_set_error (bfd_error_wrong_format
);
1570 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1572 /* The file header tells where to find the program headers.
1573 These are what we use to actually choose what to read. */
1575 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1577 bfd_set_error (bfd_error_wrong_format
);
1581 x_phdrs
= bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1582 if (x_phdrs
== NULL
)
1584 bfd_set_error (bfd_error_no_memory
);
1587 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1588 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1592 bfd_set_error (bfd_error_system_call
);
1596 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1600 loadbase
= ehdr_vma
;
1601 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1603 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1604 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1605 is executable only, and one is read only. We must not use the
1607 if (i_phdrs
[i
].p_type
== PT_LOAD
&& (i_phdrs
[i
].p_flags
& PF_R
))
1609 bfd_vma segment_end
;
1610 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1611 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1612 if (segment_end
> (bfd_vma
) contents_size
)
1613 contents_size
= segment_end
;
1615 if ((i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1616 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1618 last_phdr
= &i_phdrs
[i
];
1621 if (last_phdr
== NULL
)
1623 /* There were no PT_LOAD segments, so we don't have anything to read. */
1625 bfd_set_error (bfd_error_wrong_format
);
1629 /* Trim the last segment so we don't bother with zeros in the last page
1630 that are off the end of the file. However, if the extra bit in that
1631 page includes the section headers, keep them. */
1632 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1633 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1634 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1636 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1637 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1638 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1639 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1642 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1644 /* Now we know the size of the whole image we want read in. */
1645 contents
= bfd_zmalloc (contents_size
);
1646 if (contents
== NULL
)
1649 bfd_set_error (bfd_error_no_memory
);
1653 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1654 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1655 is executable only, and one is read only. We must not use the
1657 if (i_phdrs
[i
].p_type
== PT_LOAD
&& (i_phdrs
[i
].p_flags
& PF_R
))
1659 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1660 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1661 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1662 if (end
> (bfd_vma
) contents_size
)
1663 end
= contents_size
;
1664 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1665 & -i_phdrs
[i
].p_align
,
1666 contents
+ start
, end
- start
);
1671 bfd_set_error (bfd_error_system_call
);
1678 /* If the segments visible in memory didn't include the section headers,
1679 then clear them from the file header. */
1680 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1681 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1683 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1684 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1685 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1688 /* This will normally have been in the first PT_LOAD segment. But it
1689 conceivably could be missing, and we might have just changed it. */
1690 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1692 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1693 bim
= bfd_malloc (sizeof (struct bfd_in_memory
));
1697 bfd_set_error (bfd_error_no_memory
);
1700 nbfd
= _bfd_new_bfd ();
1705 bfd_set_error (bfd_error_no_memory
);
1708 nbfd
->filename
= "<in-memory>";
1709 nbfd
->xvec
= templ
->xvec
;
1710 bim
->size
= contents_size
;
1711 bim
->buffer
= contents
;
1712 nbfd
->iostream
= bim
;
1713 nbfd
->flags
= BFD_IN_MEMORY
;
1714 nbfd
->direction
= read_direction
;
1715 nbfd
->mtime
= time (NULL
);
1716 nbfd
->mtime_set
= TRUE
;
1719 *loadbasep
= loadbase
;
1723 #include "elfcore.h"
1725 /* Size-dependent data and functions. */
1726 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1727 sizeof (Elf_External_Ehdr
),
1728 sizeof (Elf_External_Phdr
),
1729 sizeof (Elf_External_Shdr
),
1730 sizeof (Elf_External_Rel
),
1731 sizeof (Elf_External_Rela
),
1732 sizeof (Elf_External_Sym
),
1733 sizeof (Elf_External_Dyn
),
1734 sizeof (Elf_External_Note
),
1737 ARCH_SIZE
, LOG_FILE_ALIGN
,
1738 ELFCLASS
, EV_CURRENT
,
1739 elf_write_out_phdrs
,
1740 elf_write_shdrs_and_ehdr
,
1743 elf_swap_symbol_out
,
1744 elf_slurp_reloc_table
,
1745 elf_slurp_symbol_table
,