1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
109 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
110 #define elf_get_lineno NAME(bfd_elf,get_lineno)
111 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
112 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
113 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
114 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
115 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
116 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
117 #define elf_find_section NAME(bfd_elf,find_section)
118 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
119 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
120 #define elf_write_relocs NAME(bfd_elf,write_relocs)
121 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
122 #define elf_bfd_discard_info NAME(bfd_elf,discard_info)
123 #define elf_reloc_symbol_deleted_p NAME(_bfd_elf,reloc_symbol_deleted_p)
124 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
125 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
126 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
127 #define elf_gc_common_finalize_got_offsets \
128 NAME(_bfd_elf,gc_common_finalize_got_offsets)
129 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
130 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
131 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
132 #define elf_link_record_local_dynamic_symbol \
133 NAME(_bfd_elf,link_record_local_dynamic_symbol)
136 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
137 #define ELF_R_SYM(X) ELF64_R_SYM(X)
138 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
139 #define ELFCLASS ELFCLASS64
141 #define LOG_FILE_ALIGN 3
144 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
145 #define ELF_R_SYM(X) ELF32_R_SYM(X)
146 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
147 #define ELFCLASS ELFCLASS32
149 #define LOG_FILE_ALIGN 2
153 static void elf_debug_section (int, Elf_Internal_Shdr
*);
154 static void elf_debug_file (Elf_Internal_Ehdr
*);
155 static char *elf_symbol_flags (flagword
);
158 /* Structure swapping routines */
160 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
161 can be handled by explicitly specifying 32 bits or "the long type". */
163 #define H_PUT_WORD H_PUT_64
164 #define H_PUT_SIGNED_WORD H_PUT_S64
165 #define H_GET_WORD H_GET_64
166 #define H_GET_SIGNED_WORD H_GET_S64
169 #define H_PUT_WORD H_PUT_32
170 #define H_PUT_SIGNED_WORD H_PUT_S32
171 #define H_GET_WORD H_GET_32
172 #define H_GET_SIGNED_WORD H_GET_S32
175 /* Translate an ELF symbol in external format into an ELF symbol in internal
179 elf_swap_symbol_in (bfd
*abfd
,
182 Elf_Internal_Sym
*dst
)
184 const Elf_External_Sym
*src
= psrc
;
185 const Elf_External_Sym_Shndx
*shndx
= pshn
;
186 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
188 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
190 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
192 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
193 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
194 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
195 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
196 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
197 if (dst
->st_shndx
== SHN_XINDEX
)
201 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
205 /* Translate an ELF symbol in internal format into an ELF symbol in external
209 elf_swap_symbol_out (bfd
*abfd
,
210 const Elf_Internal_Sym
*src
,
215 Elf_External_Sym
*dst
= cdst
;
216 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
217 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
218 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
219 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
220 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
222 if (tmp
> SHN_HIRESERVE
)
226 H_PUT_32 (abfd
, tmp
, shndx
);
229 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
232 /* Translate an ELF file header in external format into an ELF file header in
236 elf_swap_ehdr_in (bfd
*abfd
,
237 const Elf_External_Ehdr
*src
,
238 Elf_Internal_Ehdr
*dst
)
240 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
241 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
242 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
243 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
244 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
246 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
248 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
249 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
250 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
251 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
252 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
253 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
254 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
255 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
256 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
257 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
260 /* Translate an ELF file header in internal format into an ELF file header in
264 elf_swap_ehdr_out (bfd
*abfd
,
265 const Elf_Internal_Ehdr
*src
,
266 Elf_External_Ehdr
*dst
)
269 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
270 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
271 /* note that all elements of dst are *arrays of unsigned char* already... */
272 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
273 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
274 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
276 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
278 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
279 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
280 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
281 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
282 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
283 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
284 H_PUT_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
285 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
287 if (tmp
>= SHN_LORESERVE
)
289 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
290 tmp
= src
->e_shstrndx
;
291 if (tmp
>= SHN_LORESERVE
)
293 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
296 /* Translate an ELF section header table entry in external format into an
297 ELF section header table entry in internal format. */
300 elf_swap_shdr_in (bfd
*abfd
,
301 const Elf_External_Shdr
*src
,
302 Elf_Internal_Shdr
*dst
)
304 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
306 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
307 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
308 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
310 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
312 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
313 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
314 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
315 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
316 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
317 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
318 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
319 dst
->bfd_section
= NULL
;
320 dst
->contents
= NULL
;
323 /* Translate an ELF section header table entry in internal format into an
324 ELF section header table entry in external format. */
327 elf_swap_shdr_out (bfd
*abfd
,
328 const Elf_Internal_Shdr
*src
,
329 Elf_External_Shdr
*dst
)
331 /* note that all elements of dst are *arrays of unsigned char* already... */
332 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
333 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
334 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
335 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
336 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
337 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
338 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
339 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
340 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
341 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
344 /* Translate an ELF program header table entry in external format into an
345 ELF program header table entry in internal format. */
348 elf_swap_phdr_in (bfd
*abfd
,
349 const Elf_External_Phdr
*src
,
350 Elf_Internal_Phdr
*dst
)
352 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
354 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
355 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
356 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
359 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
360 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
364 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
365 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
367 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
368 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
369 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
373 elf_swap_phdr_out (bfd
*abfd
,
374 const Elf_Internal_Phdr
*src
,
375 Elf_External_Phdr
*dst
)
377 /* note that all elements of dst are *arrays of unsigned char* already... */
378 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
379 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
380 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
381 H_PUT_WORD (abfd
, src
->p_paddr
, dst
->p_paddr
);
382 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
383 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
384 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
385 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
388 /* Translate an ELF reloc from external format to internal format. */
390 elf_swap_reloc_in (bfd
*abfd
,
392 Elf_Internal_Rela
*dst
)
394 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
395 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
396 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
401 elf_swap_reloca_in (bfd
*abfd
,
403 Elf_Internal_Rela
*dst
)
405 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
406 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
407 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
408 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
411 /* Translate an ELF reloc from internal format to external format. */
413 elf_swap_reloc_out (bfd
*abfd
,
414 const Elf_Internal_Rela
*src
,
417 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
418 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
419 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
423 elf_swap_reloca_out (bfd
*abfd
,
424 const Elf_Internal_Rela
*src
,
427 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
428 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
429 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
430 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
434 elf_swap_dyn_in (bfd
*abfd
,
436 Elf_Internal_Dyn
*dst
)
438 const Elf_External_Dyn
*src
= p
;
440 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
441 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
445 elf_swap_dyn_out (bfd
*abfd
,
446 const Elf_Internal_Dyn
*src
,
449 Elf_External_Dyn
*dst
= p
;
451 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
452 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
455 /* ELF .o/exec file reading */
457 /* Begin processing a given object.
459 First we validate the file by reading in the ELF header and checking
462 static inline bfd_boolean
463 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
465 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
466 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
467 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
468 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
471 /* Check to see if the file associated with ABFD matches the target vector
474 Note that we may be called several times with the same ABFD, but different
475 target vectors, most of which will not match. We have to avoid leaving
476 any side effects in ABFD, or any data it points to (like tdata), if the
477 file does not match the target vector. */
480 elf_object_p (bfd
*abfd
)
482 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
483 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
484 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
485 Elf_Internal_Shdr i_shdr
;
486 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
487 unsigned int shindex
;
488 char *shstrtab
; /* Internal copy of section header stringtab */
489 const struct elf_backend_data
*ebd
;
490 struct bfd_preserve preserve
;
494 preserve
.marker
= NULL
;
496 /* Read in the ELF header in external format. */
498 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
500 if (bfd_get_error () != bfd_error_system_call
)
501 goto got_wrong_format_error
;
506 /* Now check to see if we have a valid ELF file, and one that BFD can
507 make use of. The magic number must match, the address size ('class')
508 and byte-swapping must match our XVEC entry, and it must have a
509 section header table (FIXME: See comments re sections at top of this
512 if (! elf_file_p (&x_ehdr
)
513 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
514 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
515 goto got_wrong_format_error
;
517 /* Check that file's byte order matches xvec's */
518 switch (x_ehdr
.e_ident
[EI_DATA
])
520 case ELFDATA2MSB
: /* Big-endian */
521 if (! bfd_header_big_endian (abfd
))
522 goto got_wrong_format_error
;
524 case ELFDATA2LSB
: /* Little-endian */
525 if (! bfd_header_little_endian (abfd
))
526 goto got_wrong_format_error
;
528 case ELFDATANONE
: /* No data encoding specified */
529 default: /* Unknown data encoding specified */
530 goto got_wrong_format_error
;
533 if (!bfd_preserve_save (abfd
, &preserve
))
536 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
537 the tdata pointer in the bfd. */
539 if (! (*abfd
->xvec
->_bfd_set_format
[bfd_object
]) (abfd
))
541 preserve
.marker
= elf_tdata (abfd
);
543 /* Now that we know the byte order, swap in the rest of the header */
544 i_ehdrp
= elf_elfheader (abfd
);
545 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
547 elf_debug_file (i_ehdrp
);
550 /* Reject ET_CORE (header indicates core file, not object file) */
551 if (i_ehdrp
->e_type
== ET_CORE
)
552 goto got_wrong_format_error
;
554 /* If this is a relocatable file and there is no section header
555 table, then we're hosed. */
556 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
557 goto got_wrong_format_error
;
559 /* As a simple sanity check, verify that the what BFD thinks is the
560 size of each section header table entry actually matches the size
561 recorded in the file, but only if there are any sections. */
562 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
563 goto got_wrong_format_error
;
565 /* Further sanity check. */
566 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
567 goto got_wrong_format_error
;
569 ebd
= get_elf_backend_data (abfd
);
571 /* Check that the ELF e_machine field matches what this particular
572 BFD format expects. */
573 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
574 && (ebd
->elf_machine_alt1
== 0
575 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
576 && (ebd
->elf_machine_alt2
== 0
577 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
579 const bfd_target
* const *target_ptr
;
581 if (ebd
->elf_machine_code
!= EM_NONE
)
582 goto got_wrong_format_error
;
584 /* This is the generic ELF target. Let it match any ELF target
585 for which we do not have a specific backend. */
586 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
588 const struct elf_backend_data
*back
;
590 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
592 back
= (const struct elf_backend_data
*) (*target_ptr
)->backend_data
;
593 if (back
->elf_machine_code
== i_ehdrp
->e_machine
594 || (back
->elf_machine_alt1
!= 0
595 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
596 || (back
->elf_machine_alt2
!= 0
597 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
599 /* target_ptr is an ELF backend which matches this
600 object file, so reject the generic ELF target. */
601 goto got_wrong_format_error
;
606 if (i_ehdrp
->e_type
== ET_EXEC
)
607 abfd
->flags
|= EXEC_P
;
608 else if (i_ehdrp
->e_type
== ET_DYN
)
609 abfd
->flags
|= DYNAMIC
;
611 if (i_ehdrp
->e_phnum
> 0)
612 abfd
->flags
|= D_PAGED
;
614 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
616 /* It's OK if this fails for the generic target. */
617 if (ebd
->elf_machine_code
!= EM_NONE
)
621 /* Remember the entry point specified in the ELF file header. */
622 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
624 if (i_ehdrp
->e_shoff
!= 0)
626 /* Seek to the section header table in the file. */
627 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
630 /* Read the first section header at index 0, and convert to internal
632 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
634 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
636 /* If the section count is zero, the actual count is in the first
638 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
639 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
641 /* And similarly for the string table index. */
642 if (i_ehdrp
->e_shstrndx
== SHN_XINDEX
)
643 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
646 /* Allocate space for a copy of the section header table in
648 if (i_ehdrp
->e_shnum
!= 0)
650 Elf_Internal_Shdr
*shdrp
;
651 unsigned int num_sec
;
653 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
654 i_shdrp
= bfd_alloc (abfd
, amt
);
657 num_sec
= i_ehdrp
->e_shnum
;
658 if (num_sec
> SHN_LORESERVE
)
659 num_sec
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
660 elf_numsections (abfd
) = num_sec
;
661 amt
= sizeof (i_shdrp
) * num_sec
;
662 elf_elfsections (abfd
) = bfd_alloc (abfd
, amt
);
663 if (!elf_elfsections (abfd
))
666 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
669 if (num_sec
> SHN_LORESERVE
)
671 for ( ; shindex
< SHN_LORESERVE
; shindex
++)
672 elf_elfsections (abfd
)[shindex
] = shdrp
++;
673 for ( ; shindex
< SHN_HIRESERVE
+ 1; shindex
++)
674 elf_elfsections (abfd
)[shindex
] = i_shdrp
;
676 for ( ; shindex
< num_sec
; shindex
++)
677 elf_elfsections (abfd
)[shindex
] = shdrp
++;
679 /* Read in the rest of the section header table and convert it
681 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
683 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
685 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
687 /* If the section is loaded, but not page aligned, clear
689 if (i_shdrp
[shindex
].sh_size
!= 0
690 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
691 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
692 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
695 abfd
->flags
&= ~D_PAGED
;
699 if (i_ehdrp
->e_shstrndx
&& i_ehdrp
->e_shoff
)
701 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
705 /* Read in the program headers. */
706 if (i_ehdrp
->e_phnum
== 0)
707 elf_tdata (abfd
)->phdr
= NULL
;
710 Elf_Internal_Phdr
*i_phdr
;
713 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
714 elf_tdata (abfd
)->phdr
= bfd_alloc (abfd
, amt
);
715 if (elf_tdata (abfd
)->phdr
== NULL
)
717 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
719 i_phdr
= elf_tdata (abfd
)->phdr
;
720 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
722 Elf_External_Phdr x_phdr
;
724 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
726 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
730 /* Read in the string table containing the names of the sections. We
731 will need the base pointer to this table later. */
732 /* We read this inline now, so that we don't have to go through
733 bfd_section_from_shdr with it (since this particular strtab is
734 used to find all of the ELF section names.) */
736 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
)
738 unsigned int num_sec
;
740 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
744 /* Once all of the section headers have been read and converted, we
745 can start processing them. Note that the first section header is
746 a dummy placeholder entry, so we ignore it. */
747 num_sec
= elf_numsections (abfd
);
748 for (shindex
= 1; shindex
< num_sec
; shindex
++)
750 if (! bfd_section_from_shdr (abfd
, shindex
))
752 if (shindex
== SHN_LORESERVE
- 1)
753 shindex
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
757 /* Let the backend double check the format and override global
759 if (ebd
->elf_backend_object_p
)
761 if (! (*ebd
->elf_backend_object_p
) (abfd
))
762 goto got_wrong_format_error
;
765 /* If we have created any reloc sections that are associated with
766 debugging sections, mark the reloc sections as debugging as well. */
767 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
769 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
770 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
771 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
773 unsigned long targ_index
;
776 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
777 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
779 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
780 s
->flags
|= SEC_DEBUGGING
;
784 bfd_preserve_finish (abfd
, &preserve
);
787 got_wrong_format_error
:
788 /* There is way too much undoing of half-known state here. The caller,
789 bfd_check_format_matches, really shouldn't iterate on live bfd's to
790 check match/no-match like it does. We have to rely on that a call to
791 bfd_default_set_arch_mach with the previously known mach, undoes what
792 was done by the first bfd_default_set_arch_mach (with mach 0) here.
793 For this to work, only elf-data and the mach may be changed by the
794 target-specific elf_backend_object_p function. Note that saving the
795 whole bfd here and restoring it would be even worse; the first thing
796 you notice is that the cached bfd file position gets out of sync. */
797 bfd_set_error (bfd_error_wrong_format
);
800 if (preserve
.marker
!= NULL
)
801 bfd_preserve_restore (abfd
, &preserve
);
805 /* ELF .o/exec file writing */
807 /* Write out the relocs. */
810 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
812 bfd_boolean
*failedp
= data
;
813 Elf_Internal_Shdr
*rela_hdr
;
815 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
822 /* If we have already failed, don't do anything. */
826 if ((sec
->flags
& SEC_RELOC
) == 0)
829 /* The linker backend writes the relocs out itself, and sets the
830 reloc_count field to zero to inhibit writing them here. Also,
831 sometimes the SEC_RELOC flag gets set even when there aren't any
833 if (sec
->reloc_count
== 0)
836 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
838 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
839 rela_hdr
->contents
= bfd_alloc (abfd
, rela_hdr
->sh_size
);
840 if (rela_hdr
->contents
== NULL
)
846 /* Figure out whether the relocations are RELA or REL relocations. */
847 if (rela_hdr
->sh_type
== SHT_RELA
)
849 swap_out
= elf_swap_reloca_out
;
850 extsize
= sizeof (Elf_External_Rela
);
852 else if (rela_hdr
->sh_type
== SHT_REL
)
854 swap_out
= elf_swap_reloc_out
;
855 extsize
= sizeof (Elf_External_Rel
);
858 /* Every relocation section should be either an SHT_RELA or an
862 /* The address of an ELF reloc is section relative for an object
863 file, and absolute for an executable file or shared library.
864 The address of a BFD reloc is always section relative. */
866 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
867 addr_offset
= sec
->vma
;
869 /* orelocation has the data, reloc_count has the count... */
872 dst_rela
= rela_hdr
->contents
;
874 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
876 Elf_Internal_Rela src_rela
;
881 ptr
= sec
->orelocation
[idx
];
882 sym
= *ptr
->sym_ptr_ptr
;
885 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
890 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
899 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
900 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
901 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
907 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
908 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
909 src_rela
.r_addend
= ptr
->addend
;
910 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
914 /* Write out the program headers. */
917 elf_write_out_phdrs (bfd
*abfd
,
918 const Elf_Internal_Phdr
*phdr
,
923 Elf_External_Phdr extphdr
;
924 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
925 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
926 != sizeof (Elf_External_Phdr
))
933 /* Write out the section headers and the ELF file header. */
936 elf_write_shdrs_and_ehdr (bfd
*abfd
)
938 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
939 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
940 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
941 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
945 i_ehdrp
= elf_elfheader (abfd
);
946 i_shdrp
= elf_elfsections (abfd
);
948 /* swap the header before spitting it out... */
951 elf_debug_file (i_ehdrp
);
953 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
954 amt
= sizeof (x_ehdr
);
955 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
956 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
959 /* Some fields in the first section header handle overflow of ehdr
961 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
)
962 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
963 if (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
)
964 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
966 /* at this point we've concocted all the ELF sections... */
967 amt
= i_ehdrp
->e_shnum
;
968 amt
*= sizeof (*x_shdrp
);
969 x_shdrp
= bfd_alloc (abfd
, amt
);
973 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
976 elf_debug_section (count
, *i_shdrp
);
978 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
980 if (count
== SHN_LORESERVE
- 1)
981 i_shdrp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
983 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
984 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
987 /* need to dump the string table too... */
993 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
995 Elf_Internal_Shdr
*hdr
;
996 Elf_Internal_Shdr
*verhdr
;
997 unsigned long symcount
; /* Number of external ELF symbols */
998 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
999 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1000 Elf_Internal_Sym
*isym
;
1001 Elf_Internal_Sym
*isymend
;
1002 Elf_Internal_Sym
*isymbuf
= NULL
;
1003 Elf_External_Versym
*xver
;
1004 Elf_External_Versym
*xverbuf
= NULL
;
1005 const struct elf_backend_data
*ebd
;
1008 /* Read each raw ELF symbol, converting from external ELF form to
1009 internal ELF form, and then using the information to create a
1010 canonical bfd symbol table entry.
1012 Note that we allocate the initial bfd canonical symbol buffer
1013 based on a one-to-one mapping of the ELF symbols to canonical
1014 symbols. We actually use all the ELF symbols, so there will be no
1015 space left over at the end. When we have all the symbols, we
1016 build the caller's pointer vector. */
1020 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1025 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1026 if (elf_dynversym (abfd
) == 0)
1029 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1030 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1031 && elf_tdata (abfd
)->verdef
== NULL
)
1032 || (elf_tdata (abfd
)->dynverref_section
!= 0
1033 && elf_tdata (abfd
)->verref
== NULL
))
1035 if (! _bfd_elf_slurp_version_tables (abfd
))
1040 ebd
= get_elf_backend_data (abfd
);
1041 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1043 sym
= symbase
= NULL
;
1046 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1048 if (isymbuf
== NULL
)
1052 amt
*= sizeof (elf_symbol_type
);
1053 symbase
= bfd_zalloc (abfd
, amt
);
1054 if (symbase
== (elf_symbol_type
*) NULL
)
1057 /* Read the raw ELF version symbol information. */
1059 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1061 (*_bfd_error_handler
)
1062 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1064 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1067 /* Slurp in the symbols without the version information,
1068 since that is more helpful than just quitting. */
1074 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1077 xverbuf
= bfd_malloc (verhdr
->sh_size
);
1078 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1081 if (bfd_bread (xverbuf
, verhdr
->sh_size
, abfd
) != verhdr
->sh_size
)
1085 /* Skip first symbol, which is a null dummy. */
1089 isymend
= isymbuf
+ symcount
;
1090 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1092 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1093 sym
->symbol
.the_bfd
= abfd
;
1095 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
1099 sym
->symbol
.value
= isym
->st_value
;
1101 if (isym
->st_shndx
== SHN_UNDEF
)
1103 sym
->symbol
.section
= bfd_und_section_ptr
;
1105 else if (isym
->st_shndx
< SHN_LORESERVE
1106 || isym
->st_shndx
> SHN_HIRESERVE
)
1108 sym
->symbol
.section
= bfd_section_from_elf_index (abfd
,
1110 if (sym
->symbol
.section
== NULL
)
1112 /* This symbol is in a section for which we did not
1113 create a BFD section. Just use bfd_abs_section,
1114 although it is wrong. FIXME. */
1115 sym
->symbol
.section
= bfd_abs_section_ptr
;
1118 else if (isym
->st_shndx
== SHN_ABS
)
1120 sym
->symbol
.section
= bfd_abs_section_ptr
;
1122 else if (isym
->st_shndx
== SHN_COMMON
)
1124 sym
->symbol
.section
= bfd_com_section_ptr
;
1125 /* Elf puts the alignment into the `value' field, and
1126 the size into the `size' field. BFD wants to see the
1127 size in the value field, and doesn't care (at the
1128 moment) about the alignment. */
1129 sym
->symbol
.value
= isym
->st_size
;
1132 sym
->symbol
.section
= bfd_abs_section_ptr
;
1134 /* If this is a relocatable file, then the symbol value is
1135 already section relative. */
1136 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1137 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1139 switch (ELF_ST_BIND (isym
->st_info
))
1142 sym
->symbol
.flags
|= BSF_LOCAL
;
1145 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1146 sym
->symbol
.flags
|= BSF_GLOBAL
;
1149 sym
->symbol
.flags
|= BSF_WEAK
;
1153 switch (ELF_ST_TYPE (isym
->st_info
))
1156 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1159 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1162 sym
->symbol
.flags
|= BSF_FUNCTION
;
1165 sym
->symbol
.flags
|= BSF_OBJECT
;
1170 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1174 Elf_Internal_Versym iversym
;
1176 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1177 sym
->version
= iversym
.vs_vers
;
1181 /* Do some backend-specific processing on this symbol. */
1182 if (ebd
->elf_backend_symbol_processing
)
1183 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1187 /* Do some backend-specific processing on this symbol table. */
1188 if (ebd
->elf_backend_symbol_table_processing
)
1189 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1191 /* We rely on the zalloc to clear out the final symbol entry. */
1193 symcount
= sym
- symbase
;
1195 /* Fill in the user's symbol pointer vector if needed. */
1203 *symptrs
++ = &sym
->symbol
;
1206 *symptrs
= 0; /* Final null pointer */
1209 if (xverbuf
!= NULL
)
1211 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1216 if (xverbuf
!= NULL
)
1218 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1223 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1227 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1229 Elf_Internal_Shdr
*rel_hdr
,
1230 bfd_size_type reloc_count
,
1233 bfd_boolean dynamic
)
1235 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1236 void *allocated
= NULL
;
1237 bfd_byte
*native_relocs
;
1241 unsigned int symcount
;
1243 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1244 if (allocated
== NULL
)
1247 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1248 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1249 != rel_hdr
->sh_size
))
1252 native_relocs
= allocated
;
1254 entsize
= rel_hdr
->sh_entsize
;
1255 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1256 || entsize
== sizeof (Elf_External_Rela
));
1259 symcount
= bfd_get_dynamic_symcount (abfd
);
1261 symcount
= bfd_get_symcount (abfd
);
1263 for (i
= 0, relent
= relents
;
1265 i
++, relent
++, native_relocs
+= entsize
)
1267 Elf_Internal_Rela rela
;
1269 if (entsize
== sizeof (Elf_External_Rela
))
1270 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1272 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1274 /* The address of an ELF reloc is section relative for an object
1275 file, and absolute for an executable file or shared library.
1276 The address of a normal BFD reloc is always section relative,
1277 and the address of a dynamic reloc is absolute.. */
1278 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1279 relent
->address
= rela
.r_offset
;
1281 relent
->address
= rela
.r_offset
- asect
->vma
;
1283 if (ELF_R_SYM (rela
.r_info
) == 0)
1284 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1285 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1287 (*_bfd_error_handler
)
1288 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1289 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1290 relent
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
1296 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1299 /* Canonicalize ELF section symbols. FIXME: Why? */
1300 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1301 relent
->sym_ptr_ptr
= ps
;
1303 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1306 relent
->addend
= rela
.r_addend
;
1308 if ((entsize
== sizeof (Elf_External_Rela
)
1309 && ebd
->elf_info_to_howto
!= NULL
)
1310 || ebd
->elf_info_to_howto_rel
== NULL
)
1311 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1313 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1316 if (allocated
!= NULL
)
1322 if (allocated
!= NULL
)
1327 /* Read in and swap the external relocs. */
1330 elf_slurp_reloc_table (bfd
*abfd
,
1333 bfd_boolean dynamic
)
1335 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1336 Elf_Internal_Shdr
*rel_hdr
;
1337 Elf_Internal_Shdr
*rel_hdr2
;
1338 bfd_size_type reloc_count
;
1339 bfd_size_type reloc_count2
;
1343 if (asect
->relocation
!= NULL
)
1348 if ((asect
->flags
& SEC_RELOC
) == 0
1349 || asect
->reloc_count
== 0)
1352 rel_hdr
= &d
->rel_hdr
;
1353 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1354 rel_hdr2
= d
->rel_hdr2
;
1355 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1357 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1358 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1359 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1364 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1365 case because relocations against this section may use the
1366 dynamic symbol table, and in that case bfd_section_from_shdr
1367 in elf.c does not update the RELOC_COUNT. */
1368 if (asect
->_raw_size
== 0)
1371 rel_hdr
= &d
->this_hdr
;
1372 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1377 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1378 relents
= bfd_alloc (abfd
, amt
);
1379 if (relents
== NULL
)
1382 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1383 rel_hdr
, reloc_count
,
1389 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1390 rel_hdr2
, reloc_count2
,
1391 relents
+ reloc_count
,
1395 asect
->relocation
= relents
;
1401 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1403 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1404 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1407 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1408 (long) hdr
->sh_name
,
1409 (long) hdr
->sh_type
,
1410 (long) hdr
->sh_flags
);
1412 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1413 (long) hdr
->sh_addr
,
1414 (long) hdr
->sh_offset
,
1415 (long) hdr
->sh_size
);
1417 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1418 (long) hdr
->sh_link
,
1419 (long) hdr
->sh_info
,
1420 (long) hdr
->sh_addralign
);
1421 fprintf (stderr
, "sh_entsize = %ld\n",
1422 (long) hdr
->sh_entsize
);
1427 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1429 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1430 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1431 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1432 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1433 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1434 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1435 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1439 elf_symbol_flags (flagword flags
)
1441 static char buffer
[1024];
1444 if (flags
& BSF_LOCAL
)
1445 strcat (buffer
, " local");
1447 if (flags
& BSF_GLOBAL
)
1448 strcat (buffer
, " global");
1450 if (flags
& BSF_DEBUGGING
)
1451 strcat (buffer
, " debug");
1453 if (flags
& BSF_FUNCTION
)
1454 strcat (buffer
, " function");
1456 if (flags
& BSF_KEEP
)
1457 strcat (buffer
, " keep");
1459 if (flags
& BSF_KEEP_G
)
1460 strcat (buffer
, " keep_g");
1462 if (flags
& BSF_WEAK
)
1463 strcat (buffer
, " weak");
1465 if (flags
& BSF_SECTION_SYM
)
1466 strcat (buffer
, " section-sym");
1468 if (flags
& BSF_OLD_COMMON
)
1469 strcat (buffer
, " old-common");
1471 if (flags
& BSF_NOT_AT_END
)
1472 strcat (buffer
, " not-at-end");
1474 if (flags
& BSF_CONSTRUCTOR
)
1475 strcat (buffer
, " constructor");
1477 if (flags
& BSF_WARNING
)
1478 strcat (buffer
, " warning");
1480 if (flags
& BSF_INDIRECT
)
1481 strcat (buffer
, " indirect");
1483 if (flags
& BSF_FILE
)
1484 strcat (buffer
, " file");
1486 if (flags
& DYNAMIC
)
1487 strcat (buffer
, " dynamic");
1489 if (flags
& ~(BSF_LOCAL
1504 strcat (buffer
, " unknown-bits");
1510 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1511 reconstruct an ELF file by reading the segments out of remote memory
1512 based on the ELF file header at EHDR_VMA and the ELF program headers it
1513 points to. If not null, *LOADBASEP is filled in with the difference
1514 between the VMAs from which the segments were read, and the VMAs the
1515 file headers (and hence BFD's idea of each section's VMA) put them at.
1517 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1518 remote memory at target address VMA into the local buffer at MYADDR; it
1519 should return zero on success or an `errno' code on failure. TEMPL must
1520 be a BFD for a target with the word size and byte order found in the
1524 NAME(_bfd_elf
,bfd_from_remote_memory
)
1528 int (*target_read_memory
) (bfd_vma
, char *, int))
1530 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1531 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1532 Elf_External_Phdr
*x_phdrs
;
1533 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1535 struct bfd_in_memory
*bim
;
1542 /* Read in the ELF header in external format. */
1543 err
= target_read_memory (ehdr_vma
, (char *) &x_ehdr
, sizeof x_ehdr
);
1546 bfd_set_error (bfd_error_system_call
);
1551 /* Now check to see if we have a valid ELF file, and one that BFD can
1552 make use of. The magic number must match, the address size ('class')
1553 and byte-swapping must match our XVEC entry. */
1555 if (! elf_file_p (&x_ehdr
)
1556 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1557 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1559 bfd_set_error (bfd_error_wrong_format
);
1563 /* Check that file's byte order matches xvec's */
1564 switch (x_ehdr
.e_ident
[EI_DATA
])
1566 case ELFDATA2MSB
: /* Big-endian */
1567 if (! bfd_header_big_endian (templ
))
1569 bfd_set_error (bfd_error_wrong_format
);
1573 case ELFDATA2LSB
: /* Little-endian */
1574 if (! bfd_header_little_endian (templ
))
1576 bfd_set_error (bfd_error_wrong_format
);
1580 case ELFDATANONE
: /* No data encoding specified */
1581 default: /* Unknown data encoding specified */
1582 bfd_set_error (bfd_error_wrong_format
);
1586 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1588 /* The file header tells where to find the program headers.
1589 These are what we use to actually choose what to read. */
1591 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1593 bfd_set_error (bfd_error_wrong_format
);
1597 x_phdrs
= bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1598 if (x_phdrs
== NULL
)
1600 bfd_set_error (bfd_error_no_memory
);
1603 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (char *) x_phdrs
,
1604 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1608 bfd_set_error (bfd_error_system_call
);
1612 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1616 loadbase
= ehdr_vma
;
1617 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1619 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1620 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1622 bfd_vma segment_end
;
1623 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1624 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1625 if (segment_end
> (bfd_vma
) contents_size
)
1626 contents_size
= segment_end
;
1628 if ((i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1629 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1631 last_phdr
= &i_phdrs
[i
];
1634 if (last_phdr
== NULL
)
1636 /* There were no PT_LOAD segments, so we don't have anything to read. */
1638 bfd_set_error (bfd_error_wrong_format
);
1642 /* Trim the last segment so we don't bother with zeros in the last page
1643 that are off the end of the file. However, if the extra bit in that
1644 page includes the section headers, keep them. */
1645 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1646 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1647 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1649 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1650 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1651 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1652 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1655 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1657 /* Now we know the size of the whole image we want read in. */
1658 contents
= bfd_zmalloc (contents_size
);
1659 if (contents
== NULL
)
1662 bfd_set_error (bfd_error_no_memory
);
1666 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1667 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1669 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1670 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1671 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1672 if (end
> (bfd_vma
) contents_size
)
1673 end
= contents_size
;
1674 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1675 & -i_phdrs
[i
].p_align
,
1676 contents
+ start
, end
- start
);
1681 bfd_set_error (bfd_error_system_call
);
1688 /* If the segments visible in memory didn't include the section headers,
1689 then clear them from the file header. */
1690 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1691 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1693 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1694 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1695 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1698 /* This will normally have been in the first PT_LOAD segment. But it
1699 conceivably could be missing, and we might have just changed it. */
1700 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1702 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1703 bim
= bfd_malloc (sizeof (struct bfd_in_memory
));
1707 bfd_set_error (bfd_error_no_memory
);
1710 nbfd
= _bfd_new_bfd ();
1715 bfd_set_error (bfd_error_no_memory
);
1718 nbfd
->filename
= "<in-memory>";
1719 nbfd
->xvec
= templ
->xvec
;
1720 bim
->size
= contents_size
;
1721 bim
->buffer
= contents
;
1722 nbfd
->iostream
= bim
;
1723 nbfd
->flags
= BFD_IN_MEMORY
;
1724 nbfd
->direction
= read_direction
;
1725 nbfd
->mtime
= time (NULL
);
1726 nbfd
->mtime_set
= TRUE
;
1729 *loadbasep
= loadbase
;
1733 #include "elfcore.h"
1734 #include "elflink.h"
1736 /* Size-dependent data and functions. */
1737 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1738 sizeof (Elf_External_Ehdr
),
1739 sizeof (Elf_External_Phdr
),
1740 sizeof (Elf_External_Shdr
),
1741 sizeof (Elf_External_Rel
),
1742 sizeof (Elf_External_Rela
),
1743 sizeof (Elf_External_Sym
),
1744 sizeof (Elf_External_Dyn
),
1745 sizeof (Elf_External_Note
),
1748 ARCH_SIZE
, LOG_FILE_ALIGN
,
1749 ELFCLASS
, EV_CURRENT
,
1750 elf_write_out_phdrs
,
1751 elf_write_shdrs_and_ehdr
,
1754 elf_swap_symbol_out
,
1755 elf_slurp_reloc_table
,
1756 elf_slurp_symbol_table
,