daily update
[binutils.git] / bfd / elfcode.h
blobc356638d088e2270c4502e5e2e1765274770afb9
1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 Written by Fred Fish @ Cygnus Support, from information published
7 in "UNIX System V Release 4, Programmers Guide: ANSI C and
8 Programming Support Tools". Sufficient support for gdb.
10 Rewritten by Mark Eichin @ Cygnus Support, from information
11 published in "System V Application Binary Interface", chapters 4
12 and 5, as well as the various "Processor Supplement" documents
13 derived from it. Added support for assembler and other object file
14 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
15 Meissner (Open Software Foundation), and Peter Hoogenboom (University
16 of Utah) to finish and extend this.
18 This file is part of BFD, the Binary File Descriptor library.
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 3 of the License, or
23 (at your option) any later version.
25 This program is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
30 You should have received a copy of the GNU General Public License
31 along with this program; if not, write to the Free Software
32 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
33 MA 02110-1301, USA. */
36 /* Problems and other issues to resolve.
38 (1) BFD expects there to be some fixed number of "sections" in
39 the object file. I.E. there is a "section_count" variable in the
40 bfd structure which contains the number of sections. However, ELF
41 supports multiple "views" of a file. In particular, with current
42 implementations, executable files typically have two tables, a
43 program header table and a section header table, both of which
44 partition the executable.
46 In ELF-speak, the "linking view" of the file uses the section header
47 table to access "sections" within the file, and the "execution view"
48 uses the program header table to access "segments" within the file.
49 "Segments" typically may contain all the data from one or more
50 "sections".
52 Note that the section header table is optional in ELF executables,
53 but it is this information that is most useful to gdb. If the
54 section header table is missing, then gdb should probably try
55 to make do with the program header table. (FIXME)
57 (2) The code in this file is compiled twice, once in 32-bit mode and
58 once in 64-bit mode. More of it should be made size-independent
59 and moved into elf.c.
61 (3) ELF section symbols are handled rather sloppily now. This should
62 be cleaned up, and ELF section symbols reconciled with BFD section
63 symbols.
65 (4) We need a published spec for 64-bit ELF. We've got some stuff here
66 that we're using for SPARC V9 64-bit chips, but don't assume that
67 it's cast in stone.
70 #include "sysdep.h"
71 #include "bfd.h"
72 #include "libiberty.h"
73 #include "bfdlink.h"
74 #include "libbfd.h"
75 #include "elf-bfd.h"
77 /* Renaming structures, typedefs, macros and functions to be size-specific. */
78 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
79 #define Elf_External_Sym NAME(Elf,External_Sym)
80 #define Elf_External_Shdr NAME(Elf,External_Shdr)
81 #define Elf_External_Phdr NAME(Elf,External_Phdr)
82 #define Elf_External_Rel NAME(Elf,External_Rel)
83 #define Elf_External_Rela NAME(Elf,External_Rela)
84 #define Elf_External_Dyn NAME(Elf,External_Dyn)
86 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
87 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
88 #define elf_core_file_matches_executable_p \
89 NAME(bfd_elf,core_file_matches_executable_p)
90 #define elf_object_p NAME(bfd_elf,object_p)
91 #define elf_core_file_p NAME(bfd_elf,core_file_p)
92 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
93 #define elf_get_dynamic_symtab_upper_bound \
94 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
95 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
96 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
97 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
98 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
99 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
100 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
101 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
102 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
103 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
104 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
105 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
106 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
107 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
108 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
109 #define elf_canonicalize_dynamic_symtab \
110 NAME(bfd_elf,canonicalize_dynamic_symtab)
111 #define elf_get_synthetic_symtab \
112 NAME(bfd_elf,get_synthetic_symtab)
113 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
114 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
115 #define elf_get_lineno NAME(bfd_elf,get_lineno)
116 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
117 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
118 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
119 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
120 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
121 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
122 #define elf_find_section NAME(bfd_elf,find_section)
123 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
124 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
125 #define elf_checksum_contents NAME(bfd_elf,checksum_contents)
126 #define elf_write_relocs NAME(bfd_elf,write_relocs)
127 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
129 #if ARCH_SIZE == 64
130 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
131 #define ELF_R_SYM(X) ELF64_R_SYM(X)
132 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
133 #define ELFCLASS ELFCLASS64
134 #define FILE_ALIGN 8
135 #define LOG_FILE_ALIGN 3
136 #endif
137 #if ARCH_SIZE == 32
138 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
139 #define ELF_R_SYM(X) ELF32_R_SYM(X)
140 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
141 #define ELFCLASS ELFCLASS32
142 #define FILE_ALIGN 4
143 #define LOG_FILE_ALIGN 2
144 #endif
146 #if DEBUG & 2
147 static void elf_debug_section (int, Elf_Internal_Shdr *);
148 #endif
149 #if DEBUG & 1
150 static void elf_debug_file (Elf_Internal_Ehdr *);
151 #endif
153 /* Structure swapping routines */
155 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
156 can be handled by explicitly specifying 32 bits or "the long type". */
157 #if ARCH_SIZE == 64
158 #define H_PUT_WORD H_PUT_64
159 #define H_PUT_SIGNED_WORD H_PUT_S64
160 #define H_GET_WORD H_GET_64
161 #define H_GET_SIGNED_WORD H_GET_S64
162 #endif
163 #if ARCH_SIZE == 32
164 #define H_PUT_WORD H_PUT_32
165 #define H_PUT_SIGNED_WORD H_PUT_S32
166 #define H_GET_WORD H_GET_32
167 #define H_GET_SIGNED_WORD H_GET_S32
168 #endif
170 /* Translate an ELF symbol in external format into an ELF symbol in internal
171 format. */
173 bfd_boolean
174 elf_swap_symbol_in (bfd *abfd,
175 const void *psrc,
176 const void *pshn,
177 Elf_Internal_Sym *dst)
179 const Elf_External_Sym *src = psrc;
180 const Elf_External_Sym_Shndx *shndx = pshn;
181 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
183 dst->st_name = H_GET_32 (abfd, src->st_name);
184 if (signed_vma)
185 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
186 else
187 dst->st_value = H_GET_WORD (abfd, src->st_value);
188 dst->st_size = H_GET_WORD (abfd, src->st_size);
189 dst->st_info = H_GET_8 (abfd, src->st_info);
190 dst->st_other = H_GET_8 (abfd, src->st_other);
191 dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
192 if (dst->st_shndx == (SHN_XINDEX & 0xffff))
194 if (shndx == NULL)
195 return FALSE;
196 dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
198 else if (dst->st_shndx >= (SHN_LORESERVE & 0xffff))
199 dst->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
200 return TRUE;
203 /* Translate an ELF symbol in internal format into an ELF symbol in external
204 format. */
206 void
207 elf_swap_symbol_out (bfd *abfd,
208 const Elf_Internal_Sym *src,
209 void *cdst,
210 void *shndx)
212 unsigned int tmp;
213 Elf_External_Sym *dst = cdst;
214 H_PUT_32 (abfd, src->st_name, dst->st_name);
215 H_PUT_WORD (abfd, src->st_value, dst->st_value);
216 H_PUT_WORD (abfd, src->st_size, dst->st_size);
217 H_PUT_8 (abfd, src->st_info, dst->st_info);
218 H_PUT_8 (abfd, src->st_other, dst->st_other);
219 tmp = src->st_shndx;
220 if (tmp >= (SHN_LORESERVE & 0xffff) && tmp < SHN_LORESERVE)
222 if (shndx == NULL)
223 abort ();
224 H_PUT_32 (abfd, tmp, shndx);
225 tmp = SHN_XINDEX & 0xffff;
227 H_PUT_16 (abfd, tmp, dst->st_shndx);
230 /* Translate an ELF file header in external format into an ELF file header in
231 internal format. */
233 static void
234 elf_swap_ehdr_in (bfd *abfd,
235 const Elf_External_Ehdr *src,
236 Elf_Internal_Ehdr *dst)
238 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
239 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
240 dst->e_type = H_GET_16 (abfd, src->e_type);
241 dst->e_machine = H_GET_16 (abfd, src->e_machine);
242 dst->e_version = H_GET_32 (abfd, src->e_version);
243 if (signed_vma)
244 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
245 else
246 dst->e_entry = H_GET_WORD (abfd, src->e_entry);
247 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
248 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
249 dst->e_flags = H_GET_32 (abfd, src->e_flags);
250 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
251 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
252 dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
253 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
254 dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
255 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
258 /* Translate an ELF file header in internal format into an ELF file header in
259 external format. */
261 static void
262 elf_swap_ehdr_out (bfd *abfd,
263 const Elf_Internal_Ehdr *src,
264 Elf_External_Ehdr *dst)
266 unsigned int tmp;
267 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
268 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
269 /* note that all elements of dst are *arrays of unsigned char* already... */
270 H_PUT_16 (abfd, src->e_type, dst->e_type);
271 H_PUT_16 (abfd, src->e_machine, dst->e_machine);
272 H_PUT_32 (abfd, src->e_version, dst->e_version);
273 if (signed_vma)
274 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
275 else
276 H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
277 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
278 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
279 H_PUT_32 (abfd, src->e_flags, dst->e_flags);
280 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
281 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
282 H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
283 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
284 tmp = src->e_shnum;
285 if (tmp >= (SHN_LORESERVE & 0xffff))
286 tmp = SHN_UNDEF;
287 H_PUT_16 (abfd, tmp, dst->e_shnum);
288 tmp = src->e_shstrndx;
289 if (tmp >= (SHN_LORESERVE & 0xffff))
290 tmp = SHN_XINDEX & 0xffff;
291 H_PUT_16 (abfd, tmp, dst->e_shstrndx);
294 /* Translate an ELF section header table entry in external format into an
295 ELF section header table entry in internal format. */
297 static void
298 elf_swap_shdr_in (bfd *abfd,
299 const Elf_External_Shdr *src,
300 Elf_Internal_Shdr *dst)
302 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
304 dst->sh_name = H_GET_32 (abfd, src->sh_name);
305 dst->sh_type = H_GET_32 (abfd, src->sh_type);
306 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
307 if (signed_vma)
308 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
309 else
310 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
311 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
312 dst->sh_size = H_GET_WORD (abfd, src->sh_size);
313 dst->sh_link = H_GET_32 (abfd, src->sh_link);
314 dst->sh_info = H_GET_32 (abfd, src->sh_info);
315 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
316 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
317 dst->bfd_section = NULL;
318 dst->contents = NULL;
321 /* Translate an ELF section header table entry in internal format into an
322 ELF section header table entry in external format. */
324 static void
325 elf_swap_shdr_out (bfd *abfd,
326 const Elf_Internal_Shdr *src,
327 Elf_External_Shdr *dst)
329 /* note that all elements of dst are *arrays of unsigned char* already... */
330 H_PUT_32 (abfd, src->sh_name, dst->sh_name);
331 H_PUT_32 (abfd, src->sh_type, dst->sh_type);
332 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
333 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
334 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
335 H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
336 H_PUT_32 (abfd, src->sh_link, dst->sh_link);
337 H_PUT_32 (abfd, src->sh_info, dst->sh_info);
338 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
339 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
342 /* Translate an ELF program header table entry in external format into an
343 ELF program header table entry in internal format. */
345 void
346 elf_swap_phdr_in (bfd *abfd,
347 const Elf_External_Phdr *src,
348 Elf_Internal_Phdr *dst)
350 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
352 dst->p_type = H_GET_32 (abfd, src->p_type);
353 dst->p_flags = H_GET_32 (abfd, src->p_flags);
354 dst->p_offset = H_GET_WORD (abfd, src->p_offset);
355 if (signed_vma)
357 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
358 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
360 else
362 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
363 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
365 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
366 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
367 dst->p_align = H_GET_WORD (abfd, src->p_align);
370 void
371 elf_swap_phdr_out (bfd *abfd,
372 const Elf_Internal_Phdr *src,
373 Elf_External_Phdr *dst)
375 const struct elf_backend_data *bed;
376 bfd_vma p_paddr;
378 bed = get_elf_backend_data (abfd);
379 p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
381 /* note that all elements of dst are *arrays of unsigned char* already... */
382 H_PUT_32 (abfd, src->p_type, dst->p_type);
383 H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
384 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
385 H_PUT_WORD (abfd, p_paddr, dst->p_paddr);
386 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
387 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
388 H_PUT_32 (abfd, src->p_flags, dst->p_flags);
389 H_PUT_WORD (abfd, src->p_align, dst->p_align);
392 /* Translate an ELF reloc from external format to internal format. */
393 void
394 elf_swap_reloc_in (bfd *abfd,
395 const bfd_byte *s,
396 Elf_Internal_Rela *dst)
398 const Elf_External_Rel *src = (const Elf_External_Rel *) s;
399 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
400 dst->r_info = H_GET_WORD (abfd, src->r_info);
401 dst->r_addend = 0;
404 void
405 elf_swap_reloca_in (bfd *abfd,
406 const bfd_byte *s,
407 Elf_Internal_Rela *dst)
409 const Elf_External_Rela *src = (const Elf_External_Rela *) s;
410 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
411 dst->r_info = H_GET_WORD (abfd, src->r_info);
412 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
415 /* Translate an ELF reloc from internal format to external format. */
416 void
417 elf_swap_reloc_out (bfd *abfd,
418 const Elf_Internal_Rela *src,
419 bfd_byte *d)
421 Elf_External_Rel *dst = (Elf_External_Rel *) d;
422 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
423 H_PUT_WORD (abfd, src->r_info, dst->r_info);
426 void
427 elf_swap_reloca_out (bfd *abfd,
428 const Elf_Internal_Rela *src,
429 bfd_byte *d)
431 Elf_External_Rela *dst = (Elf_External_Rela *) d;
432 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
433 H_PUT_WORD (abfd, src->r_info, dst->r_info);
434 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
437 void
438 elf_swap_dyn_in (bfd *abfd,
439 const void *p,
440 Elf_Internal_Dyn *dst)
442 const Elf_External_Dyn *src = p;
444 dst->d_tag = H_GET_WORD (abfd, src->d_tag);
445 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
448 void
449 elf_swap_dyn_out (bfd *abfd,
450 const Elf_Internal_Dyn *src,
451 void *p)
453 Elf_External_Dyn *dst = p;
455 H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
456 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
459 /* ELF .o/exec file reading */
461 /* Begin processing a given object.
463 First we validate the file by reading in the ELF header and checking
464 the magic number. */
466 static inline bfd_boolean
467 elf_file_p (Elf_External_Ehdr *x_ehdrp)
469 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
470 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
471 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
472 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
475 /* Check to see if the file associated with ABFD matches the target vector
476 that ABFD points to.
478 Note that we may be called several times with the same ABFD, but different
479 target vectors, most of which will not match. We have to avoid leaving
480 any side effects in ABFD, or any data it points to (like tdata), if the
481 file does not match the target vector. */
483 const bfd_target *
484 elf_object_p (bfd *abfd)
486 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
487 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
488 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
489 Elf_Internal_Shdr i_shdr;
490 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
491 unsigned int shindex;
492 const struct elf_backend_data *ebd;
493 struct bfd_preserve preserve;
494 asection *s;
495 bfd_size_type amt;
496 const bfd_target *target;
497 const bfd_target * const *target_ptr;
499 preserve.marker = NULL;
501 /* Read in the ELF header in external format. */
503 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
505 if (bfd_get_error () != bfd_error_system_call)
506 goto got_wrong_format_error;
507 else
508 goto got_no_match;
511 /* Now check to see if we have a valid ELF file, and one that BFD can
512 make use of. The magic number must match, the address size ('class')
513 and byte-swapping must match our XVEC entry, and it must have a
514 section header table (FIXME: See comments re sections at top of this
515 file). */
517 if (! elf_file_p (&x_ehdr)
518 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
519 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
520 goto got_wrong_format_error;
522 /* Check that file's byte order matches xvec's */
523 switch (x_ehdr.e_ident[EI_DATA])
525 case ELFDATA2MSB: /* Big-endian */
526 if (! bfd_header_big_endian (abfd))
527 goto got_wrong_format_error;
528 break;
529 case ELFDATA2LSB: /* Little-endian */
530 if (! bfd_header_little_endian (abfd))
531 goto got_wrong_format_error;
532 break;
533 case ELFDATANONE: /* No data encoding specified */
534 default: /* Unknown data encoding specified */
535 goto got_wrong_format_error;
538 if (!bfd_preserve_save (abfd, &preserve))
539 goto got_no_match;
541 target = abfd->xvec;
543 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
544 the tdata pointer in the bfd. */
546 if (! (*target->_bfd_set_format[bfd_object]) (abfd))
547 goto got_no_match;
548 preserve.marker = elf_tdata (abfd);
550 /* Now that we know the byte order, swap in the rest of the header */
551 i_ehdrp = elf_elfheader (abfd);
552 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
553 #if DEBUG & 1
554 elf_debug_file (i_ehdrp);
555 #endif
557 /* Reject ET_CORE (header indicates core file, not object file) */
558 if (i_ehdrp->e_type == ET_CORE)
559 goto got_wrong_format_error;
561 /* If this is a relocatable file and there is no section header
562 table, then we're hosed. */
563 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
564 goto got_wrong_format_error;
566 /* As a simple sanity check, verify that what BFD thinks is the
567 size of each section header table entry actually matches the size
568 recorded in the file, but only if there are any sections. */
569 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
570 goto got_wrong_format_error;
572 /* Further sanity check. */
573 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
574 goto got_wrong_format_error;
576 ebd = get_elf_backend_data (abfd);
578 /* Check that the ELF e_machine field matches what this particular
579 BFD format expects. */
580 if (ebd->elf_machine_code != i_ehdrp->e_machine
581 && (ebd->elf_machine_alt1 == 0
582 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
583 && (ebd->elf_machine_alt2 == 0
584 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
586 if (ebd->elf_machine_code != EM_NONE)
587 goto got_wrong_format_error;
589 /* This is the generic ELF target. Let it match any ELF target
590 for which we do not have a specific backend. */
591 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
593 const struct elf_backend_data *back;
595 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
596 continue;
597 back = xvec_get_elf_backend_data (*target_ptr);
598 if (back->elf_machine_code == i_ehdrp->e_machine
599 || (back->elf_machine_alt1 != 0
600 && back->elf_machine_alt1 == i_ehdrp->e_machine)
601 || (back->elf_machine_alt2 != 0
602 && back->elf_machine_alt2 == i_ehdrp->e_machine))
604 /* target_ptr is an ELF backend which matches this
605 object file, so reject the generic ELF target. */
606 goto got_wrong_format_error;
611 if (i_ehdrp->e_type == ET_EXEC)
612 abfd->flags |= EXEC_P;
613 else if (i_ehdrp->e_type == ET_DYN)
614 abfd->flags |= DYNAMIC;
616 if (i_ehdrp->e_phnum > 0)
617 abfd->flags |= D_PAGED;
619 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
621 /* It's OK if this fails for the generic target. */
622 if (ebd->elf_machine_code != EM_NONE)
623 goto got_no_match;
626 if (ebd->elf_machine_code != EM_NONE
627 && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi)
629 if (ebd->elf_osabi != ELFOSABI_NONE)
630 goto got_wrong_format_error;
632 /* This is an ELFOSABI_NONE ELF target. Let it match any ELF
633 target of the compatible machine for which we do not have a
634 backend with matching ELFOSABI. */
635 for (target_ptr = bfd_target_vector;
636 *target_ptr != NULL;
637 target_ptr++)
639 const struct elf_backend_data *back;
641 /* Skip this target and targets with incompatible byte
642 order. */
643 if (*target_ptr == target
644 || (*target_ptr)->flavour != bfd_target_elf_flavour
645 || (*target_ptr)->byteorder != target->byteorder
646 || ((*target_ptr)->header_byteorder
647 != target->header_byteorder))
648 continue;
650 back = xvec_get_elf_backend_data (*target_ptr);
651 if (back->elf_osabi == i_ehdrp->e_ident[EI_OSABI]
652 && (back->elf_machine_code == i_ehdrp->e_machine
653 || (back->elf_machine_alt1 != 0
654 && back->elf_machine_alt1 == i_ehdrp->e_machine)
655 || (back->elf_machine_alt2 != 0
656 && back->elf_machine_alt2 == i_ehdrp->e_machine)))
658 /* target_ptr is an ELF backend which matches this
659 object file, so reject the ELFOSABI_NONE ELF target. */
660 goto got_wrong_format_error;
665 if (i_ehdrp->e_shoff != 0)
667 bfd_signed_vma where = i_ehdrp->e_shoff;
669 if (where != (file_ptr) where)
670 goto got_wrong_format_error;
672 /* Seek to the section header table in the file. */
673 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
674 goto got_no_match;
676 /* Read the first section header at index 0, and convert to internal
677 form. */
678 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
679 goto got_no_match;
680 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
682 /* If the section count is zero, the actual count is in the first
683 section header. */
684 if (i_ehdrp->e_shnum == SHN_UNDEF)
686 i_ehdrp->e_shnum = i_shdr.sh_size;
687 if (i_ehdrp->e_shnum != i_shdr.sh_size
688 || i_ehdrp->e_shnum == 0)
689 goto got_wrong_format_error;
692 /* And similarly for the string table index. */
693 if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff))
695 i_ehdrp->e_shstrndx = i_shdr.sh_link;
696 if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
697 goto got_wrong_format_error;
700 /* Sanity check that we can read all of the section headers.
701 It ought to be good enough to just read the last one. */
702 if (i_ehdrp->e_shnum != 1)
704 /* Check that we don't have a totally silly number of sections. */
705 if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
706 || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
707 goto got_wrong_format_error;
709 where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
710 if (where != (file_ptr) where)
711 goto got_wrong_format_error;
712 if ((bfd_size_type) where <= i_ehdrp->e_shoff)
713 goto got_wrong_format_error;
715 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
716 goto got_no_match;
717 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
718 goto got_no_match;
720 /* Back to where we were. */
721 where = i_ehdrp->e_shoff + sizeof (x_shdr);
722 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
723 goto got_no_match;
727 /* Allocate space for a copy of the section header table in
728 internal form. */
729 if (i_ehdrp->e_shnum != 0)
731 Elf_Internal_Shdr *shdrp;
732 unsigned int num_sec;
734 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
735 i_shdrp = bfd_alloc (abfd, amt);
736 if (!i_shdrp)
737 goto got_no_match;
738 num_sec = i_ehdrp->e_shnum;
739 elf_numsections (abfd) = num_sec;
740 amt = sizeof (i_shdrp) * num_sec;
741 elf_elfsections (abfd) = bfd_alloc (abfd, amt);
742 if (!elf_elfsections (abfd))
743 goto got_no_match;
745 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
746 for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++)
747 elf_elfsections (abfd)[shindex] = shdrp++;
749 /* Read in the rest of the section header table and convert it
750 to internal form. */
751 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
753 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
754 goto got_no_match;
755 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
757 /* Sanity check sh_link and sh_info. */
758 if (i_shdrp[shindex].sh_link >= num_sec)
759 goto got_wrong_format_error;
761 if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
762 || i_shdrp[shindex].sh_type == SHT_RELA
763 || i_shdrp[shindex].sh_type == SHT_REL)
764 && i_shdrp[shindex].sh_info >= num_sec)
765 goto got_wrong_format_error;
767 /* If the section is loaded, but not page aligned, clear
768 D_PAGED. */
769 if (i_shdrp[shindex].sh_size != 0
770 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
771 && i_shdrp[shindex].sh_type != SHT_NOBITS
772 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
773 % ebd->minpagesize)
774 != 0))
775 abfd->flags &= ~D_PAGED;
779 /* A further sanity check. */
780 if (i_ehdrp->e_shnum != 0)
782 if (i_ehdrp->e_shstrndx >= elf_numsections (abfd))
784 /* PR 2257:
785 We used to just goto got_wrong_format_error here
786 but there are binaries in existance for which this test
787 will prevent the binutils from working with them at all.
788 So we are kind, and reset the string index value to 0
789 so that at least some processing can be done. */
790 i_ehdrp->e_shstrndx = SHN_UNDEF;
791 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
794 else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
795 goto got_wrong_format_error;
797 /* Read in the program headers. */
798 if (i_ehdrp->e_phnum == 0)
799 elf_tdata (abfd)->phdr = NULL;
800 else
802 Elf_Internal_Phdr *i_phdr;
803 unsigned int i;
805 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
806 elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
807 if (elf_tdata (abfd)->phdr == NULL)
808 goto got_no_match;
809 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
810 goto got_no_match;
811 i_phdr = elf_tdata (abfd)->phdr;
812 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
814 Elf_External_Phdr x_phdr;
816 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
817 goto got_no_match;
818 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
822 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
824 unsigned int num_sec;
826 /* Once all of the section headers have been read and converted, we
827 can start processing them. Note that the first section header is
828 a dummy placeholder entry, so we ignore it. */
829 num_sec = elf_numsections (abfd);
830 for (shindex = 1; shindex < num_sec; shindex++)
831 if (!bfd_section_from_shdr (abfd, shindex))
832 goto got_no_match;
834 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
835 if (! _bfd_elf_setup_sections (abfd))
836 goto got_wrong_format_error;
839 /* Let the backend double check the format and override global
840 information. */
841 if (ebd->elf_backend_object_p)
843 if (! (*ebd->elf_backend_object_p) (abfd))
844 goto got_wrong_format_error;
847 /* Remember the entry point specified in the ELF file header. */
848 bfd_set_start_address (abfd, i_ehdrp->e_entry);
850 /* If we have created any reloc sections that are associated with
851 debugging sections, mark the reloc sections as debugging as well. */
852 for (s = abfd->sections; s != NULL; s = s->next)
854 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
855 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
856 && elf_section_data (s)->this_hdr.sh_info > 0)
858 unsigned long targ_index;
859 asection *targ_sec;
861 targ_index = elf_section_data (s)->this_hdr.sh_info;
862 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
863 if (targ_sec != NULL
864 && (targ_sec->flags & SEC_DEBUGGING) != 0)
865 s->flags |= SEC_DEBUGGING;
869 bfd_preserve_finish (abfd, &preserve);
870 return target;
872 got_wrong_format_error:
873 /* There is way too much undoing of half-known state here. The caller,
874 bfd_check_format_matches, really shouldn't iterate on live bfd's to
875 check match/no-match like it does. We have to rely on that a call to
876 bfd_default_set_arch_mach with the previously known mach, undoes what
877 was done by the first bfd_default_set_arch_mach (with mach 0) here.
878 For this to work, only elf-data and the mach may be changed by the
879 target-specific elf_backend_object_p function. Note that saving the
880 whole bfd here and restoring it would be even worse; the first thing
881 you notice is that the cached bfd file position gets out of sync. */
882 bfd_set_error (bfd_error_wrong_format);
884 got_no_match:
885 if (preserve.marker != NULL)
886 bfd_preserve_restore (abfd, &preserve);
887 return NULL;
890 /* ELF .o/exec file writing */
892 /* Write out the relocs. */
894 void
895 elf_write_relocs (bfd *abfd, asection *sec, void *data)
897 bfd_boolean *failedp = data;
898 Elf_Internal_Shdr *rela_hdr;
899 bfd_vma addr_offset;
900 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
901 size_t extsize;
902 bfd_byte *dst_rela;
903 unsigned int idx;
904 asymbol *last_sym;
905 int last_sym_idx;
907 /* If we have already failed, don't do anything. */
908 if (*failedp)
909 return;
911 if ((sec->flags & SEC_RELOC) == 0)
912 return;
914 /* The linker backend writes the relocs out itself, and sets the
915 reloc_count field to zero to inhibit writing them here. Also,
916 sometimes the SEC_RELOC flag gets set even when there aren't any
917 relocs. */
918 if (sec->reloc_count == 0)
919 return;
921 /* If we have opened an existing file for update, reloc_count may be
922 set even though we are not linking. In that case we have nothing
923 to do. */
924 if (sec->orelocation == NULL)
925 return;
927 rela_hdr = &elf_section_data (sec)->rel_hdr;
929 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
930 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
931 if (rela_hdr->contents == NULL)
933 *failedp = TRUE;
934 return;
937 /* Figure out whether the relocations are RELA or REL relocations. */
938 if (rela_hdr->sh_type == SHT_RELA)
940 swap_out = elf_swap_reloca_out;
941 extsize = sizeof (Elf_External_Rela);
943 else if (rela_hdr->sh_type == SHT_REL)
945 swap_out = elf_swap_reloc_out;
946 extsize = sizeof (Elf_External_Rel);
948 else
949 /* Every relocation section should be either an SHT_RELA or an
950 SHT_REL section. */
951 abort ();
953 /* The address of an ELF reloc is section relative for an object
954 file, and absolute for an executable file or shared library.
955 The address of a BFD reloc is always section relative. */
956 addr_offset = 0;
957 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
958 addr_offset = sec->vma;
960 /* orelocation has the data, reloc_count has the count... */
961 last_sym = 0;
962 last_sym_idx = 0;
963 dst_rela = rela_hdr->contents;
965 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
967 Elf_Internal_Rela src_rela;
968 arelent *ptr;
969 asymbol *sym;
970 int n;
972 ptr = sec->orelocation[idx];
973 sym = *ptr->sym_ptr_ptr;
974 if (sym == last_sym)
975 n = last_sym_idx;
976 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
977 n = STN_UNDEF;
978 else
980 last_sym = sym;
981 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
982 if (n < 0)
984 *failedp = TRUE;
985 return;
987 last_sym_idx = n;
990 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
991 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
992 && ! _bfd_elf_validate_reloc (abfd, ptr))
994 *failedp = TRUE;
995 return;
998 src_rela.r_offset = ptr->address + addr_offset;
999 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1000 src_rela.r_addend = ptr->addend;
1001 (*swap_out) (abfd, &src_rela, dst_rela);
1005 /* Write out the program headers. */
1008 elf_write_out_phdrs (bfd *abfd,
1009 const Elf_Internal_Phdr *phdr,
1010 unsigned int count)
1012 while (count--)
1014 Elf_External_Phdr extphdr;
1015 elf_swap_phdr_out (abfd, phdr, &extphdr);
1016 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
1017 != sizeof (Elf_External_Phdr))
1018 return -1;
1019 phdr++;
1021 return 0;
1024 /* Write out the section headers and the ELF file header. */
1026 bfd_boolean
1027 elf_write_shdrs_and_ehdr (bfd *abfd)
1029 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1030 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
1031 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
1032 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
1033 unsigned int count;
1034 bfd_size_type amt;
1036 i_ehdrp = elf_elfheader (abfd);
1037 i_shdrp = elf_elfsections (abfd);
1039 /* swap the header before spitting it out... */
1041 #if DEBUG & 1
1042 elf_debug_file (i_ehdrp);
1043 #endif
1044 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1045 amt = sizeof (x_ehdr);
1046 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1047 || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1048 return FALSE;
1050 /* Some fields in the first section header handle overflow of ehdr
1051 fields. */
1052 if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff))
1053 i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1054 if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff))
1055 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1057 /* at this point we've concocted all the ELF sections... */
1058 amt = i_ehdrp->e_shnum;
1059 amt *= sizeof (*x_shdrp);
1060 x_shdrp = bfd_alloc (abfd, amt);
1061 if (!x_shdrp)
1062 return FALSE;
1064 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1066 #if DEBUG & 2
1067 elf_debug_section (count, *i_shdrp);
1068 #endif
1069 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1071 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1072 || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1073 return FALSE;
1075 /* need to dump the string table too... */
1077 return TRUE;
1080 bfd_boolean
1081 elf_checksum_contents (bfd *abfd,
1082 void (*process) (const void *, size_t, void *),
1083 void *arg)
1085 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1086 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
1087 Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr;
1088 unsigned int count, num;
1091 Elf_External_Ehdr x_ehdr;
1092 Elf_Internal_Ehdr i_ehdr;
1094 i_ehdr = *i_ehdrp;
1095 i_ehdr.e_phoff = i_ehdr.e_shoff = 0;
1096 elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr);
1097 (*process) (&x_ehdr, sizeof x_ehdr, arg);
1100 num = i_ehdrp->e_phnum;
1101 for (count = 0; count < num; count++)
1103 Elf_External_Phdr x_phdr;
1104 elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr);
1105 (*process) (&x_phdr, sizeof x_phdr, arg);
1108 num = elf_numsections (abfd);
1109 for (count = 0; count < num; count++)
1111 Elf_Internal_Shdr i_shdr;
1112 Elf_External_Shdr x_shdr;
1114 i_shdr = *i_shdrp[count];
1115 i_shdr.sh_offset = 0;
1117 elf_swap_shdr_out (abfd, &i_shdr, &x_shdr);
1118 (*process) (&x_shdr, sizeof x_shdr, arg);
1120 if (i_shdr.contents)
1121 (*process) (i_shdr.contents, i_shdr.sh_size, arg);
1124 return TRUE;
1127 long
1128 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1130 Elf_Internal_Shdr *hdr;
1131 Elf_Internal_Shdr *verhdr;
1132 unsigned long symcount; /* Number of external ELF symbols */
1133 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1134 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1135 Elf_Internal_Sym *isym;
1136 Elf_Internal_Sym *isymend;
1137 Elf_Internal_Sym *isymbuf = NULL;
1138 Elf_External_Versym *xver;
1139 Elf_External_Versym *xverbuf = NULL;
1140 const struct elf_backend_data *ebd;
1141 bfd_size_type amt;
1143 /* Read each raw ELF symbol, converting from external ELF form to
1144 internal ELF form, and then using the information to create a
1145 canonical bfd symbol table entry.
1147 Note that we allocate the initial bfd canonical symbol buffer
1148 based on a one-to-one mapping of the ELF symbols to canonical
1149 symbols. We actually use all the ELF symbols, so there will be no
1150 space left over at the end. When we have all the symbols, we
1151 build the caller's pointer vector. */
1153 if (! dynamic)
1155 hdr = &elf_tdata (abfd)->symtab_hdr;
1156 verhdr = NULL;
1158 else
1160 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1161 if (elf_dynversym (abfd) == 0)
1162 verhdr = NULL;
1163 else
1164 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1165 if ((elf_tdata (abfd)->dynverdef_section != 0
1166 && elf_tdata (abfd)->verdef == NULL)
1167 || (elf_tdata (abfd)->dynverref_section != 0
1168 && elf_tdata (abfd)->verref == NULL))
1170 if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1171 return -1;
1175 ebd = get_elf_backend_data (abfd);
1176 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1177 if (symcount == 0)
1178 sym = symbase = NULL;
1179 else
1181 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1182 NULL, NULL, NULL);
1183 if (isymbuf == NULL)
1184 return -1;
1186 amt = symcount;
1187 amt *= sizeof (elf_symbol_type);
1188 symbase = bfd_zalloc (abfd, amt);
1189 if (symbase == (elf_symbol_type *) NULL)
1190 goto error_return;
1192 /* Read the raw ELF version symbol information. */
1193 if (verhdr != NULL
1194 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1196 (*_bfd_error_handler)
1197 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1198 abfd->filename,
1199 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1200 symcount);
1202 /* Slurp in the symbols without the version information,
1203 since that is more helpful than just quitting. */
1204 verhdr = NULL;
1207 if (verhdr != NULL)
1209 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1210 goto error_return;
1212 xverbuf = bfd_malloc (verhdr->sh_size);
1213 if (xverbuf == NULL && verhdr->sh_size != 0)
1214 goto error_return;
1216 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1217 goto error_return;
1220 /* Skip first symbol, which is a null dummy. */
1221 xver = xverbuf;
1222 if (xver != NULL)
1223 ++xver;
1224 isymend = isymbuf + symcount;
1225 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1227 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1228 sym->symbol.the_bfd = abfd;
1230 sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1232 sym->symbol.value = isym->st_value;
1234 if (isym->st_shndx == SHN_UNDEF)
1236 sym->symbol.section = bfd_und_section_ptr;
1238 else if (isym->st_shndx == SHN_ABS)
1240 sym->symbol.section = bfd_abs_section_ptr;
1242 else if (isym->st_shndx == SHN_COMMON)
1244 sym->symbol.section = bfd_com_section_ptr;
1245 /* Elf puts the alignment into the `value' field, and
1246 the size into the `size' field. BFD wants to see the
1247 size in the value field, and doesn't care (at the
1248 moment) about the alignment. */
1249 sym->symbol.value = isym->st_size;
1251 else
1253 sym->symbol.section
1254 = bfd_section_from_elf_index (abfd, isym->st_shndx);
1255 if (sym->symbol.section == NULL)
1257 /* This symbol is in a section for which we did not
1258 create a BFD section. Just use bfd_abs_section,
1259 although it is wrong. FIXME. */
1260 sym->symbol.section = bfd_abs_section_ptr;
1264 /* If this is a relocatable file, then the symbol value is
1265 already section relative. */
1266 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1267 sym->symbol.value -= sym->symbol.section->vma;
1269 switch (ELF_ST_BIND (isym->st_info))
1271 case STB_LOCAL:
1272 sym->symbol.flags |= BSF_LOCAL;
1273 break;
1274 case STB_GLOBAL:
1275 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1276 sym->symbol.flags |= BSF_GLOBAL;
1277 break;
1278 case STB_WEAK:
1279 sym->symbol.flags |= BSF_WEAK;
1280 break;
1283 switch (ELF_ST_TYPE (isym->st_info))
1285 case STT_SECTION:
1286 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1287 break;
1288 case STT_FILE:
1289 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1290 break;
1291 case STT_FUNC:
1292 sym->symbol.flags |= BSF_FUNCTION;
1293 break;
1294 case STT_COMMON:
1295 /* FIXME: Do we have to put the size field into the value field
1296 as we do with symbols in SHN_COMMON sections (see above) ? */
1297 /* Fall through. */
1298 case STT_OBJECT:
1299 sym->symbol.flags |= BSF_OBJECT;
1300 break;
1301 case STT_TLS:
1302 sym->symbol.flags |= BSF_THREAD_LOCAL;
1303 break;
1304 case STT_RELC:
1305 sym->symbol.flags |= BSF_RELC;
1306 break;
1307 case STT_SRELC:
1308 sym->symbol.flags |= BSF_SRELC;
1309 break;
1312 if (dynamic)
1313 sym->symbol.flags |= BSF_DYNAMIC;
1315 if (xver != NULL)
1317 Elf_Internal_Versym iversym;
1319 _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1320 sym->version = iversym.vs_vers;
1321 xver++;
1324 /* Do some backend-specific processing on this symbol. */
1325 if (ebd->elf_backend_symbol_processing)
1326 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1330 /* Do some backend-specific processing on this symbol table. */
1331 if (ebd->elf_backend_symbol_table_processing)
1332 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1334 /* We rely on the zalloc to clear out the final symbol entry. */
1336 symcount = sym - symbase;
1338 /* Fill in the user's symbol pointer vector if needed. */
1339 if (symptrs)
1341 long l = symcount;
1343 sym = symbase;
1344 while (l-- > 0)
1346 *symptrs++ = &sym->symbol;
1347 sym++;
1349 *symptrs = 0; /* Final null pointer */
1352 if (xverbuf != NULL)
1353 free (xverbuf);
1354 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1355 free (isymbuf);
1356 return symcount;
1358 error_return:
1359 if (xverbuf != NULL)
1360 free (xverbuf);
1361 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1362 free (isymbuf);
1363 return -1;
1366 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1367 them. */
1369 static bfd_boolean
1370 elf_slurp_reloc_table_from_section (bfd *abfd,
1371 asection *asect,
1372 Elf_Internal_Shdr *rel_hdr,
1373 bfd_size_type reloc_count,
1374 arelent *relents,
1375 asymbol **symbols,
1376 bfd_boolean dynamic)
1378 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1379 void *allocated = NULL;
1380 bfd_byte *native_relocs;
1381 arelent *relent;
1382 unsigned int i;
1383 int entsize;
1384 unsigned int symcount;
1386 allocated = bfd_malloc (rel_hdr->sh_size);
1387 if (allocated == NULL)
1388 goto error_return;
1390 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1391 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1392 != rel_hdr->sh_size))
1393 goto error_return;
1395 native_relocs = allocated;
1397 entsize = rel_hdr->sh_entsize;
1398 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1399 || entsize == sizeof (Elf_External_Rela));
1401 if (dynamic)
1402 symcount = bfd_get_dynamic_symcount (abfd);
1403 else
1404 symcount = bfd_get_symcount (abfd);
1406 for (i = 0, relent = relents;
1407 i < reloc_count;
1408 i++, relent++, native_relocs += entsize)
1410 Elf_Internal_Rela rela;
1412 if (entsize == sizeof (Elf_External_Rela))
1413 elf_swap_reloca_in (abfd, native_relocs, &rela);
1414 else
1415 elf_swap_reloc_in (abfd, native_relocs, &rela);
1417 /* The address of an ELF reloc is section relative for an object
1418 file, and absolute for an executable file or shared library.
1419 The address of a normal BFD reloc is always section relative,
1420 and the address of a dynamic reloc is absolute.. */
1421 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1422 relent->address = rela.r_offset;
1423 else
1424 relent->address = rela.r_offset - asect->vma;
1426 if (ELF_R_SYM (rela.r_info) == 0)
1427 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1428 else if (ELF_R_SYM (rela.r_info) > symcount)
1430 (*_bfd_error_handler)
1431 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1432 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1433 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1435 else
1437 asymbol **ps;
1439 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1441 relent->sym_ptr_ptr = ps;
1444 relent->addend = rela.r_addend;
1446 if ((entsize == sizeof (Elf_External_Rela)
1447 && ebd->elf_info_to_howto != NULL)
1448 || ebd->elf_info_to_howto_rel == NULL)
1449 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1450 else
1451 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1454 if (allocated != NULL)
1455 free (allocated);
1457 return TRUE;
1459 error_return:
1460 if (allocated != NULL)
1461 free (allocated);
1462 return FALSE;
1465 /* Read in and swap the external relocs. */
1467 bfd_boolean
1468 elf_slurp_reloc_table (bfd *abfd,
1469 asection *asect,
1470 asymbol **symbols,
1471 bfd_boolean dynamic)
1473 struct bfd_elf_section_data * const d = elf_section_data (asect);
1474 Elf_Internal_Shdr *rel_hdr;
1475 Elf_Internal_Shdr *rel_hdr2;
1476 bfd_size_type reloc_count;
1477 bfd_size_type reloc_count2;
1478 arelent *relents;
1479 bfd_size_type amt;
1481 if (asect->relocation != NULL)
1482 return TRUE;
1484 if (! dynamic)
1486 if ((asect->flags & SEC_RELOC) == 0
1487 || asect->reloc_count == 0)
1488 return TRUE;
1490 rel_hdr = &d->rel_hdr;
1491 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1492 rel_hdr2 = d->rel_hdr2;
1493 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1495 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1496 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1497 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1500 else
1502 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1503 case because relocations against this section may use the
1504 dynamic symbol table, and in that case bfd_section_from_shdr
1505 in elf.c does not update the RELOC_COUNT. */
1506 if (asect->size == 0)
1507 return TRUE;
1509 rel_hdr = &d->this_hdr;
1510 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1511 rel_hdr2 = NULL;
1512 reloc_count2 = 0;
1515 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1516 relents = bfd_alloc (abfd, amt);
1517 if (relents == NULL)
1518 return FALSE;
1520 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1521 rel_hdr, reloc_count,
1522 relents,
1523 symbols, dynamic))
1524 return FALSE;
1526 if (rel_hdr2
1527 && !elf_slurp_reloc_table_from_section (abfd, asect,
1528 rel_hdr2, reloc_count2,
1529 relents + reloc_count,
1530 symbols, dynamic))
1531 return FALSE;
1533 asect->relocation = relents;
1534 return TRUE;
1537 #if DEBUG & 2
1538 static void
1539 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1541 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1542 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1543 (long) hdr);
1544 fprintf (stderr,
1545 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1546 (long) hdr->sh_name,
1547 (long) hdr->sh_type,
1548 (long) hdr->sh_flags);
1549 fprintf (stderr,
1550 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1551 (long) hdr->sh_addr,
1552 (long) hdr->sh_offset,
1553 (long) hdr->sh_size);
1554 fprintf (stderr,
1555 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1556 (long) hdr->sh_link,
1557 (long) hdr->sh_info,
1558 (long) hdr->sh_addralign);
1559 fprintf (stderr, "sh_entsize = %ld\n",
1560 (long) hdr->sh_entsize);
1561 fflush (stderr);
1563 #endif
1565 #if DEBUG & 1
1566 static void
1567 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1569 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1570 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1571 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1572 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1573 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1574 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1575 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1577 #endif
1579 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1580 reconstruct an ELF file by reading the segments out of remote memory
1581 based on the ELF file header at EHDR_VMA and the ELF program headers it
1582 points to. If not null, *LOADBASEP is filled in with the difference
1583 between the VMAs from which the segments were read, and the VMAs the
1584 file headers (and hence BFD's idea of each section's VMA) put them at.
1586 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1587 remote memory at target address VMA into the local buffer at MYADDR; it
1588 should return zero on success or an `errno' code on failure. TEMPL must
1589 be a BFD for a target with the word size and byte order found in the
1590 remote memory. */
1592 bfd *
1593 NAME(_bfd_elf,bfd_from_remote_memory)
1594 (bfd *templ,
1595 bfd_vma ehdr_vma,
1596 bfd_vma *loadbasep,
1597 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1599 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1600 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */
1601 Elf_External_Phdr *x_phdrs;
1602 Elf_Internal_Phdr *i_phdrs, *last_phdr;
1603 bfd *nbfd;
1604 struct bfd_in_memory *bim;
1605 int contents_size;
1606 bfd_byte *contents;
1607 int err;
1608 unsigned int i;
1609 bfd_vma loadbase;
1610 bfd_boolean loadbase_set;
1612 /* Read in the ELF header in external format. */
1613 err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1614 if (err)
1616 bfd_set_error (bfd_error_system_call);
1617 errno = err;
1618 return NULL;
1621 /* Now check to see if we have a valid ELF file, and one that BFD can
1622 make use of. The magic number must match, the address size ('class')
1623 and byte-swapping must match our XVEC entry. */
1625 if (! elf_file_p (&x_ehdr)
1626 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1627 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1629 bfd_set_error (bfd_error_wrong_format);
1630 return NULL;
1633 /* Check that file's byte order matches xvec's */
1634 switch (x_ehdr.e_ident[EI_DATA])
1636 case ELFDATA2MSB: /* Big-endian */
1637 if (! bfd_header_big_endian (templ))
1639 bfd_set_error (bfd_error_wrong_format);
1640 return NULL;
1642 break;
1643 case ELFDATA2LSB: /* Little-endian */
1644 if (! bfd_header_little_endian (templ))
1646 bfd_set_error (bfd_error_wrong_format);
1647 return NULL;
1649 break;
1650 case ELFDATANONE: /* No data encoding specified */
1651 default: /* Unknown data encoding specified */
1652 bfd_set_error (bfd_error_wrong_format);
1653 return NULL;
1656 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1658 /* The file header tells where to find the program headers.
1659 These are what we use to actually choose what to read. */
1661 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1663 bfd_set_error (bfd_error_wrong_format);
1664 return NULL;
1667 x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1668 if (x_phdrs == NULL)
1670 bfd_set_error (bfd_error_no_memory);
1671 return NULL;
1673 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1674 i_ehdr.e_phnum * sizeof x_phdrs[0]);
1675 if (err)
1677 free (x_phdrs);
1678 bfd_set_error (bfd_error_system_call);
1679 errno = err;
1680 return NULL;
1682 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1684 contents_size = 0;
1685 last_phdr = NULL;
1686 loadbase = ehdr_vma;
1687 loadbase_set = FALSE;
1688 for (i = 0; i < i_ehdr.e_phnum; ++i)
1690 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1691 if (i_phdrs[i].p_type == PT_LOAD)
1693 bfd_vma segment_end;
1694 segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1695 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1696 if (segment_end > (bfd_vma) contents_size)
1697 contents_size = segment_end;
1699 /* LOADADDR is the `Base address' from the gELF specification:
1700 `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1701 first PT_LOAD as PT_LOADs are ordered by P_VADDR. */
1702 if (!loadbase_set && (i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1704 loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1705 loadbase_set = TRUE;
1708 last_phdr = &i_phdrs[i];
1711 if (last_phdr == NULL)
1713 /* There were no PT_LOAD segments, so we don't have anything to read. */
1714 free (x_phdrs);
1715 bfd_set_error (bfd_error_wrong_format);
1716 return NULL;
1719 /* Trim the last segment so we don't bother with zeros in the last page
1720 that are off the end of the file. However, if the extra bit in that
1721 page includes the section headers, keep them. */
1722 if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1723 && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1724 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1726 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1727 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1728 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1729 contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1731 else
1732 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1734 /* Now we know the size of the whole image we want read in. */
1735 contents = bfd_zmalloc (contents_size);
1736 if (contents == NULL)
1738 free (x_phdrs);
1739 bfd_set_error (bfd_error_no_memory);
1740 return NULL;
1743 for (i = 0; i < i_ehdr.e_phnum; ++i)
1744 if (i_phdrs[i].p_type == PT_LOAD)
1746 bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1747 bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1748 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1749 if (end > (bfd_vma) contents_size)
1750 end = contents_size;
1751 err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1752 & -i_phdrs[i].p_align,
1753 contents + start, end - start);
1754 if (err)
1756 free (x_phdrs);
1757 free (contents);
1758 bfd_set_error (bfd_error_system_call);
1759 errno = err;
1760 return NULL;
1763 free (x_phdrs);
1765 /* If the segments visible in memory didn't include the section headers,
1766 then clear them from the file header. */
1767 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1768 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1770 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1771 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1772 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1775 /* This will normally have been in the first PT_LOAD segment. But it
1776 conceivably could be missing, and we might have just changed it. */
1777 memcpy (contents, &x_ehdr, sizeof x_ehdr);
1779 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1780 bim = bfd_malloc (sizeof (struct bfd_in_memory));
1781 if (bim == NULL)
1783 free (contents);
1784 bfd_set_error (bfd_error_no_memory);
1785 return NULL;
1787 nbfd = _bfd_new_bfd ();
1788 if (nbfd == NULL)
1790 free (bim);
1791 free (contents);
1792 bfd_set_error (bfd_error_no_memory);
1793 return NULL;
1795 nbfd->filename = "<in-memory>";
1796 nbfd->xvec = templ->xvec;
1797 bim->size = contents_size;
1798 bim->buffer = contents;
1799 nbfd->iostream = bim;
1800 nbfd->flags = BFD_IN_MEMORY;
1801 nbfd->direction = read_direction;
1802 nbfd->mtime = time (NULL);
1803 nbfd->mtime_set = TRUE;
1805 if (loadbasep)
1806 *loadbasep = loadbase;
1807 return nbfd;
1810 #include "elfcore.h"
1812 /* Size-dependent data and functions. */
1813 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1814 sizeof (Elf_External_Ehdr),
1815 sizeof (Elf_External_Phdr),
1816 sizeof (Elf_External_Shdr),
1817 sizeof (Elf_External_Rel),
1818 sizeof (Elf_External_Rela),
1819 sizeof (Elf_External_Sym),
1820 sizeof (Elf_External_Dyn),
1821 sizeof (Elf_External_Note),
1824 ARCH_SIZE, LOG_FILE_ALIGN,
1825 ELFCLASS, EV_CURRENT,
1826 elf_write_out_phdrs,
1827 elf_write_shdrs_and_ehdr,
1828 elf_checksum_contents,
1829 elf_write_relocs,
1830 elf_swap_symbol_in,
1831 elf_swap_symbol_out,
1832 elf_slurp_reloc_table,
1833 elf_slurp_symbol_table,
1834 elf_swap_dyn_in,
1835 elf_swap_dyn_out,
1836 elf_swap_reloc_in,
1837 elf_swap_reloc_out,
1838 elf_swap_reloca_in,
1839 elf_swap_reloca_out