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_get_symtab NAME(bfd_elf,get_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_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
119 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
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)
124 #define elf_bfd_discard_info NAME(bfd_elf,discard_info)
125 #define elf_reloc_symbol_deleted_p NAME(_bfd_elf,reloc_symbol_deleted_p)
126 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
127 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
128 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
129 #define elf_gc_common_finalize_got_offsets \
130 NAME(_bfd_elf,gc_common_finalize_got_offsets)
131 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
132 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
133 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
134 #define elf_link_record_local_dynamic_symbol \
135 NAME(_bfd_elf,link_record_local_dynamic_symbol)
138 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
139 #define ELF_R_SYM(X) ELF64_R_SYM(X)
140 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
141 #define ELFCLASS ELFCLASS64
143 #define LOG_FILE_ALIGN 3
146 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
147 #define ELF_R_SYM(X) ELF32_R_SYM(X)
148 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
149 #define ELFCLASS ELFCLASS32
151 #define LOG_FILE_ALIGN 2
154 /* Static functions */
156 static void elf_swap_ehdr_in
157 PARAMS ((bfd
*, const Elf_External_Ehdr
*, Elf_Internal_Ehdr
*));
158 static void elf_swap_ehdr_out
159 PARAMS ((bfd
*, const Elf_Internal_Ehdr
*, Elf_External_Ehdr
*));
160 static void elf_swap_shdr_in
161 PARAMS ((bfd
*, const Elf_External_Shdr
*, Elf_Internal_Shdr
*));
162 static void elf_swap_shdr_out
163 PARAMS ((bfd
*, const Elf_Internal_Shdr
*, Elf_External_Shdr
*));
165 #define elf_stringtab_init _bfd_elf_stringtab_init
167 #define section_from_elf_index bfd_section_from_elf_index
169 static bfd_boolean elf_slurp_reloc_table_from_section
170 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, bfd_size_type
,
171 arelent
*, asymbol
**, bfd_boolean
));
173 static bfd_boolean elf_file_p
PARAMS ((Elf_External_Ehdr
*));
176 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
177 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
178 static char *elf_symbol_flags
PARAMS ((flagword
));
181 /* Structure swapping routines */
183 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
184 can be handled by explicitly specifying 32 bits or "the long type". */
186 #define H_PUT_WORD H_PUT_64
187 #define H_PUT_SIGNED_WORD H_PUT_S64
188 #define H_GET_WORD H_GET_64
189 #define H_GET_SIGNED_WORD H_GET_S64
192 #define H_PUT_WORD H_PUT_32
193 #define H_PUT_SIGNED_WORD H_PUT_S32
194 #define H_GET_WORD H_GET_32
195 #define H_GET_SIGNED_WORD H_GET_S32
198 /* Translate an ELF symbol in external format into an ELF symbol in internal
202 elf_swap_symbol_in (abfd
, psrc
, pshn
, dst
)
206 Elf_Internal_Sym
*dst
;
208 const Elf_External_Sym
*src
= (const Elf_External_Sym
*) psrc
;
209 const Elf_External_Sym_Shndx
*shndx
= (const Elf_External_Sym_Shndx
*) pshn
;
210 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
212 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
214 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
216 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
217 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
218 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
219 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
220 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
221 if (dst
->st_shndx
== SHN_XINDEX
)
225 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
229 /* Translate an ELF symbol in internal format into an ELF symbol in external
233 elf_swap_symbol_out (abfd
, src
, cdst
, shndx
)
235 const Elf_Internal_Sym
*src
;
240 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
241 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
242 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
243 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
244 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
245 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
247 if (tmp
> SHN_HIRESERVE
)
251 H_PUT_32 (abfd
, tmp
, shndx
);
254 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
257 /* Translate an ELF file header in external format into an ELF file header in
261 elf_swap_ehdr_in (abfd
, src
, dst
)
263 const Elf_External_Ehdr
*src
;
264 Elf_Internal_Ehdr
*dst
;
266 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
267 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
268 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
269 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
270 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
272 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
274 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
275 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
276 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
277 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
278 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
279 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
280 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
281 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
282 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
283 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
286 /* Translate an ELF file header in internal format into an ELF file header in
290 elf_swap_ehdr_out (abfd
, src
, dst
)
292 const Elf_Internal_Ehdr
*src
;
293 Elf_External_Ehdr
*dst
;
296 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
297 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
298 /* note that all elements of dst are *arrays of unsigned char* already... */
299 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
300 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
301 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
303 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
305 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
306 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
307 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
308 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
309 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
310 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
311 H_PUT_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
312 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
314 if (tmp
>= SHN_LORESERVE
)
316 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
317 tmp
= src
->e_shstrndx
;
318 if (tmp
>= SHN_LORESERVE
)
320 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
323 /* Translate an ELF section header table entry in external format into an
324 ELF section header table entry in internal format. */
327 elf_swap_shdr_in (abfd
, src
, dst
)
329 const Elf_External_Shdr
*src
;
330 Elf_Internal_Shdr
*dst
;
332 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
334 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
335 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
336 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
338 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
340 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
341 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
342 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
343 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
344 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
345 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
346 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
347 dst
->bfd_section
= NULL
;
348 dst
->contents
= NULL
;
351 /* Translate an ELF section header table entry in internal format into an
352 ELF section header table entry in external format. */
355 elf_swap_shdr_out (abfd
, src
, dst
)
357 const Elf_Internal_Shdr
*src
;
358 Elf_External_Shdr
*dst
;
360 /* note that all elements of dst are *arrays of unsigned char* already... */
361 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
362 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
363 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
364 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
365 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
366 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
367 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
368 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
369 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
370 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
373 /* Translate an ELF program header table entry in external format into an
374 ELF program header table entry in internal format. */
377 elf_swap_phdr_in (abfd
, src
, dst
)
379 const Elf_External_Phdr
*src
;
380 Elf_Internal_Phdr
*dst
;
382 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
384 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
385 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
386 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
389 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
390 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
394 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
395 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
397 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
398 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
399 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
403 elf_swap_phdr_out (abfd
, src
, dst
)
405 const Elf_Internal_Phdr
*src
;
406 Elf_External_Phdr
*dst
;
408 /* note that all elements of dst are *arrays of unsigned char* already... */
409 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
410 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
411 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
412 H_PUT_WORD (abfd
, src
->p_paddr
, dst
->p_paddr
);
413 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
414 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
415 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
416 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
419 /* Translate an ELF reloc from external format to internal format. */
421 elf_swap_reloc_in (abfd
, s
, dst
)
424 Elf_Internal_Rela
*dst
;
426 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
427 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
428 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
433 elf_swap_reloca_in (abfd
, s
, dst
)
436 Elf_Internal_Rela
*dst
;
438 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
439 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
440 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
441 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
444 /* Translate an ELF reloc from internal format to external format. */
446 elf_swap_reloc_out (abfd
, src
, d
)
448 const Elf_Internal_Rela
*src
;
451 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
452 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
453 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
457 elf_swap_reloca_out (abfd
, src
, d
)
459 const Elf_Internal_Rela
*src
;
462 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
463 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
464 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
465 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
469 elf_swap_dyn_in (abfd
, p
, dst
)
472 Elf_Internal_Dyn
*dst
;
474 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
476 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
477 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
481 elf_swap_dyn_out (abfd
, src
, p
)
483 const Elf_Internal_Dyn
*src
;
486 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
488 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
489 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
492 /* ELF .o/exec file reading */
494 /* Begin processing a given object.
496 First we validate the file by reading in the ELF header and checking
499 static INLINE bfd_boolean
501 Elf_External_Ehdr
*x_ehdrp
;
503 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
504 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
505 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
506 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
509 /* Check to see if the file associated with ABFD matches the target vector
512 Note that we may be called several times with the same ABFD, but different
513 target vectors, most of which will not match. We have to avoid leaving
514 any side effects in ABFD, or any data it points to (like tdata), if the
515 file does not match the target vector. */
521 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
522 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
523 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
524 Elf_Internal_Shdr i_shdr
;
525 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
526 unsigned int shindex
;
527 char *shstrtab
; /* Internal copy of section header stringtab */
528 struct elf_backend_data
*ebd
;
529 struct bfd_preserve preserve
;
533 preserve
.marker
= NULL
;
535 /* Read in the ELF header in external format. */
537 if (bfd_bread ((PTR
) & x_ehdr
, (bfd_size_type
) sizeof (x_ehdr
), abfd
)
540 if (bfd_get_error () != bfd_error_system_call
)
541 goto got_wrong_format_error
;
546 /* Now check to see if we have a valid ELF file, and one that BFD can
547 make use of. The magic number must match, the address size ('class')
548 and byte-swapping must match our XVEC entry, and it must have a
549 section header table (FIXME: See comments re sections at top of this
552 if (! elf_file_p (&x_ehdr
)
553 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
554 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
555 goto got_wrong_format_error
;
557 /* Check that file's byte order matches xvec's */
558 switch (x_ehdr
.e_ident
[EI_DATA
])
560 case ELFDATA2MSB
: /* Big-endian */
561 if (! bfd_header_big_endian (abfd
))
562 goto got_wrong_format_error
;
564 case ELFDATA2LSB
: /* Little-endian */
565 if (! bfd_header_little_endian (abfd
))
566 goto got_wrong_format_error
;
568 case ELFDATANONE
: /* No data encoding specified */
569 default: /* Unknown data encoding specified */
570 goto got_wrong_format_error
;
573 if (!bfd_preserve_save (abfd
, &preserve
))
576 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
577 the tdata pointer in the bfd. */
579 if (! (*abfd
->xvec
->_bfd_set_format
[bfd_object
]) (abfd
))
581 preserve
.marker
= elf_tdata (abfd
);
583 /* Now that we know the byte order, swap in the rest of the header */
584 i_ehdrp
= elf_elfheader (abfd
);
585 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
587 elf_debug_file (i_ehdrp
);
590 /* Reject ET_CORE (header indicates core file, not object file) */
591 if (i_ehdrp
->e_type
== ET_CORE
)
592 goto got_wrong_format_error
;
594 /* If this is a relocatable file and there is no section header
595 table, then we're hosed. */
596 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
597 goto got_wrong_format_error
;
599 /* As a simple sanity check, verify that the what BFD thinks is the
600 size of each section header table entry actually matches the size
601 recorded in the file, but only if there are any sections. */
602 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
603 goto got_wrong_format_error
;
605 /* Further sanity check. */
606 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
607 goto got_wrong_format_error
;
609 ebd
= get_elf_backend_data (abfd
);
611 /* Check that the ELF e_machine field matches what this particular
612 BFD format expects. */
613 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
614 && (ebd
->elf_machine_alt1
== 0
615 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
616 && (ebd
->elf_machine_alt2
== 0
617 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
619 const bfd_target
* const *target_ptr
;
621 if (ebd
->elf_machine_code
!= EM_NONE
)
622 goto got_wrong_format_error
;
624 /* This is the generic ELF target. Let it match any ELF target
625 for which we do not have a specific backend. */
626 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
628 struct elf_backend_data
*back
;
630 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
632 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
633 if (back
->elf_machine_code
== i_ehdrp
->e_machine
634 || (back
->elf_machine_alt1
!= 0
635 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
636 || (back
->elf_machine_alt2
!= 0
637 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
639 /* target_ptr is an ELF backend which matches this
640 object file, so reject the generic ELF target. */
641 goto got_wrong_format_error
;
646 if (i_ehdrp
->e_type
== ET_EXEC
)
647 abfd
->flags
|= EXEC_P
;
648 else if (i_ehdrp
->e_type
== ET_DYN
)
649 abfd
->flags
|= DYNAMIC
;
651 if (i_ehdrp
->e_phnum
> 0)
652 abfd
->flags
|= D_PAGED
;
654 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
656 /* It's OK if this fails for the generic target. */
657 if (ebd
->elf_machine_code
!= EM_NONE
)
661 /* Remember the entry point specified in the ELF file header. */
662 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
664 if (i_ehdrp
->e_shoff
!= 0)
666 /* Seek to the section header table in the file. */
667 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
670 /* Read the first section header at index 0, and convert to internal
672 if (bfd_bread ((PTR
) & x_shdr
, (bfd_size_type
) sizeof x_shdr
, abfd
)
675 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
677 /* If the section count is zero, the actual count is in the first
679 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
680 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
682 /* And similarly for the string table index. */
683 if (i_ehdrp
->e_shstrndx
== SHN_XINDEX
)
684 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
687 /* Allocate space for a copy of the section header table in
689 if (i_ehdrp
->e_shnum
!= 0)
691 Elf_Internal_Shdr
*shdrp
;
692 unsigned int num_sec
;
694 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
695 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
698 num_sec
= i_ehdrp
->e_shnum
;
699 if (num_sec
> SHN_LORESERVE
)
700 num_sec
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
701 elf_numsections (abfd
) = num_sec
;
702 amt
= sizeof (i_shdrp
) * num_sec
;
703 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
704 if (!elf_elfsections (abfd
))
707 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
710 if (num_sec
> SHN_LORESERVE
)
712 for ( ; shindex
< SHN_LORESERVE
; shindex
++)
713 elf_elfsections (abfd
)[shindex
] = shdrp
++;
714 for ( ; shindex
< SHN_HIRESERVE
+ 1; shindex
++)
715 elf_elfsections (abfd
)[shindex
] = i_shdrp
;
717 for ( ; shindex
< num_sec
; shindex
++)
718 elf_elfsections (abfd
)[shindex
] = shdrp
++;
720 /* Read in the rest of the section header table and convert it
722 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
724 if (bfd_bread ((PTR
) & x_shdr
, (bfd_size_type
) sizeof x_shdr
, abfd
)
727 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
729 /* If the section is loaded, but not page aligned, clear
731 if (i_shdrp
[shindex
].sh_size
!= 0
732 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
733 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
734 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
737 abfd
->flags
&= ~D_PAGED
;
741 if (i_ehdrp
->e_shstrndx
&& i_ehdrp
->e_shoff
)
743 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
747 /* Read in the program headers. */
748 if (i_ehdrp
->e_phnum
== 0)
749 elf_tdata (abfd
)->phdr
= NULL
;
752 Elf_Internal_Phdr
*i_phdr
;
755 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
756 elf_tdata (abfd
)->phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
757 if (elf_tdata (abfd
)->phdr
== NULL
)
759 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
761 i_phdr
= elf_tdata (abfd
)->phdr
;
762 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
764 Elf_External_Phdr x_phdr
;
766 if (bfd_bread ((PTR
) &x_phdr
, (bfd_size_type
) sizeof x_phdr
, abfd
)
769 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
773 /* Read in the string table containing the names of the sections. We
774 will need the base pointer to this table later. */
775 /* We read this inline now, so that we don't have to go through
776 bfd_section_from_shdr with it (since this particular strtab is
777 used to find all of the ELF section names.) */
779 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
)
781 unsigned int num_sec
;
783 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
787 /* Once all of the section headers have been read and converted, we
788 can start processing them. Note that the first section header is
789 a dummy placeholder entry, so we ignore it. */
790 num_sec
= elf_numsections (abfd
);
791 for (shindex
= 1; shindex
< num_sec
; shindex
++)
793 if (! bfd_section_from_shdr (abfd
, shindex
))
795 if (shindex
== SHN_LORESERVE
- 1)
796 shindex
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
800 /* Let the backend double check the format and override global
802 if (ebd
->elf_backend_object_p
)
804 if (! (*ebd
->elf_backend_object_p
) (abfd
))
805 goto got_wrong_format_error
;
808 /* If we have created any reloc sections that are associated with
809 debugging sections, mark the reloc sections as debugging as well. */
810 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
812 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
813 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
814 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
816 unsigned long targ_index
;
819 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
820 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
822 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
823 s
->flags
|= SEC_DEBUGGING
;
827 bfd_preserve_finish (abfd
, &preserve
);
830 got_wrong_format_error
:
831 /* There is way too much undoing of half-known state here. The caller,
832 bfd_check_format_matches, really shouldn't iterate on live bfd's to
833 check match/no-match like it does. We have to rely on that a call to
834 bfd_default_set_arch_mach with the previously known mach, undoes what
835 was done by the first bfd_default_set_arch_mach (with mach 0) here.
836 For this to work, only elf-data and the mach may be changed by the
837 target-specific elf_backend_object_p function. Note that saving the
838 whole bfd here and restoring it would be even worse; the first thing
839 you notice is that the cached bfd file position gets out of sync. */
840 bfd_set_error (bfd_error_wrong_format
);
843 if (preserve
.marker
!= NULL
)
844 bfd_preserve_restore (abfd
, &preserve
);
848 /* ELF .o/exec file writing */
850 /* Write out the relocs. */
853 elf_write_relocs (abfd
, sec
, data
)
858 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
859 Elf_Internal_Shdr
*rela_hdr
;
861 void (*swap_out
) PARAMS ((bfd
*, const Elf_Internal_Rela
*, bfd_byte
*));
868 /* If we have already failed, don't do anything. */
872 if ((sec
->flags
& SEC_RELOC
) == 0)
875 /* The linker backend writes the relocs out itself, and sets the
876 reloc_count field to zero to inhibit writing them here. Also,
877 sometimes the SEC_RELOC flag gets set even when there aren't any
879 if (sec
->reloc_count
== 0)
882 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
884 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
885 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
886 if (rela_hdr
->contents
== NULL
)
892 /* Figure out whether the relocations are RELA or REL relocations. */
893 if (rela_hdr
->sh_type
== SHT_RELA
)
895 swap_out
= elf_swap_reloca_out
;
896 extsize
= sizeof (Elf_External_Rela
);
898 else if (rela_hdr
->sh_type
== SHT_REL
)
900 swap_out
= elf_swap_reloc_out
;
901 extsize
= sizeof (Elf_External_Rel
);
904 /* Every relocation section should be either an SHT_RELA or an
908 /* The address of an ELF reloc is section relative for an object
909 file, and absolute for an executable file or shared library.
910 The address of a BFD reloc is always section relative. */
912 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
913 addr_offset
= sec
->vma
;
915 /* orelocation has the data, reloc_count has the count... */
918 dst_rela
= rela_hdr
->contents
;
920 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
922 Elf_Internal_Rela src_rela
;
927 ptr
= sec
->orelocation
[idx
];
928 sym
= *ptr
->sym_ptr_ptr
;
931 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
936 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
945 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
946 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
947 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
953 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
954 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
955 src_rela
.r_addend
= ptr
->addend
;
956 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
960 /* Write out the program headers. */
963 elf_write_out_phdrs (abfd
, phdr
, count
)
965 const Elf_Internal_Phdr
*phdr
;
970 Elf_External_Phdr extphdr
;
971 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
972 if (bfd_bwrite (&extphdr
, (bfd_size_type
) sizeof (Elf_External_Phdr
),
973 abfd
) != sizeof (Elf_External_Phdr
))
980 /* Write out the section headers and the ELF file header. */
983 elf_write_shdrs_and_ehdr (abfd
)
986 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
987 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
988 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
989 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
993 i_ehdrp
= elf_elfheader (abfd
);
994 i_shdrp
= elf_elfsections (abfd
);
996 /* swap the header before spitting it out... */
999 elf_debug_file (i_ehdrp
);
1001 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1002 amt
= sizeof (x_ehdr
);
1003 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1004 || bfd_bwrite ((PTR
) & x_ehdr
, amt
, abfd
) != amt
)
1007 /* Some fields in the first section header handle overflow of ehdr
1009 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
)
1010 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1011 if (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
)
1012 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1014 /* at this point we've concocted all the ELF sections... */
1015 amt
= i_ehdrp
->e_shnum
;
1016 amt
*= sizeof (*x_shdrp
);
1017 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1021 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1024 elf_debug_section (count
, *i_shdrp
);
1026 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1028 if (count
== SHN_LORESERVE
- 1)
1029 i_shdrp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
1031 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1032 || bfd_bwrite ((PTR
) x_shdrp
, amt
, abfd
) != amt
)
1035 /* need to dump the string table too... */
1041 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
1043 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
1044 bfd_boolean dynamic
;
1046 Elf_Internal_Shdr
*hdr
;
1047 Elf_Internal_Shdr
*verhdr
;
1048 unsigned long symcount
; /* Number of external ELF symbols */
1049 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1050 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1051 Elf_Internal_Sym
*isym
;
1052 Elf_Internal_Sym
*isymend
;
1053 Elf_Internal_Sym
*isymbuf
= NULL
;
1054 Elf_External_Versym
*xver
;
1055 Elf_External_Versym
*xverbuf
= NULL
;
1056 struct elf_backend_data
*ebd
;
1059 /* Read each raw ELF symbol, converting from external ELF form to
1060 internal ELF form, and then using the information to create a
1061 canonical bfd symbol table entry.
1063 Note that we allocate the initial bfd canonical symbol buffer
1064 based on a one-to-one mapping of the ELF symbols to canonical
1065 symbols. We actually use all the ELF symbols, so there will be no
1066 space left over at the end. When we have all the symbols, we
1067 build the caller's pointer vector. */
1071 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1076 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1077 if (elf_dynversym (abfd
) == 0)
1080 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1081 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1082 && elf_tdata (abfd
)->verdef
== NULL
)
1083 || (elf_tdata (abfd
)->dynverref_section
!= 0
1084 && elf_tdata (abfd
)->verref
== NULL
))
1086 if (! _bfd_elf_slurp_version_tables (abfd
))
1091 ebd
= get_elf_backend_data (abfd
);
1092 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1094 sym
= symbase
= NULL
;
1097 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1099 if (isymbuf
== NULL
)
1103 amt
*= sizeof (elf_symbol_type
);
1104 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1105 if (symbase
== (elf_symbol_type
*) NULL
)
1108 /* Read the raw ELF version symbol information. */
1110 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1112 (*_bfd_error_handler
)
1113 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1115 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1118 /* Slurp in the symbols without the version information,
1119 since that is more helpful than just quitting. */
1125 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1128 xverbuf
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1129 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1132 if (bfd_bread ((PTR
) xverbuf
, verhdr
->sh_size
, abfd
)
1137 /* Skip first symbol, which is a null dummy. */
1141 isymend
= isymbuf
+ symcount
;
1142 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1144 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1145 sym
->symbol
.the_bfd
= abfd
;
1147 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
1151 sym
->symbol
.value
= isym
->st_value
;
1153 if (isym
->st_shndx
== SHN_UNDEF
)
1155 sym
->symbol
.section
= bfd_und_section_ptr
;
1157 else if (isym
->st_shndx
< SHN_LORESERVE
1158 || isym
->st_shndx
> SHN_HIRESERVE
)
1160 sym
->symbol
.section
= section_from_elf_index (abfd
,
1162 if (sym
->symbol
.section
== NULL
)
1164 /* This symbol is in a section for which we did not
1165 create a BFD section. Just use bfd_abs_section,
1166 although it is wrong. FIXME. */
1167 sym
->symbol
.section
= bfd_abs_section_ptr
;
1170 else if (isym
->st_shndx
== SHN_ABS
)
1172 sym
->symbol
.section
= bfd_abs_section_ptr
;
1174 else if (isym
->st_shndx
== SHN_COMMON
)
1176 sym
->symbol
.section
= bfd_com_section_ptr
;
1177 /* Elf puts the alignment into the `value' field, and
1178 the size into the `size' field. BFD wants to see the
1179 size in the value field, and doesn't care (at the
1180 moment) about the alignment. */
1181 sym
->symbol
.value
= isym
->st_size
;
1184 sym
->symbol
.section
= bfd_abs_section_ptr
;
1186 /* If this is a relocatable file, then the symbol value is
1187 already section relative. */
1188 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1189 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1191 switch (ELF_ST_BIND (isym
->st_info
))
1194 sym
->symbol
.flags
|= BSF_LOCAL
;
1197 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1198 sym
->symbol
.flags
|= BSF_GLOBAL
;
1201 sym
->symbol
.flags
|= BSF_WEAK
;
1205 switch (ELF_ST_TYPE (isym
->st_info
))
1208 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1211 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1214 sym
->symbol
.flags
|= BSF_FUNCTION
;
1217 sym
->symbol
.flags
|= BSF_OBJECT
;
1222 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1226 Elf_Internal_Versym iversym
;
1228 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1229 sym
->version
= iversym
.vs_vers
;
1233 /* Do some backend-specific processing on this symbol. */
1234 if (ebd
->elf_backend_symbol_processing
)
1235 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1239 /* Do some backend-specific processing on this symbol table. */
1240 if (ebd
->elf_backend_symbol_table_processing
)
1241 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1243 /* We rely on the zalloc to clear out the final symbol entry. */
1245 symcount
= sym
- symbase
;
1247 /* Fill in the user's symbol pointer vector if needed. */
1255 *symptrs
++ = &sym
->symbol
;
1258 *symptrs
= 0; /* Final null pointer */
1261 if (xverbuf
!= NULL
)
1263 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1268 if (xverbuf
!= NULL
)
1270 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1275 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1279 elf_slurp_reloc_table_from_section (abfd
, asect
, rel_hdr
, reloc_count
,
1280 relents
, symbols
, dynamic
)
1283 Elf_Internal_Shdr
*rel_hdr
;
1284 bfd_size_type reloc_count
;
1287 bfd_boolean dynamic
;
1289 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1290 PTR allocated
= NULL
;
1291 bfd_byte
*native_relocs
;
1295 unsigned int symcount
;
1297 allocated
= (PTR
) bfd_malloc (rel_hdr
->sh_size
);
1298 if (allocated
== NULL
)
1301 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1302 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1303 != rel_hdr
->sh_size
))
1306 native_relocs
= (bfd_byte
*) allocated
;
1308 entsize
= rel_hdr
->sh_entsize
;
1309 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1310 || entsize
== sizeof (Elf_External_Rela
));
1313 symcount
= bfd_get_dynamic_symcount (abfd
);
1315 symcount
= bfd_get_symcount (abfd
);
1317 for (i
= 0, relent
= relents
;
1319 i
++, relent
++, native_relocs
+= entsize
)
1321 Elf_Internal_Rela rela
;
1323 if (entsize
== sizeof (Elf_External_Rela
))
1324 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1326 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1328 /* The address of an ELF reloc is section relative for an object
1329 file, and absolute for an executable file or shared library.
1330 The address of a normal BFD reloc is always section relative,
1331 and the address of a dynamic reloc is absolute.. */
1332 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1333 relent
->address
= rela
.r_offset
;
1335 relent
->address
= rela
.r_offset
- asect
->vma
;
1337 if (ELF_R_SYM (rela
.r_info
) == 0)
1338 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1339 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1341 (*_bfd_error_handler
)
1342 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1343 abfd
->filename
, asect
->name
, i
, ELF_R_SYM (rela
.r_info
));
1344 relent
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
1350 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1353 /* Canonicalize ELF section symbols. FIXME: Why? */
1354 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1355 relent
->sym_ptr_ptr
= ps
;
1357 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1360 relent
->addend
= rela
.r_addend
;
1362 if ((entsize
== sizeof (Elf_External_Rela
)
1363 && ebd
->elf_info_to_howto
!= NULL
)
1364 || ebd
->elf_info_to_howto_rel
== NULL
)
1365 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1367 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rela
);
1370 if (allocated
!= NULL
)
1376 if (allocated
!= NULL
)
1381 /* Read in and swap the external relocs. */
1384 elf_slurp_reloc_table (abfd
, asect
, symbols
, dynamic
)
1388 bfd_boolean dynamic
;
1390 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1391 Elf_Internal_Shdr
*rel_hdr
;
1392 Elf_Internal_Shdr
*rel_hdr2
;
1393 bfd_size_type reloc_count
;
1394 bfd_size_type reloc_count2
;
1398 if (asect
->relocation
!= NULL
)
1403 if ((asect
->flags
& SEC_RELOC
) == 0
1404 || asect
->reloc_count
== 0)
1407 rel_hdr
= &d
->rel_hdr
;
1408 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1409 rel_hdr2
= d
->rel_hdr2
;
1410 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1412 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1413 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1414 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1419 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1420 case because relocations against this section may use the
1421 dynamic symbol table, and in that case bfd_section_from_shdr
1422 in elf.c does not update the RELOC_COUNT. */
1423 if (asect
->_raw_size
== 0)
1426 rel_hdr
= &d
->this_hdr
;
1427 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1432 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1433 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1434 if (relents
== NULL
)
1437 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1438 rel_hdr
, reloc_count
,
1444 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1445 rel_hdr2
, reloc_count2
,
1446 relents
+ reloc_count
,
1450 asect
->relocation
= relents
;
1456 elf_debug_section (num
, hdr
)
1458 Elf_Internal_Shdr
*hdr
;
1460 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1461 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1464 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1465 (long) hdr
->sh_name
,
1466 (long) hdr
->sh_type
,
1467 (long) hdr
->sh_flags
);
1469 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1470 (long) hdr
->sh_addr
,
1471 (long) hdr
->sh_offset
,
1472 (long) hdr
->sh_size
);
1474 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1475 (long) hdr
->sh_link
,
1476 (long) hdr
->sh_info
,
1477 (long) hdr
->sh_addralign
);
1478 fprintf (stderr
, "sh_entsize = %ld\n",
1479 (long) hdr
->sh_entsize
);
1484 elf_debug_file (ehdrp
)
1485 Elf_Internal_Ehdr
*ehdrp
;
1487 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1488 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1489 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1490 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1491 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1492 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1493 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1497 elf_symbol_flags (flags
)
1500 static char buffer
[1024];
1503 if (flags
& BSF_LOCAL
)
1504 strcat (buffer
, " local");
1506 if (flags
& BSF_GLOBAL
)
1507 strcat (buffer
, " global");
1509 if (flags
& BSF_DEBUGGING
)
1510 strcat (buffer
, " debug");
1512 if (flags
& BSF_FUNCTION
)
1513 strcat (buffer
, " function");
1515 if (flags
& BSF_KEEP
)
1516 strcat (buffer
, " keep");
1518 if (flags
& BSF_KEEP_G
)
1519 strcat (buffer
, " keep_g");
1521 if (flags
& BSF_WEAK
)
1522 strcat (buffer
, " weak");
1524 if (flags
& BSF_SECTION_SYM
)
1525 strcat (buffer
, " section-sym");
1527 if (flags
& BSF_OLD_COMMON
)
1528 strcat (buffer
, " old-common");
1530 if (flags
& BSF_NOT_AT_END
)
1531 strcat (buffer
, " not-at-end");
1533 if (flags
& BSF_CONSTRUCTOR
)
1534 strcat (buffer
, " constructor");
1536 if (flags
& BSF_WARNING
)
1537 strcat (buffer
, " warning");
1539 if (flags
& BSF_INDIRECT
)
1540 strcat (buffer
, " indirect");
1542 if (flags
& BSF_FILE
)
1543 strcat (buffer
, " file");
1545 if (flags
& DYNAMIC
)
1546 strcat (buffer
, " dynamic");
1548 if (flags
& ~(BSF_LOCAL
1563 strcat (buffer
, " unknown-bits");
1569 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1570 reconstruct an ELF file by reading the segments out of remote memory
1571 based on the ELF file header at EHDR_VMA and the ELF program headers it
1572 points to. If not null, *LOADBASEP is filled in with the difference
1573 between the VMAs from which the segments were read, and the VMAs the
1574 file headers (and hence BFD's idea of each section's VMA) put them at.
1576 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1577 remote memory at target address VMA into the local buffer at MYADDR; it
1578 should return zero on success or an `errno' code on failure. TEMPL must
1579 be a BFD for a target with the word size and byte order found in the
1583 NAME(_bfd_elf
,bfd_from_remote_memory
) (templ
, ehdr_vma
, loadbasep
,
1588 int (*target_read_memory
) PARAMS ((bfd_vma vma
, char *myaddr
, int len
));
1590 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1591 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1592 Elf_External_Phdr
*x_phdrs
;
1593 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
;
1595 struct bfd_in_memory
*bim
;
1602 /* Read in the ELF header in external format. */
1603 err
= target_read_memory (ehdr_vma
, (char *) &x_ehdr
, sizeof x_ehdr
);
1606 bfd_set_error (bfd_error_system_call
);
1611 /* Now check to see if we have a valid ELF file, and one that BFD can
1612 make use of. The magic number must match, the address size ('class')
1613 and byte-swapping must match our XVEC entry. */
1615 if (! elf_file_p (&x_ehdr
)
1616 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1617 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1619 bfd_set_error (bfd_error_wrong_format
);
1623 /* Check that file's byte order matches xvec's */
1624 switch (x_ehdr
.e_ident
[EI_DATA
])
1626 case ELFDATA2MSB
: /* Big-endian */
1627 if (! bfd_header_big_endian (templ
))
1629 bfd_set_error (bfd_error_wrong_format
);
1633 case ELFDATA2LSB
: /* Little-endian */
1634 if (! bfd_header_little_endian (templ
))
1636 bfd_set_error (bfd_error_wrong_format
);
1640 case ELFDATANONE
: /* No data encoding specified */
1641 default: /* Unknown data encoding specified */
1642 bfd_set_error (bfd_error_wrong_format
);
1646 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1648 /* The file header tells where to find the program headers.
1649 These are what we use to actually choose what to read. */
1651 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1653 bfd_set_error (bfd_error_wrong_format
);
1657 x_phdrs
= (Elf_External_Phdr
*)
1658 bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1659 if (x_phdrs
== NULL
)
1661 bfd_set_error (bfd_error_no_memory
);
1664 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (char *) x_phdrs
,
1665 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1669 bfd_set_error (bfd_error_system_call
);
1673 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1677 loadbase
= ehdr_vma
;
1678 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1680 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1681 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1683 bfd_vma segment_end
;
1684 segment_end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1685 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1686 if (segment_end
> (bfd_vma
) contents_size
)
1687 contents_size
= segment_end
;
1689 if ((i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
) == 0)
1690 loadbase
= ehdr_vma
- (i_phdrs
[i
].p_vaddr
& -i_phdrs
[i
].p_align
);
1692 last_phdr
= &i_phdrs
[i
];
1695 if (last_phdr
== NULL
)
1697 /* There were no PT_LOAD segments, so we don't have anything to read. */
1699 bfd_set_error (bfd_error_wrong_format
);
1703 /* Trim the last segment so we don't bother with zeros in the last page
1704 that are off the end of the file. However, if the extra bit in that
1705 page includes the section headers, keep them. */
1706 if ((bfd_vma
) contents_size
> last_phdr
->p_offset
+ last_phdr
->p_filesz
1707 && (bfd_vma
) contents_size
>= (i_ehdr
.e_shoff
1708 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1710 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1711 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1712 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1713 contents_size
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1716 contents_size
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1718 /* Now we know the size of the whole image we want read in. */
1719 contents
= (char *) bfd_zmalloc ((bfd_size_type
) contents_size
);
1720 if (contents
== NULL
)
1723 bfd_set_error (bfd_error_no_memory
);
1727 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1728 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1730 bfd_vma start
= i_phdrs
[i
].p_offset
& -i_phdrs
[i
].p_align
;
1731 bfd_vma end
= (i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
1732 + i_phdrs
[i
].p_align
- 1) & -i_phdrs
[i
].p_align
;
1733 if (end
> (bfd_vma
) contents_size
)
1734 end
= contents_size
;
1735 err
= target_read_memory ((loadbase
+ i_phdrs
[i
].p_vaddr
)
1736 & -i_phdrs
[i
].p_align
,
1737 contents
+ start
, end
- start
);
1742 bfd_set_error (bfd_error_system_call
);
1749 /* If the segments visible in memory didn't include the section headers,
1750 then clear them from the file header. */
1751 if ((bfd_vma
) contents_size
< (i_ehdr
.e_shoff
1752 + i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
))
1754 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1755 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1756 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1759 /* This will normally have been in the first PT_LOAD segment. But it
1760 conceivably could be missing, and we might have just changed it. */
1761 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1763 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1764 bim
= ((struct bfd_in_memory
*)
1765 bfd_malloc ((bfd_size_type
) sizeof (struct bfd_in_memory
)));
1769 bfd_set_error (bfd_error_no_memory
);
1772 nbfd
= _bfd_new_bfd ();
1777 bfd_set_error (bfd_error_no_memory
);
1780 nbfd
->filename
= "<in-memory>";
1781 nbfd
->xvec
= templ
->xvec
;
1782 bim
->size
= contents_size
;
1783 bim
->buffer
= contents
;
1784 nbfd
->iostream
= (PTR
) bim
;
1785 nbfd
->flags
= BFD_IN_MEMORY
;
1786 nbfd
->direction
= read_direction
;
1787 nbfd
->mtime
= time (NULL
);
1788 nbfd
->mtime_set
= TRUE
;
1791 *loadbasep
= loadbase
;
1795 #include "elfcore.h"
1796 #include "elflink.h"
1798 /* Size-dependent data and functions. */
1799 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1800 sizeof (Elf_External_Ehdr
),
1801 sizeof (Elf_External_Phdr
),
1802 sizeof (Elf_External_Shdr
),
1803 sizeof (Elf_External_Rel
),
1804 sizeof (Elf_External_Rela
),
1805 sizeof (Elf_External_Sym
),
1806 sizeof (Elf_External_Dyn
),
1807 sizeof (Elf_External_Note
),
1810 ARCH_SIZE
, LOG_FILE_ALIGN
,
1811 ELFCLASS
, EV_CURRENT
,
1812 elf_write_out_phdrs
,
1813 elf_write_shdrs_and_ehdr
,
1816 elf_swap_symbol_out
,
1817 elf_slurp_reloc_table
,
1818 elf_slurp_symbol_table
,