Commit | Line | Data |
---|---|---|
244ffee7 | 1 | /* ELF executable support for BFD. |
51fbf454 | 2 | Copyright 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. |
244ffee7 JK |
3 | |
4 | Written by Fred Fish @ Cygnus Support, from information published | |
5 | in "UNIX System V Release 4, Programmers Guide: ANSI C and | |
6 | Programming Support Tools". Sufficient support for gdb. | |
7 | ||
8 | Rewritten by Mark Eichin @ Cygnus Support, from information | |
9 | published in "System V Application Binary Interface", chapters 4 | |
10 | and 5, as well as the various "Processor Supplement" documents | |
11 | derived from it. Added support for assembler and other object file | |
12 | utilities. Further work done by Ken Raeburn (Cygnus Support), Michael | |
13 | Meissner (Open Software Foundation), and Peter Hoogenboom (University | |
14 | of Utah) to finish and extend this. | |
15 | ||
16 | This file is part of BFD, the Binary File Descriptor library. | |
17 | ||
18 | This program is free software; you can redistribute it and/or modify | |
19 | it under the terms of the GNU General Public License as published by | |
20 | the Free Software Foundation; either version 2 of the License, or | |
21 | (at your option) any later version. | |
22 | ||
23 | This program is distributed in the hope that it will be useful, | |
24 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
25 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
26 | GNU General Public License for more details. | |
27 | ||
28 | You should have received a copy of the GNU General Public License | |
29 | along with this program; if not, write to the Free Software | |
30 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
31 | ||
244ffee7 JK |
32 | /* Problems and other issues to resolve. |
33 | ||
34 | (1) BFD expects there to be some fixed number of "sections" in | |
35 | the object file. I.E. there is a "section_count" variable in the | |
36 | bfd structure which contains the number of sections. However, ELF | |
37 | supports multiple "views" of a file. In particular, with current | |
38 | implementations, executable files typically have two tables, a | |
39 | program header table and a section header table, both of which | |
40 | partition the executable. | |
41 | ||
42 | In ELF-speak, the "linking view" of the file uses the section header | |
43 | table to access "sections" within the file, and the "execution view" | |
44 | uses the program header table to access "segments" within the file. | |
45 | "Segments" typically may contain all the data from one or more | |
46 | "sections". | |
47 | ||
48 | Note that the section header table is optional in ELF executables, | |
49 | but it is this information that is most useful to gdb. If the | |
50 | section header table is missing, then gdb should probably try | |
51 | to make do with the program header table. (FIXME) | |
52 | ||
6a3eb9b6 KR |
53 | (2) The code in this file is compiled twice, once in 32-bit mode and |
54 | once in 64-bit mode. More of it should be made size-independent | |
55 | and moved into elf.c. | |
56 | ||
d24928c0 KR |
57 | (3) ELF section symbols are handled rather sloppily now. This should |
58 | be cleaned up, and ELF section symbols reconciled with BFD section | |
59 | symbols. | |
5546cc7e KR |
60 | |
61 | (4) We need a published spec for 64-bit ELF. We've got some stuff here | |
62 | that we're using for SPARC V9 64-bit chips, but don't assume that | |
63 | it's cast in stone. | |
d24928c0 | 64 | */ |
244ffee7 JK |
65 | |
66 | #include <string.h> /* For strrchr and friends */ | |
67 | #include "bfd.h" | |
68 | #include "sysdep.h" | |
6ec3bb6a | 69 | #include "bfdlink.h" |
244ffee7 JK |
70 | #include "libbfd.h" |
71 | #include "libelf.h" | |
72 | ||
32090b8e | 73 | /* Renaming structures, typedefs, macros and functions to be size-specific. */ |
244ffee7 | 74 | #define Elf_External_Ehdr NAME(Elf,External_Ehdr) |
244ffee7 | 75 | #define Elf_External_Sym NAME(Elf,External_Sym) |
244ffee7 | 76 | #define Elf_External_Shdr NAME(Elf,External_Shdr) |
244ffee7 | 77 | #define Elf_External_Phdr NAME(Elf,External_Phdr) |
244ffee7 JK |
78 | #define Elf_External_Rel NAME(Elf,External_Rel) |
79 | #define Elf_External_Rela NAME(Elf,External_Rela) | |
013dec1a | 80 | #define Elf_External_Dyn NAME(Elf,External_Dyn) |
244ffee7 | 81 | |
244ffee7 JK |
82 | #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command) |
83 | #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal) | |
cb71adf1 PS |
84 | #define elf_core_file_matches_executable_p \ |
85 | NAME(bfd_elf,core_file_matches_executable_p) | |
244ffee7 JK |
86 | #define elf_object_p NAME(bfd_elf,object_p) |
87 | #define elf_core_file_p NAME(bfd_elf,core_file_p) | |
244ffee7 | 88 | #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound) |
cb71adf1 PS |
89 | #define elf_get_dynamic_symtab_upper_bound \ |
90 | NAME(bfd_elf,get_dynamic_symtab_upper_bound) | |
013dec1a ILT |
91 | #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in) |
92 | #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in) | |
93 | #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out) | |
94 | #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out) | |
71edd06d ILT |
95 | #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in) |
96 | #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out) | |
013dec1a ILT |
97 | #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in) |
98 | #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out) | |
244ffee7 JK |
99 | #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound) |
100 | #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc) | |
101 | #define elf_get_symtab NAME(bfd_elf,get_symtab) | |
cb71adf1 PS |
102 | #define elf_canonicalize_dynamic_symtab \ |
103 | NAME(bfd_elf,canonicalize_dynamic_symtab) | |
244ffee7 JK |
104 | #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol) |
105 | #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info) | |
244ffee7 JK |
106 | #define elf_get_lineno NAME(bfd_elf,get_lineno) |
107 | #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach) | |
108 | #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line) | |
109 | #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers) | |
110 | #define elf_set_section_contents NAME(bfd_elf,set_section_contents) | |
111 | #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto) | |
112 | #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel) | |
f035cc47 | 113 | #define elf_find_section NAME(bfd_elf,find_section) |
6ec3bb6a | 114 | #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols) |
013dec1a | 115 | #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry) |
374d2ef9 ILT |
116 | #define elf_link_create_dynamic_sections \ |
117 | NAME(bfd_elf,link_create_dynamic_sections) | |
ede4eed4 | 118 | #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol |
6ec3bb6a | 119 | #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link) |
244ffee7 | 120 | |
6a3eb9b6 KR |
121 | #if ARCH_SIZE == 64 |
122 | #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y) | |
123 | #define ELF_R_SYM(X) ELF64_R_SYM(X) | |
6ec3bb6a | 124 | #define ELF_R_TYPE(X) ELF64_R_TYPE(X) |
32090b8e | 125 | #define ELFCLASS ELFCLASS64 |
f035cc47 | 126 | #define FILE_ALIGN 8 |
013dec1a | 127 | #define LOG_FILE_ALIGN 3 |
6a3eb9b6 KR |
128 | #endif |
129 | #if ARCH_SIZE == 32 | |
130 | #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y) | |
131 | #define ELF_R_SYM(X) ELF32_R_SYM(X) | |
6ec3bb6a | 132 | #define ELF_R_TYPE(X) ELF32_R_TYPE(X) |
32090b8e | 133 | #define ELFCLASS ELFCLASS32 |
f035cc47 | 134 | #define FILE_ALIGN 4 |
013dec1a | 135 | #define LOG_FILE_ALIGN 2 |
244ffee7 JK |
136 | #endif |
137 | ||
244ffee7 JK |
138 | /* Forward declarations of static functions */ |
139 | ||
ede4eed4 | 140 | #define elf_stringtab_init _bfd_elf_stringtab_init |
244ffee7 | 141 | |
ede4eed4 KR |
142 | extern struct bfd_strtab_hash *_bfd_elf_stringtab_init PARAMS ((void)); |
143 | #define section_from_elf_index bfd_section_from_elf_index | |
144 | extern boolean bfd_section_from_phdr PARAMS ((bfd *, Elf_Internal_Phdr *, | |
145 | int)); | |
146 | ||
147 | int _bfd_elf_section_from_bfd_section PARAMS ((bfd *, struct sec *)); | |
244ffee7 | 148 | |
cb71adf1 | 149 | static long elf_slurp_symbol_table PARAMS ((bfd *, asymbol **, boolean)); |
244ffee7 | 150 | |
ea617174 ILT |
151 | static boolean elf_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **)); |
152 | ||
ede4eed4 | 153 | int _bfd_elf_symbol_from_bfd_symbol PARAMS ((bfd *, |
1c6042ee | 154 | struct symbol_cache_entry **)); |
244ffee7 | 155 | |
0ef449df | 156 | static void write_relocs PARAMS ((bfd *, asection *, PTR)); |
013dec1a | 157 | static file_ptr align_file_position PARAMS ((file_ptr)); |
ede4eed4 KR |
158 | |
159 | boolean bfd_section_from_shdr PARAMS ((bfd *, unsigned int shindex)); | |
2e03ce18 | 160 | |
6a3eb9b6 | 161 | #ifdef DEBUG |
eb4267a3 | 162 | static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *)); |
6a3eb9b6 | 163 | static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *)); |
0ef449df | 164 | static char *elf_symbol_flags PARAMS ((flagword)); |
6a3eb9b6 | 165 | #endif |
32090b8e KR |
166 | \f |
167 | /* Structure swapping routines */ | |
168 | ||
6a3eb9b6 KR |
169 | /* Should perhaps use put_offset, put_word, etc. For now, the two versions |
170 | can be handled by explicitly specifying 32 bits or "the long type". */ | |
238ac6ec KR |
171 | #if ARCH_SIZE == 64 |
172 | #define put_word bfd_h_put_64 | |
173 | #define get_word bfd_h_get_64 | |
174 | #endif | |
175 | #if ARCH_SIZE == 32 | |
176 | #define put_word bfd_h_put_32 | |
177 | #define get_word bfd_h_get_32 | |
178 | #endif | |
179 | ||
244ffee7 JK |
180 | /* Translate an ELF symbol in external format into an ELF symbol in internal |
181 | format. */ | |
182 | ||
71edd06d | 183 | void |
1c6042ee ILT |
184 | elf_swap_symbol_in (abfd, src, dst) |
185 | bfd *abfd; | |
186 | Elf_External_Sym *src; | |
187 | Elf_Internal_Sym *dst; | |
244ffee7 JK |
188 | { |
189 | dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name); | |
238ac6ec KR |
190 | dst->st_value = get_word (abfd, (bfd_byte *) src->st_value); |
191 | dst->st_size = get_word (abfd, (bfd_byte *) src->st_size); | |
244ffee7 JK |
192 | dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info); |
193 | dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other); | |
194 | dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx); | |
195 | } | |
196 | ||
197 | /* Translate an ELF symbol in internal format into an ELF symbol in external | |
198 | format. */ | |
199 | ||
71edd06d | 200 | void |
ede4eed4 | 201 | elf_swap_symbol_out (abfd, src, cdst) |
1c6042ee ILT |
202 | bfd *abfd; |
203 | Elf_Internal_Sym *src; | |
ede4eed4 | 204 | char *cdst; |
244ffee7 | 205 | { |
ede4eed4 | 206 | Elf_External_Sym *dst = (Elf_External_Sym *) cdst; |
244ffee7 | 207 | bfd_h_put_32 (abfd, src->st_name, dst->st_name); |
238ac6ec KR |
208 | put_word (abfd, src->st_value, dst->st_value); |
209 | put_word (abfd, src->st_size, dst->st_size); | |
244ffee7 JK |
210 | bfd_h_put_8 (abfd, src->st_info, dst->st_info); |
211 | bfd_h_put_8 (abfd, src->st_other, dst->st_other); | |
212 | bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx); | |
213 | } | |
214 | ||
215 | ||
216 | /* Translate an ELF file header in external format into an ELF file header in | |
217 | internal format. */ | |
218 | ||
219 | static void | |
1c6042ee ILT |
220 | elf_swap_ehdr_in (abfd, src, dst) |
221 | bfd *abfd; | |
222 | Elf_External_Ehdr *src; | |
223 | Elf_Internal_Ehdr *dst; | |
244ffee7 JK |
224 | { |
225 | memcpy (dst->e_ident, src->e_ident, EI_NIDENT); | |
226 | dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type); | |
227 | dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine); | |
228 | dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version); | |
238ac6ec KR |
229 | dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry); |
230 | dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff); | |
231 | dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff); | |
244ffee7 JK |
232 | dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags); |
233 | dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize); | |
234 | dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize); | |
235 | dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum); | |
236 | dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize); | |
237 | dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum); | |
238 | dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx); | |
239 | } | |
240 | ||
241 | /* Translate an ELF file header in internal format into an ELF file header in | |
242 | external format. */ | |
243 | ||
244 | static void | |
1c6042ee ILT |
245 | elf_swap_ehdr_out (abfd, src, dst) |
246 | bfd *abfd; | |
247 | Elf_Internal_Ehdr *src; | |
248 | Elf_External_Ehdr *dst; | |
244ffee7 JK |
249 | { |
250 | memcpy (dst->e_ident, src->e_ident, EI_NIDENT); | |
251 | /* note that all elements of dst are *arrays of unsigned char* already... */ | |
252 | bfd_h_put_16 (abfd, src->e_type, dst->e_type); | |
253 | bfd_h_put_16 (abfd, src->e_machine, dst->e_machine); | |
254 | bfd_h_put_32 (abfd, src->e_version, dst->e_version); | |
238ac6ec KR |
255 | put_word (abfd, src->e_entry, dst->e_entry); |
256 | put_word (abfd, src->e_phoff, dst->e_phoff); | |
257 | put_word (abfd, src->e_shoff, dst->e_shoff); | |
244ffee7 JK |
258 | bfd_h_put_32 (abfd, src->e_flags, dst->e_flags); |
259 | bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize); | |
260 | bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize); | |
261 | bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum); | |
262 | bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize); | |
263 | bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum); | |
264 | bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx); | |
265 | } | |
266 | ||
267 | ||
268 | /* Translate an ELF section header table entry in external format into an | |
269 | ELF section header table entry in internal format. */ | |
270 | ||
271 | static void | |
1c6042ee ILT |
272 | elf_swap_shdr_in (abfd, src, dst) |
273 | bfd *abfd; | |
274 | Elf_External_Shdr *src; | |
275 | Elf_Internal_Shdr *dst; | |
244ffee7 JK |
276 | { |
277 | dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name); | |
278 | dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type); | |
238ac6ec KR |
279 | dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags); |
280 | dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr); | |
281 | dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset); | |
282 | dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size); | |
244ffee7 JK |
283 | dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link); |
284 | dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info); | |
238ac6ec KR |
285 | dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign); |
286 | dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize); | |
24f13b03 ILT |
287 | dst->bfd_section = NULL; |
288 | dst->contents = NULL; | |
244ffee7 JK |
289 | } |
290 | ||
291 | /* Translate an ELF section header table entry in internal format into an | |
292 | ELF section header table entry in external format. */ | |
293 | ||
294 | static void | |
1c6042ee ILT |
295 | elf_swap_shdr_out (abfd, src, dst) |
296 | bfd *abfd; | |
297 | Elf_Internal_Shdr *src; | |
298 | Elf_External_Shdr *dst; | |
244ffee7 JK |
299 | { |
300 | /* note that all elements of dst are *arrays of unsigned char* already... */ | |
301 | bfd_h_put_32 (abfd, src->sh_name, dst->sh_name); | |
302 | bfd_h_put_32 (abfd, src->sh_type, dst->sh_type); | |
238ac6ec KR |
303 | put_word (abfd, src->sh_flags, dst->sh_flags); |
304 | put_word (abfd, src->sh_addr, dst->sh_addr); | |
305 | put_word (abfd, src->sh_offset, dst->sh_offset); | |
306 | put_word (abfd, src->sh_size, dst->sh_size); | |
244ffee7 JK |
307 | bfd_h_put_32 (abfd, src->sh_link, dst->sh_link); |
308 | bfd_h_put_32 (abfd, src->sh_info, dst->sh_info); | |
238ac6ec KR |
309 | put_word (abfd, src->sh_addralign, dst->sh_addralign); |
310 | put_word (abfd, src->sh_entsize, dst->sh_entsize); | |
244ffee7 JK |
311 | } |
312 | ||
313 | ||
314 | /* Translate an ELF program header table entry in external format into an | |
315 | ELF program header table entry in internal format. */ | |
316 | ||
317 | static void | |
1c6042ee ILT |
318 | elf_swap_phdr_in (abfd, src, dst) |
319 | bfd *abfd; | |
320 | Elf_External_Phdr *src; | |
321 | Elf_Internal_Phdr *dst; | |
244ffee7 JK |
322 | { |
323 | dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type); | |
244ffee7 | 324 | dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags); |
238ac6ec KR |
325 | dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset); |
326 | dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr); | |
327 | dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr); | |
328 | dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz); | |
329 | dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz); | |
330 | dst->p_align = get_word (abfd, (bfd_byte *) src->p_align); | |
244ffee7 JK |
331 | } |
332 | ||
244ffee7 | 333 | static void |
1c6042ee ILT |
334 | elf_swap_phdr_out (abfd, src, dst) |
335 | bfd *abfd; | |
336 | Elf_Internal_Phdr *src; | |
337 | Elf_External_Phdr *dst; | |
244ffee7 JK |
338 | { |
339 | /* note that all elements of dst are *arrays of unsigned char* already... */ | |
340 | bfd_h_put_32 (abfd, src->p_type, dst->p_type); | |
94dbb655 KR |
341 | put_word (abfd, src->p_offset, dst->p_offset); |
342 | put_word (abfd, src->p_vaddr, dst->p_vaddr); | |
343 | put_word (abfd, src->p_paddr, dst->p_paddr); | |
344 | put_word (abfd, src->p_filesz, dst->p_filesz); | |
345 | put_word (abfd, src->p_memsz, dst->p_memsz); | |
244ffee7 | 346 | bfd_h_put_32 (abfd, src->p_flags, dst->p_flags); |
94dbb655 | 347 | put_word (abfd, src->p_align, dst->p_align); |
244ffee7 JK |
348 | } |
349 | ||
350 | /* Translate an ELF reloc from external format to internal format. */ | |
013dec1a | 351 | INLINE void |
1c6042ee ILT |
352 | elf_swap_reloc_in (abfd, src, dst) |
353 | bfd *abfd; | |
354 | Elf_External_Rel *src; | |
355 | Elf_Internal_Rel *dst; | |
244ffee7 | 356 | { |
94dbb655 KR |
357 | dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset); |
358 | dst->r_info = get_word (abfd, (bfd_byte *) src->r_info); | |
244ffee7 JK |
359 | } |
360 | ||
013dec1a | 361 | INLINE void |
1c6042ee ILT |
362 | elf_swap_reloca_in (abfd, src, dst) |
363 | bfd *abfd; | |
364 | Elf_External_Rela *src; | |
365 | Elf_Internal_Rela *dst; | |
244ffee7 | 366 | { |
94dbb655 KR |
367 | dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset); |
368 | dst->r_info = get_word (abfd, (bfd_byte *) src->r_info); | |
369 | dst->r_addend = get_word (abfd, (bfd_byte *) src->r_addend); | |
244ffee7 JK |
370 | } |
371 | ||
372 | /* Translate an ELF reloc from internal format to external format. */ | |
013dec1a | 373 | INLINE void |
1c6042ee ILT |
374 | elf_swap_reloc_out (abfd, src, dst) |
375 | bfd *abfd; | |
376 | Elf_Internal_Rel *src; | |
377 | Elf_External_Rel *dst; | |
244ffee7 | 378 | { |
94dbb655 KR |
379 | put_word (abfd, src->r_offset, dst->r_offset); |
380 | put_word (abfd, src->r_info, dst->r_info); | |
244ffee7 JK |
381 | } |
382 | ||
013dec1a | 383 | INLINE void |
1c6042ee ILT |
384 | elf_swap_reloca_out (abfd, src, dst) |
385 | bfd *abfd; | |
386 | Elf_Internal_Rela *src; | |
387 | Elf_External_Rela *dst; | |
244ffee7 | 388 | { |
94dbb655 KR |
389 | put_word (abfd, src->r_offset, dst->r_offset); |
390 | put_word (abfd, src->r_info, dst->r_info); | |
391 | put_word (abfd, src->r_addend, dst->r_addend); | |
244ffee7 | 392 | } |
32090b8e | 393 | |
013dec1a ILT |
394 | INLINE void |
395 | elf_swap_dyn_in (abfd, src, dst) | |
396 | bfd *abfd; | |
397 | const Elf_External_Dyn *src; | |
398 | Elf_Internal_Dyn *dst; | |
399 | { | |
400 | dst->d_tag = get_word (abfd, src->d_tag); | |
401 | dst->d_un.d_val = get_word (abfd, src->d_un.d_val); | |
402 | } | |
1c6042ee | 403 | |
013dec1a ILT |
404 | INLINE void |
405 | elf_swap_dyn_out (abfd, src, dst) | |
406 | bfd *abfd; | |
407 | const Elf_Internal_Dyn *src; | |
408 | Elf_External_Dyn *dst; | |
409 | { | |
410 | put_word (abfd, src->d_tag, dst->d_tag); | |
411 | put_word (abfd, src->d_un.d_val, dst->d_un.d_val); | |
412 | } | |
413 | \f | |
32090b8e KR |
414 | /* ELF .o/exec file reading */ |
415 | ||
244ffee7 | 416 | |
32090b8e | 417 | /* Begin processing a given object. |
244ffee7 | 418 | |
32090b8e KR |
419 | First we validate the file by reading in the ELF header and checking |
420 | the magic number. */ | |
421 | ||
422 | static INLINE boolean | |
1c6042ee ILT |
423 | elf_file_p (x_ehdrp) |
424 | Elf_External_Ehdr *x_ehdrp; | |
244ffee7 | 425 | { |
32090b8e KR |
426 | return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0) |
427 | && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1) | |
428 | && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2) | |
429 | && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3)); | |
430 | } | |
244ffee7 | 431 | |
d24928c0 KR |
432 | /* Check to see if the file associated with ABFD matches the target vector |
433 | that ABFD points to. | |
434 | ||
435 | Note that we may be called several times with the same ABFD, but different | |
436 | target vectors, most of which will not match. We have to avoid leaving | |
437 | any side effects in ABFD, or any data it points to (like tdata), if the | |
6ec3bb6a | 438 | file does not match the target vector. */ |
d24928c0 | 439 | |
2f3508ad | 440 | const bfd_target * |
1c6042ee ILT |
441 | elf_object_p (abfd) |
442 | bfd *abfd; | |
244ffee7 | 443 | { |
32090b8e KR |
444 | Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ |
445 | Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ | |
446 | Elf_External_Shdr x_shdr; /* Section header table entry, external form */ | |
6ec3bb6a | 447 | Elf_Internal_Shdr *i_shdrp = NULL; /* Section header table, internal form */ |
68241b2b | 448 | unsigned int shindex; |
32090b8e | 449 | char *shstrtab; /* Internal copy of section header stringtab */ |
062189c6 | 450 | struct elf_backend_data *ebd; |
d24928c0 | 451 | struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd); |
6ec3bb6a | 452 | struct elf_obj_tdata *new_tdata = NULL; |
244ffee7 | 453 | |
32090b8e KR |
454 | /* Read in the ELF header in external format. */ |
455 | ||
456 | if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr)) | |
25057836 JL |
457 | { |
458 | if (bfd_get_error () != bfd_error_system_call) | |
459 | goto got_wrong_format_error; | |
460 | else | |
461 | goto got_no_match; | |
462 | } | |
244ffee7 | 463 | |
32090b8e KR |
464 | /* Now check to see if we have a valid ELF file, and one that BFD can |
465 | make use of. The magic number must match, the address size ('class') | |
466 | and byte-swapping must match our XVEC entry, and it must have a | |
467 | section header table (FIXME: See comments re sections at top of this | |
468 | file). */ | |
244ffee7 | 469 | |
d24928c0 KR |
470 | if ((elf_file_p (&x_ehdr) == false) || |
471 | (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) || | |
472 | (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)) | |
473 | goto got_wrong_format_error; | |
244ffee7 | 474 | |
d24928c0 | 475 | /* Check that file's byte order matches xvec's */ |
32090b8e | 476 | switch (x_ehdr.e_ident[EI_DATA]) |
244ffee7 | 477 | { |
32090b8e KR |
478 | case ELFDATA2MSB: /* Big-endian */ |
479 | if (!abfd->xvec->header_byteorder_big_p) | |
d24928c0 | 480 | goto got_wrong_format_error; |
32090b8e KR |
481 | break; |
482 | case ELFDATA2LSB: /* Little-endian */ | |
483 | if (abfd->xvec->header_byteorder_big_p) | |
d24928c0 | 484 | goto got_wrong_format_error; |
32090b8e KR |
485 | break; |
486 | case ELFDATANONE: /* No data encoding specified */ | |
487 | default: /* Unknown data encoding specified */ | |
d24928c0 | 488 | goto got_wrong_format_error; |
244ffee7 | 489 | } |
244ffee7 | 490 | |
32090b8e | 491 | /* Allocate an instance of the elf_obj_tdata structure and hook it up to |
6ec3bb6a | 492 | the tdata pointer in the bfd. */ |
244ffee7 | 493 | |
6ec3bb6a ILT |
494 | new_tdata = ((struct elf_obj_tdata *) |
495 | bfd_zalloc (abfd, sizeof (struct elf_obj_tdata))); | |
496 | if (new_tdata == NULL) | |
d24928c0 | 497 | goto got_no_memory_error; |
6ec3bb6a | 498 | elf_tdata (abfd) = new_tdata; |
244ffee7 | 499 | |
32090b8e KR |
500 | /* Now that we know the byte order, swap in the rest of the header */ |
501 | i_ehdrp = elf_elfheader (abfd); | |
502 | elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp); | |
503 | #if DEBUG & 1 | |
504 | elf_debug_file (i_ehdrp); | |
244ffee7 JK |
505 | #endif |
506 | ||
32090b8e KR |
507 | /* If there is no section header table, we're hosed. */ |
508 | if (i_ehdrp->e_shoff == 0) | |
d24928c0 | 509 | goto got_wrong_format_error; |
244ffee7 | 510 | |
062189c6 ILT |
511 | /* As a simple sanity check, verify that the what BFD thinks is the |
512 | size of each section header table entry actually matches the size | |
513 | recorded in the file. */ | |
514 | if (i_ehdrp->e_shentsize != sizeof (x_shdr)) | |
515 | goto got_wrong_format_error; | |
516 | ||
517 | ebd = get_elf_backend_data (abfd); | |
518 | ||
519 | /* Check that the ELF e_machine field matches what this particular | |
520 | BFD format expects. */ | |
df168c35 DE |
521 | if (ebd->elf_machine_code != i_ehdrp->e_machine |
522 | && (ebd->elf_machine_alt1 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt1) | |
523 | && (ebd->elf_machine_alt2 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt2)) | |
062189c6 | 524 | { |
2f3508ad | 525 | const bfd_target * const *target_ptr; |
062189c6 ILT |
526 | |
527 | if (ebd->elf_machine_code != EM_NONE) | |
528 | goto got_wrong_format_error; | |
529 | ||
530 | /* This is the generic ELF target. Let it match any ELF target | |
531 | for which we do not have a specific backend. */ | |
f4bd7a8f | 532 | for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++) |
062189c6 ILT |
533 | { |
534 | struct elf_backend_data *back; | |
535 | ||
536 | if ((*target_ptr)->flavour != bfd_target_elf_flavour) | |
537 | continue; | |
538 | back = (struct elf_backend_data *) (*target_ptr)->backend_data; | |
539 | if (back->elf_machine_code == i_ehdrp->e_machine) | |
540 | { | |
541 | /* target_ptr is an ELF backend which matches this | |
542 | object file, so reject the generic ELF target. */ | |
543 | goto got_wrong_format_error; | |
544 | } | |
545 | } | |
546 | } | |
547 | ||
7b8106b4 | 548 | if (i_ehdrp->e_type == ET_EXEC) |
32090b8e | 549 | abfd->flags |= EXEC_P; |
7b8106b4 ILT |
550 | else if (i_ehdrp->e_type == ET_DYN) |
551 | abfd->flags |= DYNAMIC; | |
244ffee7 | 552 | |
fa15568a ILT |
553 | if (i_ehdrp->e_phnum > 0) |
554 | abfd->flags |= D_PAGED; | |
555 | ||
6ec3bb6a ILT |
556 | if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)) |
557 | goto got_no_match; | |
32090b8e | 558 | |
062189c6 ILT |
559 | /* Remember the entry point specified in the ELF file header. */ |
560 | bfd_get_start_address (abfd) = i_ehdrp->e_entry; | |
32090b8e KR |
561 | |
562 | /* Allocate space for a copy of the section header table in | |
563 | internal form, seek to the section header table in the file, | |
062189c6 | 564 | read it in, and convert it to internal form. */ |
6ec3bb6a ILT |
565 | i_shdrp = ((Elf_Internal_Shdr *) |
566 | bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum)); | |
567 | elf_elfsections (abfd) = ((Elf_Internal_Shdr **) | |
568 | bfd_alloc (abfd, | |
569 | sizeof (i_shdrp) * i_ehdrp->e_shnum)); | |
1c6042ee | 570 | if (!i_shdrp || !elf_elfsections (abfd)) |
d24928c0 | 571 | goto got_no_memory_error; |
6ec3bb6a | 572 | if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) != 0) |
25057836 | 573 | goto got_no_match; |
32090b8e | 574 | for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++) |
244ffee7 | 575 | { |
d24928c0 | 576 | if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr)) |
25057836 | 577 | goto got_no_match; |
32090b8e | 578 | elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex); |
1c6042ee | 579 | elf_elfsections (abfd)[shindex] = i_shdrp + shindex; |
244ffee7 | 580 | } |
32090b8e | 581 | if (i_ehdrp->e_shstrndx) |
244ffee7 | 582 | { |
2e03ce18 ILT |
583 | if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx)) |
584 | goto got_no_match; | |
244ffee7 JK |
585 | } |
586 | ||
32090b8e KR |
587 | /* Read in the string table containing the names of the sections. We |
588 | will need the base pointer to this table later. */ | |
589 | /* We read this inline now, so that we don't have to go through | |
590 | bfd_section_from_shdr with it (since this particular strtab is | |
591 | used to find all of the ELF section names.) */ | |
244ffee7 | 592 | |
ede4eed4 | 593 | shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx); |
32090b8e | 594 | if (!shstrtab) |
6ec3bb6a | 595 | goto got_no_match; |
244ffee7 | 596 | |
32090b8e KR |
597 | /* Once all of the section headers have been read and converted, we |
598 | can start processing them. Note that the first section header is | |
6ec3bb6a | 599 | a dummy placeholder entry, so we ignore it. */ |
244ffee7 | 600 | |
32090b8e KR |
601 | for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++) |
602 | { | |
2e03ce18 ILT |
603 | if (! bfd_section_from_shdr (abfd, shindex)) |
604 | goto got_no_match; | |
32090b8e | 605 | } |
244ffee7 | 606 | |
5315c428 ILT |
607 | /* Let the backend double check the format and override global |
608 | information. */ | |
609 | if (ebd->elf_backend_object_p) | |
610 | { | |
611 | if ((*ebd->elf_backend_object_p) (abfd) == false) | |
612 | goto got_wrong_format_error; | |
613 | } | |
614 | ||
d24928c0 KR |
615 | return (abfd->xvec); |
616 | ||
1c6042ee | 617 | got_wrong_format_error: |
d1ad85a6 | 618 | bfd_set_error (bfd_error_wrong_format); |
d24928c0 | 619 | goto got_no_match; |
1c6042ee | 620 | got_no_memory_error: |
d1ad85a6 | 621 | bfd_set_error (bfd_error_no_memory); |
d24928c0 | 622 | goto got_no_match; |
1c6042ee | 623 | got_no_match: |
6ec3bb6a ILT |
624 | if (new_tdata != NULL |
625 | && new_tdata->elf_sect_ptr != NULL) | |
626 | bfd_release (abfd, new_tdata->elf_sect_ptr); | |
627 | if (i_shdrp != NULL) | |
628 | bfd_release (abfd, i_shdrp); | |
629 | if (new_tdata != NULL) | |
630 | bfd_release (abfd, new_tdata); | |
d24928c0 KR |
631 | elf_tdata (abfd) = preserved_tdata; |
632 | return (NULL); | |
32090b8e | 633 | } |
32090b8e | 634 | \f |
1c6042ee | 635 | |
32090b8e KR |
636 | /* ELF .o/exec file writing */ |
637 | ||
0ef449df KR |
638 | static void |
639 | write_relocs (abfd, sec, data) | |
32090b8e KR |
640 | bfd *abfd; |
641 | asection *sec; | |
0ef449df | 642 | PTR data; |
32090b8e | 643 | { |
0ef449df | 644 | boolean *failedp = (boolean *) data; |
32090b8e KR |
645 | Elf_Internal_Shdr *rela_hdr; |
646 | Elf_External_Rela *outbound_relocas; | |
647 | Elf_External_Rel *outbound_relocs; | |
648 | int idx; | |
649 | int use_rela_p = get_elf_backend_data (abfd)->use_rela_p; | |
300adb31 | 650 | asymbol *last_sym = 0; |
38a5f510 | 651 | int last_sym_idx = 9999999; /* should always be written before use */ |
244ffee7 | 652 | |
0ef449df KR |
653 | /* If we have already failed, don't do anything. */ |
654 | if (*failedp) | |
655 | return; | |
656 | ||
32090b8e KR |
657 | if ((sec->flags & SEC_RELOC) == 0) |
658 | return; | |
6ec3bb6a ILT |
659 | |
660 | /* The linker backend writes the relocs out itself, and sets the | |
661 | reloc_count field to zero to inhibit writing them here. Also, | |
662 | sometimes the SEC_RELOC flag gets set even when there aren't any | |
663 | relocs. */ | |
32090b8e KR |
664 | if (sec->reloc_count == 0) |
665 | return; | |
244ffee7 | 666 | |
32090b8e | 667 | rela_hdr = &elf_section_data (sec)->rel_hdr; |
244ffee7 | 668 | |
32090b8e | 669 | rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count; |
0ef449df KR |
670 | rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size); |
671 | if (rela_hdr->contents == NULL) | |
9783e04a | 672 | { |
d1ad85a6 | 673 | bfd_set_error (bfd_error_no_memory); |
0ef449df KR |
674 | *failedp = true; |
675 | return; | |
9783e04a | 676 | } |
244ffee7 | 677 | |
32090b8e | 678 | /* orelocation has the data, reloc_count has the count... */ |
300adb31 KR |
679 | if (use_rela_p) |
680 | { | |
681 | outbound_relocas = (Elf_External_Rela *) rela_hdr->contents; | |
682 | ||
683 | for (idx = 0; idx < sec->reloc_count; idx++) | |
32090b8e | 684 | { |
300adb31 KR |
685 | Elf_Internal_Rela dst_rela; |
686 | Elf_External_Rela *src_rela; | |
687 | arelent *ptr; | |
688 | asymbol *sym; | |
689 | int n; | |
690 | ||
691 | ptr = sec->orelocation[idx]; | |
692 | src_rela = outbound_relocas + idx; | |
4c124191 ILT |
693 | |
694 | /* The address of an ELF reloc is section relative for an object | |
695 | file, and absolute for an executable file or shared library. | |
696 | The address of a BFD reloc is always section relative. */ | |
697 | if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) | |
300adb31 | 698 | dst_rela.r_offset = ptr->address; |
4c124191 ILT |
699 | else |
700 | dst_rela.r_offset = ptr->address + sec->vma; | |
6a3eb9b6 | 701 | |
300adb31 KR |
702 | sym = *ptr->sym_ptr_ptr; |
703 | if (sym == last_sym) | |
704 | n = last_sym_idx; | |
705 | else | |
32090b8e | 706 | { |
300adb31 | 707 | last_sym = sym; |
ede4eed4 | 708 | last_sym_idx = n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); |
32090b8e | 709 | } |
300adb31 KR |
710 | dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type); |
711 | ||
712 | dst_rela.r_addend = ptr->addend; | |
713 | elf_swap_reloca_out (abfd, &dst_rela, src_rela); | |
244ffee7 | 714 | } |
300adb31 KR |
715 | } |
716 | else | |
717 | /* REL relocations */ | |
718 | { | |
719 | outbound_relocs = (Elf_External_Rel *) rela_hdr->contents; | |
720 | ||
721 | for (idx = 0; idx < sec->reloc_count; idx++) | |
32090b8e | 722 | { |
300adb31 KR |
723 | Elf_Internal_Rel dst_rel; |
724 | Elf_External_Rel *src_rel; | |
725 | arelent *ptr; | |
726 | int n; | |
727 | asymbol *sym; | |
728 | ||
729 | ptr = sec->orelocation[idx]; | |
730 | sym = *ptr->sym_ptr_ptr; | |
731 | src_rel = outbound_relocs + idx; | |
4c124191 ILT |
732 | |
733 | /* The address of an ELF reloc is section relative for an object | |
734 | file, and absolute for an executable file or shared library. | |
735 | The address of a BFD reloc is always section relative. */ | |
736 | if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) | |
300adb31 | 737 | dst_rel.r_offset = ptr->address; |
4c124191 ILT |
738 | else |
739 | dst_rel.r_offset = ptr->address + sec->vma; | |
244ffee7 | 740 | |
300adb31 KR |
741 | if (sym == last_sym) |
742 | n = last_sym_idx; | |
743 | else | |
32090b8e | 744 | { |
300adb31 | 745 | last_sym = sym; |
ede4eed4 | 746 | last_sym_idx = n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); |
32090b8e | 747 | } |
300adb31 KR |
748 | dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type); |
749 | ||
750 | elf_swap_reloc_out (abfd, &dst_rel, src_rel); | |
32090b8e | 751 | } |
300adb31 | 752 | } |
32090b8e | 753 | } |
244ffee7 | 754 | |
ede4eed4 KR |
755 | /* Align to the maximum file alignment that could be required for any |
756 | ELF data structure. */ | |
244ffee7 | 757 | |
ede4eed4 KR |
758 | static INLINE file_ptr |
759 | align_file_position (off) | |
760 | file_ptr off; | |
32090b8e | 761 | { |
ede4eed4 KR |
762 | return (off + FILE_ALIGN - 1) & ~(FILE_ALIGN - 1); |
763 | } | |
f035cc47 | 764 | |
ede4eed4 KR |
765 | static int |
766 | write_out_phdrs (abfd, phdr, count) | |
767 | bfd *abfd; | |
768 | Elf_Internal_Phdr *phdr; | |
769 | int count; | |
770 | { | |
771 | while (count--) | |
fa15568a | 772 | { |
ede4eed4 KR |
773 | Elf_External_Phdr extphdr; |
774 | elf_swap_phdr_out (abfd, phdr, &extphdr); | |
775 | if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd) | |
776 | != sizeof (Elf_External_Phdr)) | |
777 | return -1; | |
778 | phdr++; | |
fa15568a | 779 | } |
ede4eed4 | 780 | return 0; |
fa15568a | 781 | } |
244ffee7 | 782 | |
fa15568a | 783 | static boolean |
ede4eed4 | 784 | write_shdrs_and_ehdr (abfd) |
fa15568a ILT |
785 | bfd *abfd; |
786 | { | |
ede4eed4 KR |
787 | Elf_External_Ehdr x_ehdr; /* Elf file header, external form */ |
788 | Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */ | |
789 | Elf_External_Shdr *x_shdrp; /* Section header table, external form */ | |
790 | Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */ | |
791 | unsigned int count; | |
7c726b66 | 792 | |
ede4eed4 KR |
793 | i_ehdrp = elf_elfheader (abfd); |
794 | i_shdrp = elf_elfsections (abfd); | |
7c726b66 | 795 | |
ede4eed4 | 796 | /* swap the header before spitting it out... */ |
fa15568a | 797 | |
ede4eed4 KR |
798 | #if DEBUG & 1 |
799 | elf_debug_file (i_ehdrp); | |
800 | #endif | |
801 | elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr); | |
802 | if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0 | |
803 | || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) | |
804 | != sizeof (x_ehdr))) | |
805 | return false; | |
fa15568a | 806 | |
ede4eed4 KR |
807 | /* at this point we've concocted all the ELF sections... */ |
808 | x_shdrp = (Elf_External_Shdr *) | |
809 | bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum)); | |
810 | if (!x_shdrp) | |
fa15568a | 811 | { |
fa15568a ILT |
812 | bfd_set_error (bfd_error_no_memory); |
813 | return false; | |
814 | } | |
fa15568a | 815 | |
ede4eed4 | 816 | for (count = 0; count < i_ehdrp->e_shnum; count++) |
fa15568a | 817 | { |
ede4eed4 KR |
818 | #if DEBUG & 2 |
819 | elf_debug_section (count, i_shdrp[count]); | |
820 | #endif | |
821 | elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count); | |
fa15568a | 822 | } |
ede4eed4 KR |
823 | if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0 |
824 | || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd) | |
825 | != sizeof (*x_shdrp) * i_ehdrp->e_shnum)) | |
826 | return false; | |
fa15568a | 827 | |
ede4eed4 | 828 | /* need to dump the string table too... */ |
fa15568a ILT |
829 | |
830 | return true; | |
244ffee7 JK |
831 | } |
832 | ||
ede4eed4 KR |
833 | static long |
834 | elf_slurp_symbol_table (abfd, symptrs, dynamic) | |
062189c6 | 835 | bfd *abfd; |
ede4eed4 KR |
836 | asymbol **symptrs; /* Buffer for generated bfd symbols */ |
837 | boolean dynamic; | |
32090b8e | 838 | { |
ede4eed4 KR |
839 | Elf_Internal_Shdr *hdr; |
840 | long symcount; /* Number of external ELF symbols */ | |
841 | elf_symbol_type *sym; /* Pointer to current bfd symbol */ | |
842 | elf_symbol_type *symbase; /* Buffer for generated bfd symbols */ | |
843 | Elf_Internal_Sym i_sym; | |
844 | Elf_External_Sym *x_symp = NULL; | |
244ffee7 | 845 | |
ede4eed4 KR |
846 | /* Read each raw ELF symbol, converting from external ELF form to |
847 | internal ELF form, and then using the information to create a | |
848 | canonical bfd symbol table entry. | |
6a3eb9b6 | 849 | |
ede4eed4 KR |
850 | Note that we allocate the initial bfd canonical symbol buffer |
851 | based on a one-to-one mapping of the ELF symbols to canonical | |
852 | symbols. We actually use all the ELF symbols, so there will be no | |
853 | space left over at the end. When we have all the symbols, we | |
854 | build the caller's pointer vector. */ | |
244ffee7 | 855 | |
ede4eed4 KR |
856 | if (dynamic) |
857 | hdr = &elf_tdata (abfd)->dynsymtab_hdr; | |
858 | else | |
859 | hdr = &elf_tdata (abfd)->symtab_hdr; | |
860 | if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1) | |
861 | return -1; | |
244ffee7 | 862 | |
ede4eed4 | 863 | symcount = hdr->sh_size / sizeof (Elf_External_Sym); |
d24928c0 | 864 | |
ede4eed4 KR |
865 | if (symcount == 0) |
866 | sym = symbase = NULL; | |
867 | else | |
e621c5cc | 868 | { |
ede4eed4 | 869 | long i; |
24f13b03 | 870 | |
ede4eed4 KR |
871 | if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1) |
872 | return -1; | |
6ec3bb6a | 873 | |
ede4eed4 KR |
874 | symbase = ((elf_symbol_type *) |
875 | bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type))); | |
876 | if (symbase == (elf_symbol_type *) NULL) | |
6ec3bb6a | 877 | { |
ede4eed4 KR |
878 | bfd_set_error (bfd_error_no_memory); |
879 | return -1; | |
6ec3bb6a | 880 | } |
ede4eed4 | 881 | sym = symbase; |
6ec3bb6a | 882 | |
ede4eed4 KR |
883 | /* Temporarily allocate room for the raw ELF symbols. */ |
884 | x_symp = ((Elf_External_Sym *) | |
885 | malloc (symcount * sizeof (Elf_External_Sym))); | |
886 | if (x_symp == NULL && symcount != 0) | |
6ec3bb6a | 887 | { |
ede4eed4 KR |
888 | bfd_set_error (bfd_error_no_memory); |
889 | goto error_return; | |
6ec3bb6a | 890 | } |
1c640609 | 891 | |
ede4eed4 KR |
892 | if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd) |
893 | != symcount * sizeof (Elf_External_Sym)) | |
894 | goto error_return; | |
895 | /* Skip first symbol, which is a null dummy. */ | |
896 | for (i = 1; i < symcount; i++) | |
6ec3bb6a | 897 | { |
ede4eed4 KR |
898 | elf_swap_symbol_in (abfd, x_symp + i, &i_sym); |
899 | memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym)); | |
900 | #ifdef ELF_KEEP_EXTSYM | |
901 | memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym)); | |
6ec3bb6a | 902 | #endif |
ede4eed4 | 903 | sym->symbol.the_bfd = abfd; |
6ec3bb6a | 904 | |
ede4eed4 KR |
905 | sym->symbol.name = bfd_elf_string_from_elf_section (abfd, |
906 | hdr->sh_link, | |
907 | i_sym.st_name); | |
6ec3bb6a | 908 | |
ede4eed4 | 909 | sym->symbol.value = i_sym.st_value; |
6ec3bb6a | 910 | |
ede4eed4 | 911 | if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE) |
6ec3bb6a | 912 | { |
ede4eed4 KR |
913 | sym->symbol.section = section_from_elf_index (abfd, |
914 | i_sym.st_shndx); | |
915 | if (sym->symbol.section == NULL) | |
6ec3bb6a | 916 | { |
ede4eed4 KR |
917 | /* This symbol is in a section for which we did not |
918 | create a BFD section. Just use bfd_abs_section, | |
919 | although it is wrong. FIXME. */ | |
920 | sym->symbol.section = bfd_abs_section_ptr; | |
6ec3bb6a ILT |
921 | } |
922 | } | |
ede4eed4 | 923 | else if (i_sym.st_shndx == SHN_ABS) |
6ec3bb6a | 924 | { |
ede4eed4 | 925 | sym->symbol.section = bfd_abs_section_ptr; |
6ec3bb6a | 926 | } |
ede4eed4 | 927 | else if (i_sym.st_shndx == SHN_COMMON) |
6ec3bb6a | 928 | { |
ede4eed4 KR |
929 | sym->symbol.section = bfd_com_section_ptr; |
930 | /* Elf puts the alignment into the `value' field, and | |
931 | the size into the `size' field. BFD wants to see the | |
932 | size in the value field, and doesn't care (at the | |
933 | moment) about the alignment. */ | |
934 | sym->symbol.value = i_sym.st_size; | |
6ec3bb6a | 935 | } |
ede4eed4 | 936 | else if (i_sym.st_shndx == SHN_UNDEF) |
6ec3bb6a | 937 | { |
ede4eed4 | 938 | sym->symbol.section = bfd_und_section_ptr; |
6ec3bb6a ILT |
939 | } |
940 | else | |
ede4eed4 | 941 | sym->symbol.section = bfd_abs_section_ptr; |
013dec1a | 942 | |
ede4eed4 | 943 | sym->symbol.value -= sym->symbol.section->vma; |
013dec1a | 944 | |
ede4eed4 | 945 | switch (ELF_ST_BIND (i_sym.st_info)) |
013dec1a | 946 | { |
ede4eed4 KR |
947 | case STB_LOCAL: |
948 | sym->symbol.flags |= BSF_LOCAL; | |
197e30e5 | 949 | break; |
ede4eed4 KR |
950 | case STB_GLOBAL: |
951 | if (i_sym.st_shndx != SHN_UNDEF | |
952 | && i_sym.st_shndx != SHN_COMMON) | |
953 | sym->symbol.flags |= BSF_GLOBAL; | |
013dec1a | 954 | break; |
ede4eed4 KR |
955 | case STB_WEAK: |
956 | sym->symbol.flags |= BSF_WEAK; | |
013dec1a ILT |
957 | break; |
958 | } | |
013dec1a | 959 | |
ede4eed4 | 960 | switch (ELF_ST_TYPE (i_sym.st_info)) |
eb4267a3 | 961 | { |
ede4eed4 KR |
962 | case STT_SECTION: |
963 | sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING; | |
964 | break; | |
965 | case STT_FILE: | |
966 | sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING; | |
967 | break; | |
968 | case STT_FUNC: | |
969 | sym->symbol.flags |= BSF_FUNCTION; | |
970 | break; | |
eb4267a3 | 971 | } |
6ec3bb6a | 972 | |
ede4eed4 KR |
973 | if (dynamic) |
974 | sym->symbol.flags |= BSF_DYNAMIC; | |
3c9832f8 | 975 | |
ede4eed4 KR |
976 | /* Do some backend-specific processing on this symbol. */ |
977 | { | |
978 | struct elf_backend_data *ebd = get_elf_backend_data (abfd); | |
979 | if (ebd->elf_backend_symbol_processing) | |
980 | (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol); | |
981 | } | |
6ec3bb6a | 982 | |
ede4eed4 KR |
983 | sym++; |
984 | } | |
6ec3bb6a ILT |
985 | } |
986 | ||
ede4eed4 KR |
987 | /* Do some backend-specific processing on this symbol table. */ |
988 | { | |
989 | struct elf_backend_data *ebd = get_elf_backend_data (abfd); | |
990 | if (ebd->elf_backend_symbol_table_processing) | |
991 | (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount); | |
992 | } | |
6ec3bb6a | 993 | |
ede4eed4 | 994 | /* We rely on the zalloc to clear out the final symbol entry. */ |
6ec3bb6a | 995 | |
ede4eed4 | 996 | symcount = sym - symbase; |
71edd06d | 997 | |
ede4eed4 KR |
998 | /* Fill in the user's symbol pointer vector if needed. */ |
999 | if (symptrs) | |
6ec3bb6a | 1000 | { |
ede4eed4 | 1001 | long l = symcount; |
6ec3bb6a | 1002 | |
ede4eed4 KR |
1003 | sym = symbase; |
1004 | while (l-- > 0) | |
1005 | { | |
1006 | *symptrs++ = &sym->symbol; | |
1007 | sym++; | |
1008 | } | |
1009 | *symptrs = 0; /* Final null pointer */ | |
6ec3bb6a ILT |
1010 | } |
1011 | ||
ede4eed4 KR |
1012 | if (x_symp != NULL) |
1013 | free (x_symp); | |
1014 | return symcount; | |
1015 | error_return: | |
1016 | if (x_symp != NULL) | |
1017 | free (x_symp); | |
1018 | return -1; | |
6ec3bb6a ILT |
1019 | } |
1020 | ||
ede4eed4 | 1021 | /* Read in and swap the external relocs. */ |
6ec3bb6a ILT |
1022 | |
1023 | static boolean | |
ede4eed4 KR |
1024 | elf_slurp_reloc_table (abfd, asect, symbols) |
1025 | bfd *abfd; | |
1026 | asection *asect; | |
1027 | asymbol **symbols; | |
6ec3bb6a | 1028 | { |
ede4eed4 KR |
1029 | struct elf_backend_data * const ebd = get_elf_backend_data (abfd); |
1030 | struct bfd_elf_section_data * const d = elf_section_data (asect); | |
1031 | PTR allocated = NULL; | |
1032 | bfd_byte *native_relocs; | |
1033 | arelent *relents; | |
1034 | arelent *relent; | |
1035 | unsigned int i; | |
1036 | int entsize; | |
013dec1a | 1037 | |
ede4eed4 KR |
1038 | if (asect->relocation != NULL |
1039 | || (asect->flags & SEC_RELOC) == 0 | |
1040 | || asect->reloc_count == 0) | |
6ec3bb6a ILT |
1041 | return true; |
1042 | ||
ede4eed4 KR |
1043 | BFD_ASSERT (asect->rel_filepos == d->rel_hdr.sh_offset |
1044 | && (asect->reloc_count | |
1045 | == d->rel_hdr.sh_size / d->rel_hdr.sh_entsize)); | |
6ec3bb6a | 1046 | |
ede4eed4 KR |
1047 | allocated = (PTR) malloc (d->rel_hdr.sh_size); |
1048 | if (allocated == NULL) | |
6ec3bb6a | 1049 | { |
ede4eed4 KR |
1050 | bfd_set_error (bfd_error_no_memory); |
1051 | goto error_return; | |
1052 | } | |
6ec3bb6a | 1053 | |
ede4eed4 KR |
1054 | if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0 |
1055 | || (bfd_read (allocated, 1, d->rel_hdr.sh_size, abfd) | |
1056 | != d->rel_hdr.sh_size)) | |
1057 | goto error_return; | |
6ec3bb6a | 1058 | |
ede4eed4 | 1059 | native_relocs = (bfd_byte *) allocated; |
6ec3bb6a | 1060 | |
ede4eed4 KR |
1061 | relents = ((arelent *) |
1062 | bfd_alloc (abfd, asect->reloc_count * sizeof (arelent))); | |
1063 | if (relents == NULL) | |
1064 | { | |
1065 | bfd_set_error (bfd_error_no_memory); | |
1066 | goto error_return; | |
6ec3bb6a ILT |
1067 | } |
1068 | ||
ede4eed4 KR |
1069 | entsize = d->rel_hdr.sh_entsize; |
1070 | BFD_ASSERT (entsize == sizeof (Elf_External_Rel) | |
1071 | || entsize == sizeof (Elf_External_Rela)); | |
1072 | ||
1073 | for (i = 0, relent = relents; | |
1074 | i < asect->reloc_count; | |
1075 | i++, relent++, native_relocs += entsize) | |
013dec1a | 1076 | { |
ede4eed4 KR |
1077 | Elf_Internal_Rela rela; |
1078 | Elf_Internal_Rel rel; | |
1079 | ||
1080 | if (entsize == sizeof (Elf_External_Rela)) | |
1081 | elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela); | |
1082 | else | |
013dec1a | 1083 | { |
ede4eed4 KR |
1084 | elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel); |
1085 | rela.r_offset = rel.r_offset; | |
1086 | rela.r_info = rel.r_info; | |
1087 | rela.r_addend = 0; | |
013dec1a ILT |
1088 | } |
1089 | ||
ede4eed4 KR |
1090 | /* The address of an ELF reloc is section relative for an object |
1091 | file, and absolute for an executable file or shared library. | |
1092 | The address of a BFD reloc is always section relative. */ | |
1093 | if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) | |
1094 | relent->address = rela.r_offset; | |
1095 | else | |
1096 | relent->address = rela.r_offset - asect->vma; | |
6ec3bb6a | 1097 | |
ede4eed4 KR |
1098 | if (ELF_R_SYM (rela.r_info) == 0) |
1099 | relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; | |
1100 | else | |
1101 | { | |
1102 | asymbol **ps, *s; | |
6ec3bb6a | 1103 | |
ede4eed4 KR |
1104 | ps = symbols + ELF_R_SYM (rela.r_info) - 1; |
1105 | s = *ps; | |
6ec3bb6a | 1106 | |
ede4eed4 KR |
1107 | /* Canonicalize ELF section symbols. FIXME: Why? */ |
1108 | if ((s->flags & BSF_SECTION_SYM) == 0) | |
1109 | relent->sym_ptr_ptr = ps; | |
1110 | else | |
1111 | relent->sym_ptr_ptr = s->section->symbol_ptr_ptr; | |
1112 | } | |
6ec3bb6a | 1113 | |
ede4eed4 | 1114 | relent->addend = rela.r_addend; |
013dec1a | 1115 | |
ede4eed4 KR |
1116 | if (entsize == sizeof (Elf_External_Rela)) |
1117 | (*ebd->elf_info_to_howto) (abfd, relent, &rela); | |
1118 | else | |
1119 | (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel); | |
5315c428 ILT |
1120 | } |
1121 | ||
ede4eed4 | 1122 | asect->relocation = relents; |
6ec3bb6a | 1123 | |
ede4eed4 KR |
1124 | if (allocated != NULL) |
1125 | free (allocated); | |
6ec3bb6a | 1126 | |
ede4eed4 | 1127 | return true; |
6ec3bb6a | 1128 | |
ede4eed4 KR |
1129 | error_return: |
1130 | if (allocated != NULL) | |
1131 | free (allocated); | |
1132 | return false; | |
1133 | } | |
5315c428 | 1134 | |
ede4eed4 KR |
1135 | #ifdef DEBUG |
1136 | static void | |
1137 | elf_debug_section (num, hdr) | |
1138 | int num; | |
1139 | Elf_Internal_Shdr *hdr; | |
1140 | { | |
1141 | fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num, | |
1142 | hdr->bfd_section != NULL ? hdr->bfd_section->name : "", | |
1143 | (long) hdr); | |
1144 | fprintf (stderr, | |
1145 | "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n", | |
1146 | (long) hdr->sh_name, | |
1147 | (long) hdr->sh_type, | |
1148 | (long) hdr->sh_flags); | |
1149 | fprintf (stderr, | |
1150 | "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n", | |
1151 | (long) hdr->sh_addr, | |
1152 | (long) hdr->sh_offset, | |
1153 | (long) hdr->sh_size); | |
1154 | fprintf (stderr, | |
1155 | "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n", | |
1156 | (long) hdr->sh_link, | |
1157 | (long) hdr->sh_info, | |
1158 | (long) hdr->sh_addralign); | |
1159 | fprintf (stderr, "sh_entsize = %ld\n", | |
1160 | (long) hdr->sh_entsize); | |
1161 | fflush (stderr); | |
1162 | } | |
6ec3bb6a | 1163 | |
ede4eed4 KR |
1164 | static void |
1165 | elf_debug_file (ehdrp) | |
1166 | Elf_Internal_Ehdr *ehdrp; | |
1167 | { | |
1168 | fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry); | |
1169 | fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff); | |
1170 | fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum); | |
1171 | fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize); | |
1172 | fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff); | |
1173 | fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum); | |
1174 | fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize); | |
1175 | } | |
6ec3bb6a | 1176 | |
ede4eed4 KR |
1177 | static char * |
1178 | elf_symbol_flags (flags) | |
1179 | flagword flags; | |
1180 | { | |
1181 | static char buffer[1024]; | |
6ec3bb6a | 1182 | |
ede4eed4 KR |
1183 | buffer[0] = '\0'; |
1184 | if (flags & BSF_LOCAL) | |
1185 | strcat (buffer, " local"); | |
8af74670 | 1186 | |
ede4eed4 KR |
1187 | if (flags & BSF_GLOBAL) |
1188 | strcat (buffer, " global"); | |
6ec3bb6a | 1189 | |
ede4eed4 KR |
1190 | if (flags & BSF_DEBUGGING) |
1191 | strcat (buffer, " debug"); | |
6ec3bb6a | 1192 | |
ede4eed4 KR |
1193 | if (flags & BSF_FUNCTION) |
1194 | strcat (buffer, " function"); | |
6ec3bb6a | 1195 | |
ede4eed4 KR |
1196 | if (flags & BSF_KEEP) |
1197 | strcat (buffer, " keep"); | |
6ec3bb6a | 1198 | |
ede4eed4 KR |
1199 | if (flags & BSF_KEEP_G) |
1200 | strcat (buffer, " keep_g"); | |
6ec3bb6a | 1201 | |
ede4eed4 KR |
1202 | if (flags & BSF_WEAK) |
1203 | strcat (buffer, " weak"); | |
6ec3bb6a | 1204 | |
ede4eed4 KR |
1205 | if (flags & BSF_SECTION_SYM) |
1206 | strcat (buffer, " section-sym"); | |
6ec3bb6a | 1207 | |
ede4eed4 KR |
1208 | if (flags & BSF_OLD_COMMON) |
1209 | strcat (buffer, " old-common"); | |
6ec3bb6a | 1210 | |
ede4eed4 KR |
1211 | if (flags & BSF_NOT_AT_END) |
1212 | strcat (buffer, " not-at-end"); | |
6ec3bb6a | 1213 | |
ede4eed4 KR |
1214 | if (flags & BSF_CONSTRUCTOR) |
1215 | strcat (buffer, " constructor"); | |
6ec3bb6a | 1216 | |
ede4eed4 KR |
1217 | if (flags & BSF_WARNING) |
1218 | strcat (buffer, " warning"); | |
6ec3bb6a | 1219 | |
ede4eed4 KR |
1220 | if (flags & BSF_INDIRECT) |
1221 | strcat (buffer, " indirect"); | |
6ec3bb6a | 1222 | |
ede4eed4 KR |
1223 | if (flags & BSF_FILE) |
1224 | strcat (buffer, " file"); | |
6ec3bb6a | 1225 | |
ede4eed4 KR |
1226 | if (flags & DYNAMIC) |
1227 | strcat (buffer, " dynamic"); | |
6ec3bb6a | 1228 | |
ede4eed4 KR |
1229 | if (flags & ~(BSF_LOCAL |
1230 | | BSF_GLOBAL | |
1231 | | BSF_DEBUGGING | |
1232 | | BSF_FUNCTION | |
1233 | | BSF_KEEP | |
1234 | | BSF_KEEP_G | |
1235 | | BSF_WEAK | |
1236 | | BSF_SECTION_SYM | |
1237 | | BSF_OLD_COMMON | |
1238 | | BSF_NOT_AT_END | |
1239 | | BSF_CONSTRUCTOR | |
1240 | | BSF_WARNING | |
1241 | | BSF_INDIRECT | |
1242 | | BSF_FILE | |
1243 | | BSF_DYNAMIC)) | |
1244 | strcat (buffer, " unknown-bits"); | |
6ec3bb6a | 1245 | |
ede4eed4 | 1246 | return buffer; |
6ec3bb6a | 1247 | } |
ede4eed4 KR |
1248 | #endif |
1249 | \f | |
1250 | #include "elfcore.h" | |
1251 | #include "elflink.h" | |
1252 | \f | |
1253 | /* Size-dependent data and functions. */ | |
1254 | const struct elf_size_info NAME(_bfd_elf,size_info) = { | |
1255 | sizeof (Elf_External_Ehdr), | |
1256 | sizeof (Elf_External_Phdr), | |
1257 | sizeof (Elf_External_Shdr), | |
1258 | sizeof (Elf_External_Rel), | |
1259 | sizeof (Elf_External_Rela), | |
1260 | sizeof (Elf_External_Sym), | |
1261 | sizeof (Elf_External_Dyn), | |
1262 | sizeof (Elf_External_Note), | |
1263 | ||
1264 | ARCH_SIZE, FILE_ALIGN, | |
1265 | ELFCLASS, EV_CURRENT, | |
1266 | &write_out_phdrs, | |
1267 | &write_shdrs_and_ehdr, | |
1268 | &write_relocs, | |
1269 | &elf_swap_symbol_out, | |
1270 | &elf_slurp_reloc_table, | |
1271 | &elf_slurp_symbol_table, | |
1272 | }; |