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_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_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
129 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
130 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
131 #define elf_gc_common_finalize_got_offsets \
132 NAME(_bfd_elf,gc_common_finalize_got_offsets)
133 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
134 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
135 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
136 #define elf_link_record_local_dynamic_symbol \
137 NAME(_bfd_elf,link_record_local_dynamic_symbol)
140 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
141 #define ELF_R_SYM(X) ELF64_R_SYM(X)
142 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
143 #define ELFCLASS ELFCLASS64
145 #define LOG_FILE_ALIGN 3
148 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
149 #define ELF_R_SYM(X) ELF32_R_SYM(X)
150 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
151 #define ELFCLASS ELFCLASS32
153 #define LOG_FILE_ALIGN 2
156 /* Static functions */
158 static void elf_swap_ehdr_in
159 PARAMS ((bfd
*, const Elf_External_Ehdr
*, Elf_Internal_Ehdr
*));
160 static void elf_swap_ehdr_out
161 PARAMS ((bfd
*, const Elf_Internal_Ehdr
*, Elf_External_Ehdr
*));
162 static void elf_swap_shdr_in
163 PARAMS ((bfd
*, const Elf_External_Shdr
*, Elf_Internal_Shdr
*));
164 static void elf_swap_shdr_out
165 PARAMS ((bfd
*, const Elf_Internal_Shdr
*, Elf_External_Shdr
*));
167 #define elf_stringtab_init _bfd_elf_stringtab_init
169 #define section_from_elf_index bfd_section_from_elf_index
171 static boolean elf_slurp_reloc_table_from_section
172 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, bfd_size_type
,
173 arelent
*, asymbol
**, boolean
));
175 static boolean elf_file_p
PARAMS ((Elf_External_Ehdr
*));
178 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
179 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
180 static char *elf_symbol_flags
PARAMS ((flagword
));
183 /* Structure swapping routines */
185 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
186 can be handled by explicitly specifying 32 bits or "the long type". */
188 #define put_word bfd_h_put_64
189 #define put_signed_word bfd_h_put_signed_64
190 #define get_word bfd_h_get_64
191 #define get_signed_word bfd_h_get_signed_64
194 #define put_word bfd_h_put_32
195 #define put_signed_word bfd_h_put_signed_32
196 #define get_word bfd_h_get_32
197 #define get_signed_word bfd_h_get_signed_32
200 /* Translate an ELF symbol in external format into an ELF symbol in internal
204 elf_swap_symbol_in (abfd
, src
, dst
)
206 const Elf_External_Sym
*src
;
207 Elf_Internal_Sym
*dst
;
209 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
211 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
213 dst
->st_value
= get_signed_word (abfd
, (bfd_byte
*) src
->st_value
);
215 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
216 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
217 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
218 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
219 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
222 /* Translate an ELF symbol in internal format into an ELF symbol in external
226 elf_swap_symbol_out (abfd
, src
, cdst
)
228 const Elf_Internal_Sym
*src
;
231 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
232 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
233 put_word (abfd
, src
->st_value
, dst
->st_value
);
234 put_word (abfd
, src
->st_size
, dst
->st_size
);
235 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
236 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
237 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
240 /* Translate an ELF file header in external format into an ELF file header in
244 elf_swap_ehdr_in (abfd
, src
, dst
)
246 const Elf_External_Ehdr
*src
;
247 Elf_Internal_Ehdr
*dst
;
249 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
250 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
251 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
252 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
253 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
255 dst
->e_entry
= get_signed_word (abfd
, (bfd_byte
*) src
->e_entry
);
257 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
258 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
259 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
260 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
261 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
262 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
263 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
264 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
265 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
266 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
269 /* Translate an ELF file header in internal format into an ELF file header in
273 elf_swap_ehdr_out (abfd
, src
, dst
)
275 const Elf_Internal_Ehdr
*src
;
276 Elf_External_Ehdr
*dst
;
278 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
279 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
280 /* note that all elements of dst are *arrays of unsigned char* already... */
281 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
282 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
283 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
285 put_signed_word (abfd
, src
->e_entry
, dst
->e_entry
);
287 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
288 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
289 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
290 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
291 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
292 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
293 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
294 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
295 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
296 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
299 /* Translate an ELF section header table entry in external format into an
300 ELF section header table entry in internal format. */
303 elf_swap_shdr_in (abfd
, src
, dst
)
305 const Elf_External_Shdr
*src
;
306 Elf_Internal_Shdr
*dst
;
308 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
310 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
311 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
312 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
314 dst
->sh_addr
= get_signed_word (abfd
, (bfd_byte
*) src
->sh_addr
);
316 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
317 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
318 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
319 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
320 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
321 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
322 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
323 dst
->bfd_section
= NULL
;
324 dst
->contents
= NULL
;
327 /* Translate an ELF section header table entry in internal format into an
328 ELF section header table entry in external format. */
331 elf_swap_shdr_out (abfd
, src
, dst
)
333 const Elf_Internal_Shdr
*src
;
334 Elf_External_Shdr
*dst
;
336 /* note that all elements of dst are *arrays of unsigned char* already... */
337 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
338 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
339 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
340 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
341 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
342 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
343 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
344 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
345 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
346 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
349 /* Translate an ELF program header table entry in external format into an
350 ELF program header table entry in internal format. */
353 elf_swap_phdr_in (abfd
, src
, dst
)
355 const Elf_External_Phdr
*src
;
356 Elf_Internal_Phdr
*dst
;
358 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
360 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
361 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
362 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
365 dst
->p_vaddr
= get_signed_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
366 dst
->p_paddr
= get_signed_word (abfd
, (bfd_byte
*) src
->p_paddr
);
370 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
371 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
373 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
374 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
375 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
379 elf_swap_phdr_out (abfd
, src
, dst
)
381 const Elf_Internal_Phdr
*src
;
382 Elf_External_Phdr
*dst
;
384 /* note that all elements of dst are *arrays of unsigned char* already... */
385 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
386 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
387 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
388 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
389 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
390 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
391 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
392 put_word (abfd
, src
->p_align
, dst
->p_align
);
395 /* Translate an ELF reloc from external format to internal format. */
397 elf_swap_reloc_in (abfd
, src
, dst
)
399 const Elf_External_Rel
*src
;
400 Elf_Internal_Rel
*dst
;
402 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
403 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
407 elf_swap_reloca_in (abfd
, src
, dst
)
409 const Elf_External_Rela
*src
;
410 Elf_Internal_Rela
*dst
;
412 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
413 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
414 dst
->r_addend
= get_signed_word (abfd
, (bfd_byte
*) src
->r_addend
);
417 /* Translate an ELF reloc from internal format to external format. */
419 elf_swap_reloc_out (abfd
, src
, dst
)
421 const Elf_Internal_Rel
*src
;
422 Elf_External_Rel
*dst
;
424 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
425 put_word (abfd
, src
->r_info
, dst
->r_info
);
429 elf_swap_reloca_out (abfd
, src
, dst
)
431 const Elf_Internal_Rela
*src
;
432 Elf_External_Rela
*dst
;
434 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
435 put_word (abfd
, src
->r_info
, dst
->r_info
);
436 put_signed_word (abfd
, src
->r_addend
, dst
->r_addend
);
440 elf_swap_dyn_in (abfd
, p
, dst
)
443 Elf_Internal_Dyn
*dst
;
445 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
447 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
448 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
452 elf_swap_dyn_out (abfd
, src
, p
)
454 const Elf_Internal_Dyn
*src
;
457 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
459 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
460 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
463 /* ELF .o/exec file reading */
465 /* Begin processing a given object.
467 First we validate the file by reading in the ELF header and checking
470 static INLINE boolean
472 Elf_External_Ehdr
*x_ehdrp
;
474 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
475 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
476 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
477 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
480 /* Check to see if the file associated with ABFD matches the target vector
483 Note that we may be called several times with the same ABFD, but different
484 target vectors, most of which will not match. We have to avoid leaving
485 any side effects in ABFD, or any data it points to (like tdata), if the
486 file does not match the target vector. */
492 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
493 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
494 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
495 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
496 unsigned int shindex
;
497 char *shstrtab
; /* Internal copy of section header stringtab */
498 struct elf_backend_data
*ebd
;
499 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
500 struct sec
*preserved_sections
= abfd
->sections
;
501 unsigned int preserved_section_count
= abfd
->section_count
;
502 enum bfd_architecture previous_arch
= bfd_get_arch (abfd
);
503 unsigned long previous_mach
= bfd_get_mach (abfd
);
504 struct elf_obj_tdata
*new_tdata
= NULL
;
507 /* Clear section information, since there might be a recognized bfd that
508 we now check if we can replace, and we don't want to append to it. */
509 abfd
->sections
= NULL
;
510 abfd
->section_count
= 0;
512 /* Read in the ELF header in external format. */
514 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
516 if (bfd_get_error () != bfd_error_system_call
)
517 goto got_wrong_format_error
;
522 /* Now check to see if we have a valid ELF file, and one that BFD can
523 make use of. The magic number must match, the address size ('class')
524 and byte-swapping must match our XVEC entry, and it must have a
525 section header table (FIXME: See comments re sections at top of this
528 if ((elf_file_p (&x_ehdr
) == false) ||
529 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
530 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
531 goto got_wrong_format_error
;
533 /* Check that file's byte order matches xvec's */
534 switch (x_ehdr
.e_ident
[EI_DATA
])
536 case ELFDATA2MSB
: /* Big-endian */
537 if (! bfd_header_big_endian (abfd
))
538 goto got_wrong_format_error
;
540 case ELFDATA2LSB
: /* Little-endian */
541 if (! bfd_header_little_endian (abfd
))
542 goto got_wrong_format_error
;
544 case ELFDATANONE
: /* No data encoding specified */
545 default: /* Unknown data encoding specified */
546 goto got_wrong_format_error
;
549 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
550 the tdata pointer in the bfd. */
552 new_tdata
= ((struct elf_obj_tdata
*)
553 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
554 if (new_tdata
== NULL
)
556 elf_tdata (abfd
) = new_tdata
;
558 /* Now that we know the byte order, swap in the rest of the header */
559 i_ehdrp
= elf_elfheader (abfd
);
560 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
562 elf_debug_file (i_ehdrp
);
565 /* Reject ET_CORE (header indicates core file, not object file) */
566 if (i_ehdrp
->e_type
== ET_CORE
)
567 goto got_wrong_format_error
;
569 /* If there is no section header table, we're hosed. */
570 if (i_ehdrp
->e_shoff
== 0)
571 goto got_wrong_format_error
;
573 /* As a simple sanity check, verify that the what BFD thinks is the
574 size of each section header table entry actually matches the size
575 recorded in the file. */
576 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
577 goto got_wrong_format_error
;
579 ebd
= get_elf_backend_data (abfd
);
581 /* Check that the ELF e_machine field matches what this particular
582 BFD format expects. */
583 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
584 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
585 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
587 const bfd_target
* const *target_ptr
;
589 if (ebd
->elf_machine_code
!= EM_NONE
)
590 goto got_wrong_format_error
;
592 /* This is the generic ELF target. Let it match any ELF target
593 for which we do not have a specific backend. */
594 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
596 struct elf_backend_data
*back
;
598 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
600 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
601 if (back
->elf_machine_code
== i_ehdrp
->e_machine
602 || (back
->elf_machine_alt1
!= 0
603 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
604 || (back
->elf_machine_alt2
!= 0
605 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
607 /* target_ptr is an ELF backend which matches this
608 object file, so reject the generic ELF target. */
609 goto got_wrong_format_error
;
614 if (i_ehdrp
->e_type
== ET_EXEC
)
615 abfd
->flags
|= EXEC_P
;
616 else if (i_ehdrp
->e_type
== ET_DYN
)
617 abfd
->flags
|= DYNAMIC
;
619 if (i_ehdrp
->e_phnum
> 0)
620 abfd
->flags
|= D_PAGED
;
622 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
624 /* It's OK if this fails for the generic target. */
625 if (ebd
->elf_machine_code
!= EM_NONE
)
629 /* Remember the entry point specified in the ELF file header. */
630 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
632 /* Allocate space for a copy of the section header table in
633 internal form, seek to the section header table in the file,
634 read it in, and convert it to internal form. */
635 i_shdrp
= ((Elf_Internal_Shdr
*)
636 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
637 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
639 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
640 if (!i_shdrp
|| !elf_elfsections (abfd
))
642 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
644 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
646 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
648 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
649 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
651 /* If the section is loaded, but not page aligned, clear
653 if ((i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
654 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
655 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
658 abfd
->flags
&= ~D_PAGED
;
660 if (i_ehdrp
->e_shstrndx
)
662 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
666 /* Read in the program headers. */
667 if (i_ehdrp
->e_phnum
== 0)
668 elf_tdata (abfd
)->phdr
= NULL
;
671 Elf_Internal_Phdr
*i_phdr
;
674 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
677 * sizeof (Elf_Internal_Phdr
))));
678 if (elf_tdata (abfd
)->phdr
== NULL
)
680 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
682 i_phdr
= elf_tdata (abfd
)->phdr
;
683 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
685 Elf_External_Phdr x_phdr
;
687 if (bfd_read ((PTR
) &x_phdr
, sizeof x_phdr
, 1, abfd
)
690 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
694 /* Read in the string table containing the names of the sections. We
695 will need the base pointer to this table later. */
696 /* We read this inline now, so that we don't have to go through
697 bfd_section_from_shdr with it (since this particular strtab is
698 used to find all of the ELF section names.) */
700 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
704 /* Once all of the section headers have been read and converted, we
705 can start processing them. Note that the first section header is
706 a dummy placeholder entry, so we ignore it. */
708 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
710 if (! bfd_section_from_shdr (abfd
, shindex
))
714 /* Let the backend double check the format and override global
716 if (ebd
->elf_backend_object_p
)
718 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
719 goto got_wrong_format_error
;
722 /* If we have created any reloc sections that are associated with
723 debugging sections, mark the reloc sections as debugging as well. */
724 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
726 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
727 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
728 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
730 unsigned long targ_index
;
733 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
734 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
736 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
737 s
->flags
|= SEC_DEBUGGING
;
743 got_wrong_format_error
:
744 /* There is way too much undoing of half-known state here. The caller,
745 bfd_check_format_matches, really shouldn't iterate on live bfd's to
746 check match/no-match like it does. We have to rely on that a call to
747 bfd_default_set_arch_mach with the previously known mach, undoes what
748 was done by the first bfd_default_set_arch_mach (with mach 0) here.
749 For this to work, only elf-data and the mach may be changed by the
750 target-specific elf_backend_object_p function. Note that saving the
751 whole bfd here and restoring it would be even worse; the first thing
752 you notice is that the cached bfd file position gets out of sync. */
753 bfd_default_set_arch_mach (abfd
, previous_arch
, previous_mach
);
754 bfd_set_error (bfd_error_wrong_format
);
756 if (new_tdata
!= NULL
757 && new_tdata
->elf_sect_ptr
!= NULL
)
758 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
760 bfd_release (abfd
, i_shdrp
);
761 if (new_tdata
!= NULL
)
762 bfd_release (abfd
, new_tdata
);
763 elf_tdata (abfd
) = preserved_tdata
;
764 abfd
->sections
= preserved_sections
;
765 abfd
->section_count
= preserved_section_count
;
769 /* ELF .o/exec file writing */
771 /* Write out the relocs. */
774 elf_write_relocs (abfd
, sec
, data
)
779 boolean
*failedp
= (boolean
*) data
;
780 Elf_Internal_Shdr
*rela_hdr
;
781 Elf_External_Rela
*outbound_relocas
;
782 Elf_External_Rel
*outbound_relocs
;
785 asymbol
*last_sym
= 0;
786 int last_sym_idx
= 0;
788 /* If we have already failed, don't do anything. */
792 if ((sec
->flags
& SEC_RELOC
) == 0)
795 /* The linker backend writes the relocs out itself, and sets the
796 reloc_count field to zero to inhibit writing them here. Also,
797 sometimes the SEC_RELOC flag gets set even when there aren't any
799 if (sec
->reloc_count
== 0)
802 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
804 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
805 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
806 if (rela_hdr
->contents
== NULL
)
812 /* Figure out whether the relocations are RELA or REL relocations. */
813 if (rela_hdr
->sh_type
== SHT_RELA
)
815 else if (rela_hdr
->sh_type
== SHT_REL
)
818 /* Every relocation section should be either an SHT_RELA or an
822 /* orelocation has the data, reloc_count has the count... */
825 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
827 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
829 Elf_Internal_Rela dst_rela
;
830 Elf_External_Rela
*src_rela
;
835 ptr
= sec
->orelocation
[idx
];
836 src_rela
= outbound_relocas
+ idx
;
838 /* The address of an ELF reloc is section relative for an object
839 file, and absolute for an executable file or shared library.
840 The address of a BFD reloc is always section relative. */
841 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
842 dst_rela
.r_offset
= ptr
->address
;
844 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
846 sym
= *ptr
->sym_ptr_ptr
;
849 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
854 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
863 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
864 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
865 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
871 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
873 dst_rela
.r_addend
= ptr
->addend
;
874 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
878 /* REL relocations */
880 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
882 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
884 Elf_Internal_Rel dst_rel
;
885 Elf_External_Rel
*src_rel
;
890 ptr
= sec
->orelocation
[idx
];
891 sym
= *ptr
->sym_ptr_ptr
;
892 src_rel
= outbound_relocs
+ idx
;
894 /* The address of an ELF reloc is section relative for an object
895 file, and absolute for an executable file or shared library.
896 The address of a BFD reloc is always section relative. */
897 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
898 dst_rel
.r_offset
= ptr
->address
;
900 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
904 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
909 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
918 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
919 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
920 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
926 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
928 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
933 /* Write out the program headers. */
936 elf_write_out_phdrs (abfd
, phdr
, count
)
938 const Elf_Internal_Phdr
*phdr
;
943 Elf_External_Phdr extphdr
;
944 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
945 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
946 != sizeof (Elf_External_Phdr
))
953 /* Write out the section headers and the ELF file header. */
956 elf_write_shdrs_and_ehdr (abfd
)
959 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
960 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
961 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
962 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
965 i_ehdrp
= elf_elfheader (abfd
);
966 i_shdrp
= elf_elfsections (abfd
);
968 /* swap the header before spitting it out... */
971 elf_debug_file (i_ehdrp
);
973 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
974 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
975 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
979 /* at this point we've concocted all the ELF sections... */
980 x_shdrp
= (Elf_External_Shdr
*)
981 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
985 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
988 elf_debug_section (count
, i_shdrp
[count
]);
990 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
992 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
993 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
994 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
997 /* need to dump the string table too... */
1003 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
1005 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
1008 Elf_Internal_Shdr
*hdr
;
1009 Elf_Internal_Shdr
*verhdr
;
1010 unsigned long symcount
; /* Number of external ELF symbols */
1011 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1012 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1013 Elf_Internal_Sym i_sym
;
1014 Elf_External_Sym
*x_symp
= NULL
;
1015 Elf_External_Versym
*x_versymp
= NULL
;
1017 /* Read each raw ELF symbol, converting from external ELF form to
1018 internal ELF form, and then using the information to create a
1019 canonical bfd symbol table entry.
1021 Note that we allocate the initial bfd canonical symbol buffer
1022 based on a one-to-one mapping of the ELF symbols to canonical
1023 symbols. We actually use all the ELF symbols, so there will be no
1024 space left over at the end. When we have all the symbols, we
1025 build the caller's pointer vector. */
1029 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1034 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1035 if (elf_dynversym (abfd
) == 0)
1038 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1039 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
1040 && elf_tdata (abfd
)->verdef
== NULL
)
1041 || (elf_tdata (abfd
)->dynverref_section
!= 0
1042 && elf_tdata (abfd
)->verref
== NULL
))
1044 if (! _bfd_elf_slurp_version_tables (abfd
))
1049 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
1052 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1055 sym
= symbase
= NULL
;
1060 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
1063 symbase
= ((elf_symbol_type
*)
1064 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
1065 if (symbase
== (elf_symbol_type
*) NULL
)
1069 /* Temporarily allocate room for the raw ELF symbols. */
1070 x_symp
= ((Elf_External_Sym
*)
1071 bfd_malloc (symcount
* sizeof (Elf_External_Sym
)));
1072 if (x_symp
== NULL
&& symcount
!= 0)
1075 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
1076 != symcount
* sizeof (Elf_External_Sym
))
1079 /* Read the raw ELF version symbol information. */
1082 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1084 (*_bfd_error_handler
)
1085 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1087 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1090 /* Slurp in the symbols without the version information,
1091 since that is more helpful than just quitting. */
1097 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1100 x_versymp
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1101 if (x_versymp
== NULL
&& verhdr
->sh_size
!= 0)
1104 if (bfd_read ((PTR
) x_versymp
, 1, verhdr
->sh_size
, abfd
)
1109 /* Skip first symbol, which is a null dummy. */
1110 for (i
= 1; i
< symcount
; i
++)
1112 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
1113 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
1114 #ifdef ELF_KEEP_EXTSYM
1115 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
1117 sym
->symbol
.the_bfd
= abfd
;
1119 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
1123 sym
->symbol
.value
= i_sym
.st_value
;
1125 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
1127 sym
->symbol
.section
= section_from_elf_index (abfd
,
1129 if (sym
->symbol
.section
== NULL
)
1131 /* This symbol is in a section for which we did not
1132 create a BFD section. Just use bfd_abs_section,
1133 although it is wrong. FIXME. */
1134 sym
->symbol
.section
= bfd_abs_section_ptr
;
1137 else if (i_sym
.st_shndx
== SHN_ABS
)
1139 sym
->symbol
.section
= bfd_abs_section_ptr
;
1141 else if (i_sym
.st_shndx
== SHN_COMMON
)
1143 sym
->symbol
.section
= bfd_com_section_ptr
;
1144 /* Elf puts the alignment into the `value' field, and
1145 the size into the `size' field. BFD wants to see the
1146 size in the value field, and doesn't care (at the
1147 moment) about the alignment. */
1148 sym
->symbol
.value
= i_sym
.st_size
;
1150 else if (i_sym
.st_shndx
== SHN_UNDEF
)
1152 sym
->symbol
.section
= bfd_und_section_ptr
;
1155 sym
->symbol
.section
= bfd_abs_section_ptr
;
1157 /* If this is a relocateable file, then the symbol value is
1158 already section relative. */
1159 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1160 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1162 switch (ELF_ST_BIND (i_sym
.st_info
))
1165 sym
->symbol
.flags
|= BSF_LOCAL
;
1168 if (i_sym
.st_shndx
!= SHN_UNDEF
1169 && i_sym
.st_shndx
!= SHN_COMMON
)
1170 sym
->symbol
.flags
|= BSF_GLOBAL
;
1173 sym
->symbol
.flags
|= BSF_WEAK
;
1177 switch (ELF_ST_TYPE (i_sym
.st_info
))
1180 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1183 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1186 sym
->symbol
.flags
|= BSF_FUNCTION
;
1189 sym
->symbol
.flags
|= BSF_OBJECT
;
1194 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1196 if (x_versymp
!= NULL
)
1198 Elf_Internal_Versym iversym
;
1200 _bfd_elf_swap_versym_in (abfd
, x_versymp
+ i
, &iversym
);
1201 sym
->version
= iversym
.vs_vers
;
1204 /* Do some backend-specific processing on this symbol. */
1206 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1207 if (ebd
->elf_backend_symbol_processing
)
1208 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1215 /* Do some backend-specific processing on this symbol table. */
1217 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1218 if (ebd
->elf_backend_symbol_table_processing
)
1219 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1222 /* We rely on the zalloc to clear out the final symbol entry. */
1224 symcount
= sym
- symbase
;
1226 /* Fill in the user's symbol pointer vector if needed. */
1234 *symptrs
++ = &sym
->symbol
;
1237 *symptrs
= 0; /* Final null pointer */
1240 if (x_versymp
!= NULL
)
1246 if (x_versymp
!= NULL
)
1253 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1257 elf_slurp_reloc_table_from_section (abfd
, asect
, rel_hdr
, reloc_count
,
1258 relents
, symbols
, dynamic
)
1261 Elf_Internal_Shdr
*rel_hdr
;
1262 bfd_size_type reloc_count
;
1267 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1268 PTR allocated
= NULL
;
1269 bfd_byte
*native_relocs
;
1274 allocated
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1275 if (allocated
== NULL
)
1278 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1279 || (bfd_read (allocated
, 1, rel_hdr
->sh_size
, abfd
)
1280 != rel_hdr
->sh_size
))
1283 native_relocs
= (bfd_byte
*) allocated
;
1285 entsize
= rel_hdr
->sh_entsize
;
1286 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1287 || entsize
== sizeof (Elf_External_Rela
));
1289 for (i
= 0, relent
= relents
;
1291 i
++, relent
++, native_relocs
+= entsize
)
1293 Elf_Internal_Rela rela
;
1294 Elf_Internal_Rel rel
;
1296 if (entsize
== sizeof (Elf_External_Rela
))
1297 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
1300 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
1301 rela
.r_offset
= rel
.r_offset
;
1302 rela
.r_info
= rel
.r_info
;
1306 /* The address of an ELF reloc is section relative for an object
1307 file, and absolute for an executable file or shared library.
1308 The address of a normal BFD reloc is always section relative,
1309 and the address of a dynamic reloc is absolute.. */
1310 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1311 relent
->address
= rela
.r_offset
;
1313 relent
->address
= rela
.r_offset
- asect
->vma
;
1315 if (ELF_R_SYM (rela
.r_info
) == 0)
1316 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1321 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1324 /* Canonicalize ELF section symbols. FIXME: Why? */
1325 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1326 relent
->sym_ptr_ptr
= ps
;
1328 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1331 relent
->addend
= rela
.r_addend
;
1333 if (entsize
== sizeof (Elf_External_Rela
))
1334 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1336 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
1339 if (allocated
!= NULL
)
1345 if (allocated
!= NULL
)
1350 /* Read in and swap the external relocs. */
1353 elf_slurp_reloc_table (abfd
, asect
, symbols
, dynamic
)
1359 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1360 Elf_Internal_Shdr
*rel_hdr
;
1361 Elf_Internal_Shdr
*rel_hdr2
;
1362 bfd_size_type reloc_count
;
1363 bfd_size_type reloc_count2
;
1366 if (asect
->relocation
!= NULL
)
1371 if ((asect
->flags
& SEC_RELOC
) == 0
1372 || asect
->reloc_count
== 0)
1375 rel_hdr
= &d
->rel_hdr
;
1376 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1377 rel_hdr2
= d
->rel_hdr2
;
1378 reloc_count2
= (rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0);
1380 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1381 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1382 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1387 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1388 case because relocations against this section may use the
1389 dynamic symbol table, and in that case bfd_section_from_shdr
1390 in elf.c does not update the RELOC_COUNT. */
1391 if (asect
->_raw_size
== 0)
1394 rel_hdr
= &d
->this_hdr
;
1395 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1400 relents
= ((arelent
*)
1402 (reloc_count
+ reloc_count2
) * sizeof (arelent
)));
1403 if (relents
== NULL
)
1406 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1407 rel_hdr
, reloc_count
,
1413 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1414 rel_hdr2
, reloc_count2
,
1415 relents
+ reloc_count
,
1419 asect
->relocation
= relents
;
1425 elf_debug_section (num
, hdr
)
1427 Elf_Internal_Shdr
*hdr
;
1429 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1430 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1433 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1434 (long) hdr
->sh_name
,
1435 (long) hdr
->sh_type
,
1436 (long) hdr
->sh_flags
);
1438 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1439 (long) hdr
->sh_addr
,
1440 (long) hdr
->sh_offset
,
1441 (long) hdr
->sh_size
);
1443 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1444 (long) hdr
->sh_link
,
1445 (long) hdr
->sh_info
,
1446 (long) hdr
->sh_addralign
);
1447 fprintf (stderr
, "sh_entsize = %ld\n",
1448 (long) hdr
->sh_entsize
);
1453 elf_debug_file (ehdrp
)
1454 Elf_Internal_Ehdr
*ehdrp
;
1456 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1457 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1458 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1459 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1460 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1461 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1462 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1466 elf_symbol_flags (flags
)
1469 static char buffer
[1024];
1472 if (flags
& BSF_LOCAL
)
1473 strcat (buffer
, " local");
1475 if (flags
& BSF_GLOBAL
)
1476 strcat (buffer
, " global");
1478 if (flags
& BSF_DEBUGGING
)
1479 strcat (buffer
, " debug");
1481 if (flags
& BSF_FUNCTION
)
1482 strcat (buffer
, " function");
1484 if (flags
& BSF_KEEP
)
1485 strcat (buffer
, " keep");
1487 if (flags
& BSF_KEEP_G
)
1488 strcat (buffer
, " keep_g");
1490 if (flags
& BSF_WEAK
)
1491 strcat (buffer
, " weak");
1493 if (flags
& BSF_SECTION_SYM
)
1494 strcat (buffer
, " section-sym");
1496 if (flags
& BSF_OLD_COMMON
)
1497 strcat (buffer
, " old-common");
1499 if (flags
& BSF_NOT_AT_END
)
1500 strcat (buffer
, " not-at-end");
1502 if (flags
& BSF_CONSTRUCTOR
)
1503 strcat (buffer
, " constructor");
1505 if (flags
& BSF_WARNING
)
1506 strcat (buffer
, " warning");
1508 if (flags
& BSF_INDIRECT
)
1509 strcat (buffer
, " indirect");
1511 if (flags
& BSF_FILE
)
1512 strcat (buffer
, " file");
1514 if (flags
& DYNAMIC
)
1515 strcat (buffer
, " dynamic");
1517 if (flags
& ~(BSF_LOCAL
1532 strcat (buffer
, " unknown-bits");
1538 #include "elfcore.h"
1539 #include "elflink.h"
1541 /* Size-dependent data and functions. */
1542 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1543 sizeof (Elf_External_Ehdr
),
1544 sizeof (Elf_External_Phdr
),
1545 sizeof (Elf_External_Shdr
),
1546 sizeof (Elf_External_Rel
),
1547 sizeof (Elf_External_Rela
),
1548 sizeof (Elf_External_Sym
),
1549 sizeof (Elf_External_Dyn
),
1550 sizeof (Elf_External_Note
),
1553 ARCH_SIZE
, FILE_ALIGN
,
1554 ELFCLASS
, EV_CURRENT
,
1555 elf_write_out_phdrs
,
1556 elf_write_shdrs_and_ehdr
,
1558 elf_swap_symbol_out
,
1559 elf_slurp_reloc_table
,
1560 elf_slurp_symbol_table
,