1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001 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_link_create_dynamic_sections \
125 NAME(bfd_elf,link_create_dynamic_sections)
126 #define elf_bfd_discard_info NAME(bfd_elf,discard_info)
127 #define elf_reloc_symbol_deleted_p NAME(_bfd_elf,reloc_symbol_deleted_p)
128 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
129 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
130 #define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
131 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
132 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
133 #define elf_gc_common_finalize_got_offsets \
134 NAME(_bfd_elf,gc_common_finalize_got_offsets)
135 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
136 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
137 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
138 #define elf_link_record_local_dynamic_symbol \
139 NAME(_bfd_elf,link_record_local_dynamic_symbol)
142 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
143 #define ELF_R_SYM(X) ELF64_R_SYM(X)
144 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
145 #define ELFCLASS ELFCLASS64
147 #define LOG_FILE_ALIGN 3
150 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
151 #define ELF_R_SYM(X) ELF32_R_SYM(X)
152 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
153 #define ELFCLASS ELFCLASS32
155 #define LOG_FILE_ALIGN 2
158 /* Static functions */
160 static void elf_swap_ehdr_in
161 PARAMS ((bfd
*, const Elf_External_Ehdr
*, Elf_Internal_Ehdr
*));
162 static void elf_swap_ehdr_out
163 PARAMS ((bfd
*, const Elf_Internal_Ehdr
*, Elf_External_Ehdr
*));
164 static void elf_swap_shdr_in
165 PARAMS ((bfd
*, const Elf_External_Shdr
*, Elf_Internal_Shdr
*));
166 static void elf_swap_shdr_out
167 PARAMS ((bfd
*, const Elf_Internal_Shdr
*, Elf_External_Shdr
*));
169 #define elf_stringtab_init _bfd_elf_stringtab_init
171 #define section_from_elf_index bfd_section_from_elf_index
173 static boolean elf_slurp_reloc_table_from_section
174 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, bfd_size_type
,
175 arelent
*, asymbol
**, boolean
));
177 static boolean elf_file_p
PARAMS ((Elf_External_Ehdr
*));
180 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
181 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
182 static char *elf_symbol_flags
PARAMS ((flagword
));
185 /* Structure swapping routines */
187 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
188 can be handled by explicitly specifying 32 bits or "the long type". */
190 #define H_PUT_WORD H_PUT_64
191 #define H_PUT_SIGNED_WORD H_PUT_S64
192 #define H_GET_WORD H_GET_64
193 #define H_GET_SIGNED_WORD H_GET_S64
196 #define H_PUT_WORD H_PUT_32
197 #define H_PUT_SIGNED_WORD H_PUT_S32
198 #define H_GET_WORD H_GET_32
199 #define H_GET_SIGNED_WORD H_GET_S32
202 /* Translate an ELF symbol in external format into an ELF symbol in internal
206 elf_swap_symbol_in (abfd
, src
, shndx
, dst
)
208 const Elf_External_Sym
*src
;
209 const Elf_External_Sym_Shndx
*shndx
;
210 Elf_Internal_Sym
*dst
;
212 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
214 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
216 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
218 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
219 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
220 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
221 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
222 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
223 if (dst
->st_shndx
== SHN_XINDEX
)
227 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
231 /* Translate an ELF symbol in internal format into an ELF symbol in external
235 elf_swap_symbol_out (abfd
, src
, cdst
, shndx
)
237 const Elf_Internal_Sym
*src
;
242 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
243 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
244 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
245 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
246 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
247 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
249 if (tmp
> SHN_HIRESERVE
)
253 H_PUT_32 (abfd
, tmp
, shndx
);
256 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
259 /* Translate an ELF file header in external format into an ELF file header in
263 elf_swap_ehdr_in (abfd
, src
, dst
)
265 const Elf_External_Ehdr
*src
;
266 Elf_Internal_Ehdr
*dst
;
268 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
269 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
270 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
271 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
272 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
274 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
276 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
277 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
278 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
279 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
280 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
281 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
282 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
283 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
284 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
285 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
288 /* Translate an ELF file header in internal format into an ELF file header in
292 elf_swap_ehdr_out (abfd
, src
, dst
)
294 const Elf_Internal_Ehdr
*src
;
295 Elf_External_Ehdr
*dst
;
298 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
299 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
300 /* note that all elements of dst are *arrays of unsigned char* already... */
301 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
302 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
303 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
305 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
307 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
308 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
309 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
310 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
311 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
312 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
313 H_PUT_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
314 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
316 if (tmp
>= SHN_LORESERVE
)
318 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
319 tmp
= src
->e_shstrndx
;
320 if (tmp
>= SHN_LORESERVE
)
322 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
325 /* Translate an ELF section header table entry in external format into an
326 ELF section header table entry in internal format. */
329 elf_swap_shdr_in (abfd
, src
, dst
)
331 const Elf_External_Shdr
*src
;
332 Elf_Internal_Shdr
*dst
;
334 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
336 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
337 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
338 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
340 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
342 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
343 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
344 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
345 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
346 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
347 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
348 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
349 dst
->bfd_section
= NULL
;
350 dst
->contents
= NULL
;
353 /* Translate an ELF section header table entry in internal format into an
354 ELF section header table entry in external format. */
357 elf_swap_shdr_out (abfd
, src
, dst
)
359 const Elf_Internal_Shdr
*src
;
360 Elf_External_Shdr
*dst
;
362 /* note that all elements of dst are *arrays of unsigned char* already... */
363 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
364 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
365 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
366 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
367 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
368 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
369 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
370 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
371 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
372 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
375 /* Translate an ELF program header table entry in external format into an
376 ELF program header table entry in internal format. */
379 elf_swap_phdr_in (abfd
, src
, dst
)
381 const Elf_External_Phdr
*src
;
382 Elf_Internal_Phdr
*dst
;
384 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
386 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
387 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
388 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
391 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
392 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
396 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
397 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
399 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
400 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
401 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
405 elf_swap_phdr_out (abfd
, src
, dst
)
407 const Elf_Internal_Phdr
*src
;
408 Elf_External_Phdr
*dst
;
410 /* note that all elements of dst are *arrays of unsigned char* already... */
411 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
412 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
413 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
414 H_PUT_WORD (abfd
, src
->p_paddr
, dst
->p_paddr
);
415 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
416 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
417 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
418 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
421 /* Translate an ELF reloc from external format to internal format. */
423 elf_swap_reloc_in (abfd
, src
, dst
)
425 const Elf_External_Rel
*src
;
426 Elf_Internal_Rel
*dst
;
428 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
429 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
433 elf_swap_reloca_in (abfd
, src
, dst
)
435 const Elf_External_Rela
*src
;
436 Elf_Internal_Rela
*dst
;
438 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
439 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
440 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
443 /* Translate an ELF reloc from internal format to external format. */
445 elf_swap_reloc_out (abfd
, src
, dst
)
447 const Elf_Internal_Rel
*src
;
448 Elf_External_Rel
*dst
;
450 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
451 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
455 elf_swap_reloca_out (abfd
, src
, dst
)
457 const Elf_Internal_Rela
*src
;
458 Elf_External_Rela
*dst
;
460 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
461 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
462 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
466 elf_swap_dyn_in (abfd
, p
, dst
)
469 Elf_Internal_Dyn
*dst
;
471 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
473 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
474 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
478 elf_swap_dyn_out (abfd
, src
, p
)
480 const Elf_Internal_Dyn
*src
;
483 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
485 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
486 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
489 /* ELF .o/exec file reading */
491 /* Begin processing a given object.
493 First we validate the file by reading in the ELF header and checking
496 static INLINE boolean
498 Elf_External_Ehdr
*x_ehdrp
;
500 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
501 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
502 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
503 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
508 const struct bfd_arch_info
*arch_info
;
509 struct elf_obj_tdata
*tdata
;
510 struct bfd_hash_table section_htab
;
511 struct sec
*sections
;
512 struct sec
**section_tail
;
513 unsigned int section_count
;
516 /* Check to see if the file associated with ABFD matches the target vector
519 Note that we may be called several times with the same ABFD, but different
520 target vectors, most of which will not match. We have to avoid leaving
521 any side effects in ABFD, or any data it points to (like tdata), if the
522 file does not match the target vector. */
528 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
529 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
530 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
531 Elf_Internal_Shdr i_shdr
;
532 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
533 unsigned int shindex
;
534 char *shstrtab
; /* Internal copy of section header stringtab */
535 struct elf_backend_data
*ebd
;
536 struct bfd_preserve preserve
;
537 struct elf_obj_tdata
*new_tdata
= NULL
;
541 preserve
.arch_info
= abfd
->arch_info
;
543 /* Read in the ELF header in external format. */
545 if (bfd_bread ((PTR
) & x_ehdr
, (bfd_size_type
) sizeof (x_ehdr
), abfd
)
548 if (bfd_get_error () != bfd_error_system_call
)
549 goto got_wrong_format_error
;
554 /* Now check to see if we have a valid ELF file, and one that BFD can
555 make use of. The magic number must match, the address size ('class')
556 and byte-swapping must match our XVEC entry, and it must have a
557 section header table (FIXME: See comments re sections at top of this
560 if ((elf_file_p (&x_ehdr
) == false) ||
561 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
562 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
563 goto got_wrong_format_error
;
565 /* Check that file's byte order matches xvec's */
566 switch (x_ehdr
.e_ident
[EI_DATA
])
568 case ELFDATA2MSB
: /* Big-endian */
569 if (! bfd_header_big_endian (abfd
))
570 goto got_wrong_format_error
;
572 case ELFDATA2LSB
: /* Little-endian */
573 if (! bfd_header_little_endian (abfd
))
574 goto got_wrong_format_error
;
576 case ELFDATANONE
: /* No data encoding specified */
577 default: /* Unknown data encoding specified */
578 goto got_wrong_format_error
;
581 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
582 the tdata pointer in the bfd. */
584 amt
= sizeof (struct elf_obj_tdata
);
585 new_tdata
= (struct elf_obj_tdata
*) bfd_zalloc (abfd
, amt
);
586 if (new_tdata
== NULL
)
588 preserve
.tdata
= elf_tdata (abfd
);
589 elf_tdata (abfd
) = new_tdata
;
591 /* Clear section information, since there might be a recognized bfd that
592 we now check if we can replace, and we don't want to append to it. */
593 preserve
.sections
= abfd
->sections
;
594 preserve
.section_tail
= abfd
->section_tail
;
595 preserve
.section_count
= abfd
->section_count
;
596 preserve
.section_htab
= abfd
->section_htab
;
597 abfd
->sections
= NULL
;
598 abfd
->section_tail
= &abfd
->sections
;
599 abfd
->section_count
= 0;
600 if (!bfd_hash_table_init (&abfd
->section_htab
, bfd_section_hash_newfunc
))
603 /* Now that we know the byte order, swap in the rest of the header */
604 i_ehdrp
= elf_elfheader (abfd
);
605 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
607 elf_debug_file (i_ehdrp
);
610 /* Reject ET_CORE (header indicates core file, not object file) */
611 if (i_ehdrp
->e_type
== ET_CORE
)
612 goto got_wrong_format_error
;
614 /* If this is a relocatable file and there is no section header
615 table, then we're hosed. */
616 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
617 goto got_wrong_format_error
;
619 /* As a simple sanity check, verify that the what BFD thinks is the
620 size of each section header table entry actually matches the size
621 recorded in the file, but only if there are any sections. */
622 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
623 goto got_wrong_format_error
;
625 ebd
= get_elf_backend_data (abfd
);
627 /* Check that the ELF e_machine field matches what this particular
628 BFD format expects. */
629 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
630 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
631 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
633 const bfd_target
* const *target_ptr
;
635 if (ebd
->elf_machine_code
!= EM_NONE
)
636 goto got_wrong_format_error
;
638 /* This is the generic ELF target. Let it match any ELF target
639 for which we do not have a specific backend. */
640 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
642 struct elf_backend_data
*back
;
644 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
646 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
647 if (back
->elf_machine_code
== i_ehdrp
->e_machine
648 || (back
->elf_machine_alt1
!= 0
649 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
650 || (back
->elf_machine_alt2
!= 0
651 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
653 /* target_ptr is an ELF backend which matches this
654 object file, so reject the generic ELF target. */
655 goto got_wrong_format_error
;
660 if (i_ehdrp
->e_type
== ET_EXEC
)
661 abfd
->flags
|= EXEC_P
;
662 else if (i_ehdrp
->e_type
== ET_DYN
)
663 abfd
->flags
|= DYNAMIC
;
665 if (i_ehdrp
->e_phnum
> 0)
666 abfd
->flags
|= D_PAGED
;
668 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
670 /* It's OK if this fails for the generic target. */
671 if (ebd
->elf_machine_code
!= EM_NONE
)
675 /* Remember the entry point specified in the ELF file header. */
676 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
678 /* Seek to the section header table in the file. */
679 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
682 /* Read the first section header at index 0, and convert to internal
684 if (bfd_bread ((PTR
) & x_shdr
, (bfd_size_type
) sizeof x_shdr
, abfd
)
687 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
689 /* If the section count is zero, the actual count is in the first
691 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
692 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
694 /* And similarly for the string table index. */
695 if (i_ehdrp
->e_shstrndx
== SHN_XINDEX
)
696 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
698 /* Allocate space for a copy of the section header table in
700 if (i_ehdrp
->e_shnum
!= 0)
702 Elf_Internal_Shdr
*shdrp
;
703 unsigned int num_sec
;
705 amt
= sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
;
706 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
709 num_sec
= i_ehdrp
->e_shnum
;
710 if (num_sec
> SHN_LORESERVE
)
711 num_sec
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
712 elf_numsections (abfd
) = num_sec
;
713 amt
= sizeof (i_shdrp
) * num_sec
;
714 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
715 if (!elf_elfsections (abfd
))
718 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
721 if (num_sec
> SHN_LORESERVE
)
723 for ( ; shindex
< SHN_LORESERVE
; shindex
++)
724 elf_elfsections (abfd
)[shindex
] = shdrp
++;
725 for ( ; shindex
< SHN_HIRESERVE
+ 1; shindex
++)
726 elf_elfsections (abfd
)[shindex
] = i_shdrp
;
728 for ( ; shindex
< num_sec
; shindex
++)
729 elf_elfsections (abfd
)[shindex
] = shdrp
++;
731 /* Read in the rest of the section header table and convert it
733 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
735 if (bfd_bread ((PTR
) & x_shdr
, (bfd_size_type
) sizeof x_shdr
, abfd
)
738 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
740 /* If the section is loaded, but not page aligned, clear
742 if (i_shdrp
[shindex
].sh_size
!= 0
743 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
744 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
745 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
748 abfd
->flags
&= ~D_PAGED
;
752 if (i_ehdrp
->e_shstrndx
)
754 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
758 /* Read in the program headers. */
759 if (i_ehdrp
->e_phnum
== 0)
760 elf_tdata (abfd
)->phdr
= NULL
;
763 Elf_Internal_Phdr
*i_phdr
;
766 amt
= i_ehdrp
->e_phnum
* sizeof (Elf_Internal_Phdr
);
767 elf_tdata (abfd
)->phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
768 if (elf_tdata (abfd
)->phdr
== NULL
)
770 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
772 i_phdr
= elf_tdata (abfd
)->phdr
;
773 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
775 Elf_External_Phdr x_phdr
;
777 if (bfd_bread ((PTR
) &x_phdr
, (bfd_size_type
) sizeof x_phdr
, abfd
)
780 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
784 /* Read in the string table containing the names of the sections. We
785 will need the base pointer to this table later. */
786 /* We read this inline now, so that we don't have to go through
787 bfd_section_from_shdr with it (since this particular strtab is
788 used to find all of the ELF section names.) */
790 if (i_ehdrp
->e_shstrndx
!= 0)
792 unsigned int num_sec
;
794 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
798 /* Once all of the section headers have been read and converted, we
799 can start processing them. Note that the first section header is
800 a dummy placeholder entry, so we ignore it. */
801 num_sec
= elf_numsections (abfd
);
802 for (shindex
= 1; shindex
< num_sec
; shindex
++)
804 if (! bfd_section_from_shdr (abfd
, shindex
))
806 if (shindex
== SHN_LORESERVE
- 1)
807 shindex
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
811 /* Let the backend double check the format and override global
813 if (ebd
->elf_backend_object_p
)
815 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
816 goto got_wrong_format_error
;
819 /* If we have created any reloc sections that are associated with
820 debugging sections, mark the reloc sections as debugging as well. */
821 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
823 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
824 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
825 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
827 unsigned long targ_index
;
830 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
831 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
833 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
834 s
->flags
|= SEC_DEBUGGING
;
838 /* It would be nice to be able to free more memory here, eg. old
839 elf_elfsections, old tdata, but that's not possible since these
840 blocks are sitting inside obj_alloc'd memory. */
841 bfd_hash_table_free (&preserve
.section_htab
);
844 got_wrong_format_error
:
845 /* There is way too much undoing of half-known state here. The caller,
846 bfd_check_format_matches, really shouldn't iterate on live bfd's to
847 check match/no-match like it does. We have to rely on that a call to
848 bfd_default_set_arch_mach with the previously known mach, undoes what
849 was done by the first bfd_default_set_arch_mach (with mach 0) here.
850 For this to work, only elf-data and the mach may be changed by the
851 target-specific elf_backend_object_p function. Note that saving the
852 whole bfd here and restoring it would be even worse; the first thing
853 you notice is that the cached bfd file position gets out of sync. */
854 bfd_set_error (bfd_error_wrong_format
);
857 abfd
->arch_info
= preserve
.arch_info
;
858 if (new_tdata
!= NULL
)
860 /* bfd_release frees all memory more recently bfd_alloc'd than
861 its arg, as well as its arg. */
862 bfd_release (abfd
, new_tdata
);
863 elf_tdata (abfd
) = preserve
.tdata
;
864 abfd
->section_htab
= preserve
.section_htab
;
865 abfd
->sections
= preserve
.sections
;
866 abfd
->section_tail
= preserve
.section_tail
;
867 abfd
->section_count
= preserve
.section_count
;
872 /* ELF .o/exec file writing */
874 /* Write out the relocs. */
877 elf_write_relocs (abfd
, sec
, data
)
882 boolean
*failedp
= (boolean
*) data
;
883 Elf_Internal_Shdr
*rela_hdr
;
884 Elf_External_Rela
*outbound_relocas
;
885 Elf_External_Rel
*outbound_relocs
;
888 asymbol
*last_sym
= 0;
889 int last_sym_idx
= 0;
891 /* If we have already failed, don't do anything. */
895 if ((sec
->flags
& SEC_RELOC
) == 0)
898 /* The linker backend writes the relocs out itself, and sets the
899 reloc_count field to zero to inhibit writing them here. Also,
900 sometimes the SEC_RELOC flag gets set even when there aren't any
902 if (sec
->reloc_count
== 0)
905 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
907 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
908 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
909 if (rela_hdr
->contents
== NULL
)
915 /* Figure out whether the relocations are RELA or REL relocations. */
916 if (rela_hdr
->sh_type
== SHT_RELA
)
918 else if (rela_hdr
->sh_type
== SHT_REL
)
921 /* Every relocation section should be either an SHT_RELA or an
925 /* orelocation has the data, reloc_count has the count... */
928 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
930 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
932 Elf_Internal_Rela dst_rela
;
933 Elf_External_Rela
*src_rela
;
938 ptr
= sec
->orelocation
[idx
];
939 src_rela
= outbound_relocas
+ idx
;
941 /* The address of an ELF reloc is section relative for an object
942 file, and absolute for an executable file or shared library.
943 The address of a BFD reloc is always section relative. */
944 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
945 dst_rela
.r_offset
= ptr
->address
;
947 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
949 sym
= *ptr
->sym_ptr_ptr
;
952 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
957 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
966 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
967 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
968 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
974 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
976 dst_rela
.r_addend
= ptr
->addend
;
977 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
981 /* REL relocations */
983 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
985 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
987 Elf_Internal_Rel dst_rel
;
988 Elf_External_Rel
*src_rel
;
993 ptr
= sec
->orelocation
[idx
];
994 sym
= *ptr
->sym_ptr_ptr
;
995 src_rel
= outbound_relocs
+ idx
;
997 /* The address of an ELF reloc is section relative for an object
998 file, and absolute for an executable file or shared library.
999 The address of a BFD reloc is always section relative. */
1000 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1001 dst_rel
.r_offset
= ptr
->address
;
1003 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
1005 if (sym
== last_sym
)
1007 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
1012 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
1021 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
1022 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
1023 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
1029 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1031 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1036 /* Write out the program headers. */
1039 elf_write_out_phdrs (abfd
, phdr
, count
)
1041 const Elf_Internal_Phdr
*phdr
;
1046 Elf_External_Phdr extphdr
;
1047 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1048 if (bfd_bwrite (&extphdr
, (bfd_size_type
) sizeof (Elf_External_Phdr
),
1049 abfd
) != sizeof (Elf_External_Phdr
))
1056 /* Write out the section headers and the ELF file header. */
1059 elf_write_shdrs_and_ehdr (abfd
)
1062 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1063 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1064 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1065 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1069 i_ehdrp
= elf_elfheader (abfd
);
1070 i_shdrp
= elf_elfsections (abfd
);
1072 /* swap the header before spitting it out... */
1075 elf_debug_file (i_ehdrp
);
1077 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1078 amt
= sizeof (x_ehdr
);
1079 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1080 || bfd_bwrite ((PTR
) & x_ehdr
, amt
, abfd
) != amt
)
1083 /* Some fields in the first section header handle overflow of ehdr
1085 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
)
1086 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1087 if (i_ehdrp
->e_shstrndx
>= SHN_LORESERVE
)
1088 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1090 /* at this point we've concocted all the ELF sections... */
1091 amt
= i_ehdrp
->e_shnum
;
1092 amt
*= sizeof (*x_shdrp
);
1093 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1097 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1100 elf_debug_section (count
, *i_shdrp
);
1102 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1104 if (count
== SHN_LORESERVE
- 1)
1105 i_shdrp
+= SHN_HIRESERVE
+ 1 - SHN_LORESERVE
;
1107 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1108 || bfd_bwrite ((PTR
) x_shdrp
, amt
, abfd
) != amt
)
1111 /* need to dump the string table too... */
1117 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
1119 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
1122 Elf_Internal_Shdr
*hdr
;
1123 Elf_Internal_Shdr
*verhdr
;
1124 unsigned long symcount
; /* Number of external ELF symbols */
1125 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1126 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1127 Elf_Internal_Sym i_sym
;
1128 Elf_External_Sym
*x_symp
= NULL
;
1129 Elf_External_Sym_Shndx
*x_shndx
= NULL
;
1130 Elf_External_Versym
*x_versymp
= NULL
;
1133 /* Read each raw ELF symbol, converting from external ELF form to
1134 internal ELF form, and then using the information to create a
1135 canonical bfd symbol table entry.
1137 Note that we allocate the initial bfd canonical symbol buffer
1138 based on a one-to-one mapping of the ELF symbols to canonical
1139 symbols. We actually use all the ELF symbols, so there will be no
1140 space left over at the end. When we have all the symbols, we
1141 build the caller's pointer vector. */
1145 Elf_Internal_Shdr
*shndx_hdr
;
1147 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1148 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1151 /* If we have a SHT_SYMTAB_SHNDX section for the symbol table,
1152 read the raw contents. */
1153 if (elf_elfsections (abfd
)[shndx_hdr
->sh_link
] == hdr
)
1155 amt
= shndx_hdr
->sh_size
;
1156 x_shndx
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1158 || bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1159 || bfd_bread ((PTR
) x_shndx
, amt
, abfd
) != amt
)
1165 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1166 if (elf_dynversym (abfd
) == 0)
1169 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1170 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1171 && elf_tdata (abfd
)->verdef
== NULL
)
1172 || (elf_tdata (abfd
)->dynverref_section
!= 0
1173 && elf_tdata (abfd
)->verref
== NULL
))
1175 if (! _bfd_elf_slurp_version_tables (abfd
))
1180 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
1183 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1186 sym
= symbase
= NULL
;
1191 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) != 0)
1195 amt
*= sizeof (elf_symbol_type
);
1196 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1197 if (symbase
== (elf_symbol_type
*) NULL
)
1201 /* Temporarily allocate room for the raw ELF symbols. */
1203 amt
*= sizeof (Elf_External_Sym
);
1204 x_symp
= (Elf_External_Sym
*) bfd_malloc (amt
);
1208 if (bfd_bread ((PTR
) x_symp
, amt
, abfd
) != amt
)
1211 /* Read the raw ELF version symbol information. */
1214 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1216 (*_bfd_error_handler
)
1217 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1219 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1222 /* Slurp in the symbols without the version information,
1223 since that is more helpful than just quitting. */
1229 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1232 x_versymp
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1233 if (x_versymp
== NULL
&& verhdr
->sh_size
!= 0)
1236 if (bfd_bread ((PTR
) x_versymp
, verhdr
->sh_size
, abfd
)
1241 /* Skip first symbol, which is a null dummy. */
1242 for (i
= 1; i
< symcount
; i
++)
1244 elf_swap_symbol_in (abfd
, x_symp
+ i
,
1245 x_shndx
+ (x_shndx
!= NULL
? i
: 0), &i_sym
);
1246 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
1247 #ifdef ELF_KEEP_EXTSYM
1248 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
1250 sym
->symbol
.the_bfd
= abfd
;
1252 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
1256 sym
->symbol
.value
= i_sym
.st_value
;
1258 if (i_sym
.st_shndx
== SHN_UNDEF
)
1260 sym
->symbol
.section
= bfd_und_section_ptr
;
1262 else if (i_sym
.st_shndx
< SHN_LORESERVE
1263 || i_sym
.st_shndx
> SHN_HIRESERVE
)
1265 sym
->symbol
.section
= section_from_elf_index (abfd
,
1267 if (sym
->symbol
.section
== NULL
)
1269 /* This symbol is in a section for which we did not
1270 create a BFD section. Just use bfd_abs_section,
1271 although it is wrong. FIXME. */
1272 sym
->symbol
.section
= bfd_abs_section_ptr
;
1275 else if (i_sym
.st_shndx
== SHN_ABS
)
1277 sym
->symbol
.section
= bfd_abs_section_ptr
;
1279 else if (i_sym
.st_shndx
== SHN_COMMON
)
1281 sym
->symbol
.section
= bfd_com_section_ptr
;
1282 /* Elf puts the alignment into the `value' field, and
1283 the size into the `size' field. BFD wants to see the
1284 size in the value field, and doesn't care (at the
1285 moment) about the alignment. */
1286 sym
->symbol
.value
= i_sym
.st_size
;
1289 sym
->symbol
.section
= bfd_abs_section_ptr
;
1291 /* If this is a relocateable file, then the symbol value is
1292 already section relative. */
1293 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1294 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1296 switch (ELF_ST_BIND (i_sym
.st_info
))
1299 sym
->symbol
.flags
|= BSF_LOCAL
;
1302 if (i_sym
.st_shndx
!= SHN_UNDEF
1303 && i_sym
.st_shndx
!= SHN_COMMON
)
1304 sym
->symbol
.flags
|= BSF_GLOBAL
;
1307 sym
->symbol
.flags
|= BSF_WEAK
;
1311 switch (ELF_ST_TYPE (i_sym
.st_info
))
1314 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1317 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1320 sym
->symbol
.flags
|= BSF_FUNCTION
;
1323 sym
->symbol
.flags
|= BSF_OBJECT
;
1328 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1330 if (x_versymp
!= NULL
)
1332 Elf_Internal_Versym iversym
;
1334 _bfd_elf_swap_versym_in (abfd
, x_versymp
+ i
, &iversym
);
1335 sym
->version
= iversym
.vs_vers
;
1338 /* Do some backend-specific processing on this symbol. */
1340 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1341 if (ebd
->elf_backend_symbol_processing
)
1342 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1349 /* Do some backend-specific processing on this symbol table. */
1351 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1352 if (ebd
->elf_backend_symbol_table_processing
)
1353 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1356 /* We rely on the zalloc to clear out the final symbol entry. */
1358 symcount
= sym
- symbase
;
1360 /* Fill in the user's symbol pointer vector if needed. */
1368 *symptrs
++ = &sym
->symbol
;
1371 *symptrs
= 0; /* Final null pointer */
1374 if (x_shndx
!= NULL
)
1376 if (x_versymp
!= NULL
)
1383 if (x_shndx
!= NULL
)
1385 if (x_versymp
!= NULL
)
1392 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1396 elf_slurp_reloc_table_from_section (abfd
, asect
, rel_hdr
, reloc_count
,
1397 relents
, symbols
, dynamic
)
1400 Elf_Internal_Shdr
*rel_hdr
;
1401 bfd_size_type reloc_count
;
1406 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1407 PTR allocated
= NULL
;
1408 bfd_byte
*native_relocs
;
1413 allocated
= (PTR
) bfd_malloc (rel_hdr
->sh_size
);
1414 if (allocated
== NULL
)
1417 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1418 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1419 != rel_hdr
->sh_size
))
1422 native_relocs
= (bfd_byte
*) allocated
;
1424 entsize
= rel_hdr
->sh_entsize
;
1425 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1426 || entsize
== sizeof (Elf_External_Rela
));
1428 for (i
= 0, relent
= relents
;
1430 i
++, relent
++, native_relocs
+= entsize
)
1432 Elf_Internal_Rela rela
;
1433 Elf_Internal_Rel rel
;
1435 if (entsize
== sizeof (Elf_External_Rela
))
1436 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
1439 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
1440 rela
.r_offset
= rel
.r_offset
;
1441 rela
.r_info
= rel
.r_info
;
1445 /* The address of an ELF reloc is section relative for an object
1446 file, and absolute for an executable file or shared library.
1447 The address of a normal BFD reloc is always section relative,
1448 and the address of a dynamic reloc is absolute.. */
1449 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1450 relent
->address
= rela
.r_offset
;
1452 relent
->address
= rela
.r_offset
- asect
->vma
;
1454 if (ELF_R_SYM (rela
.r_info
) == 0)
1455 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1460 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1463 /* Canonicalize ELF section symbols. FIXME: Why? */
1464 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1465 relent
->sym_ptr_ptr
= ps
;
1467 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1470 relent
->addend
= rela
.r_addend
;
1472 if (entsize
== sizeof (Elf_External_Rela
))
1473 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1475 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
1478 if (allocated
!= NULL
)
1484 if (allocated
!= NULL
)
1489 /* Read in and swap the external relocs. */
1492 elf_slurp_reloc_table (abfd
, asect
, symbols
, dynamic
)
1498 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1499 Elf_Internal_Shdr
*rel_hdr
;
1500 Elf_Internal_Shdr
*rel_hdr2
;
1501 bfd_size_type reloc_count
;
1502 bfd_size_type reloc_count2
;
1506 if (asect
->relocation
!= NULL
)
1511 if ((asect
->flags
& SEC_RELOC
) == 0
1512 || asect
->reloc_count
== 0)
1515 rel_hdr
= &d
->rel_hdr
;
1516 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1517 rel_hdr2
= d
->rel_hdr2
;
1518 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1520 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1521 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1522 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1527 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1528 case because relocations against this section may use the
1529 dynamic symbol table, and in that case bfd_section_from_shdr
1530 in elf.c does not update the RELOC_COUNT. */
1531 if (asect
->_raw_size
== 0)
1534 rel_hdr
= &d
->this_hdr
;
1535 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1540 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1541 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1542 if (relents
== NULL
)
1545 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1546 rel_hdr
, reloc_count
,
1552 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1553 rel_hdr2
, reloc_count2
,
1554 relents
+ reloc_count
,
1558 asect
->relocation
= relents
;
1564 elf_debug_section (num
, hdr
)
1566 Elf_Internal_Shdr
*hdr
;
1568 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1569 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1572 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1573 (long) hdr
->sh_name
,
1574 (long) hdr
->sh_type
,
1575 (long) hdr
->sh_flags
);
1577 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1578 (long) hdr
->sh_addr
,
1579 (long) hdr
->sh_offset
,
1580 (long) hdr
->sh_size
);
1582 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1583 (long) hdr
->sh_link
,
1584 (long) hdr
->sh_info
,
1585 (long) hdr
->sh_addralign
);
1586 fprintf (stderr
, "sh_entsize = %ld\n",
1587 (long) hdr
->sh_entsize
);
1592 elf_debug_file (ehdrp
)
1593 Elf_Internal_Ehdr
*ehdrp
;
1595 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1596 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1597 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1598 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1599 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1600 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1601 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1605 elf_symbol_flags (flags
)
1608 static char buffer
[1024];
1611 if (flags
& BSF_LOCAL
)
1612 strcat (buffer
, " local");
1614 if (flags
& BSF_GLOBAL
)
1615 strcat (buffer
, " global");
1617 if (flags
& BSF_DEBUGGING
)
1618 strcat (buffer
, " debug");
1620 if (flags
& BSF_FUNCTION
)
1621 strcat (buffer
, " function");
1623 if (flags
& BSF_KEEP
)
1624 strcat (buffer
, " keep");
1626 if (flags
& BSF_KEEP_G
)
1627 strcat (buffer
, " keep_g");
1629 if (flags
& BSF_WEAK
)
1630 strcat (buffer
, " weak");
1632 if (flags
& BSF_SECTION_SYM
)
1633 strcat (buffer
, " section-sym");
1635 if (flags
& BSF_OLD_COMMON
)
1636 strcat (buffer
, " old-common");
1638 if (flags
& BSF_NOT_AT_END
)
1639 strcat (buffer
, " not-at-end");
1641 if (flags
& BSF_CONSTRUCTOR
)
1642 strcat (buffer
, " constructor");
1644 if (flags
& BSF_WARNING
)
1645 strcat (buffer
, " warning");
1647 if (flags
& BSF_INDIRECT
)
1648 strcat (buffer
, " indirect");
1650 if (flags
& BSF_FILE
)
1651 strcat (buffer
, " file");
1653 if (flags
& DYNAMIC
)
1654 strcat (buffer
, " dynamic");
1656 if (flags
& ~(BSF_LOCAL
1671 strcat (buffer
, " unknown-bits");
1677 #include "elfcore.h"
1678 #include "elflink.h"
1680 /* Size-dependent data and functions. */
1681 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1682 sizeof (Elf_External_Ehdr
),
1683 sizeof (Elf_External_Phdr
),
1684 sizeof (Elf_External_Shdr
),
1685 sizeof (Elf_External_Rel
),
1686 sizeof (Elf_External_Rela
),
1687 sizeof (Elf_External_Sym
),
1688 sizeof (Elf_External_Dyn
),
1689 sizeof (Elf_External_Note
),
1692 ARCH_SIZE
, FILE_ALIGN
,
1693 ELFCLASS
, EV_CURRENT
,
1694 elf_write_out_phdrs
,
1695 elf_write_shdrs_and_ehdr
,
1697 elf_swap_symbol_out
,
1698 elf_slurp_reloc_table
,
1699 elf_slurp_symbol_table
,